updated with final touches (#682)

.dockerignore

@@ -1,6 +1,5 @@
 backend/**.db
 backend/tmp
-backend/backend*
 backend/vendor/**
 frontend/dist/**
 frontend/node_modules/**

.github/workflows/pr.yaml

@@ -3,117 +3,85 @@ name: PR Request
 on:
   pull_request:
     branches:
-      - "main"
-      - "dev/v*.*.*"
-      - "beta/v*.*.*"
-      - "stable/v*.*.*"
+      - "dev/v[0-9]+.[0-9]+.[0-9]+"
+      - "beta/v[0-9]+.[0-9]+.[0-9]+"
+      - "stable/v[0-9]+.[0-9]+.[0-9]+"
+
 jobs:
-  prime_docker_cache:
-    name: Prime docker cache
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Prime Cache
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          file: _docker/Dockerfile.primecache
-          push: false
-          load: false
-          cache-to: |
-            type=gha,mode=max,scope=${{ github.ref_name }}-playwright-base
-  build_frontend:
-    name: Build frontend
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-      - name: Build frontend
-        working-directory: frontend
-        run: npm i && npm run build
-      - name: Upload frontend build artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: dist
-          path: backend/http/dist
-  build_backend:
-    name: Build backend
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - uses: actions/setup-go@v5
-        with:
-          go-version: 'stable'
-      - name: Build backend
-        working-directory: backend
-        run: go build -o filebrowser .
-      - name: Upload backend build artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: filebrowser
-          path: backend/filebrowser
   test_playwright:
-    needs: [build_backend, build_frontend, prime_docker_cache]
-    name: Test Playwright - ${{ matrix.name }}
+    name: Test Playwright - general
     runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - name: general
-            dockerfile: ./_docker/Dockerfile.playwright-general
-          - name: proxy
-            dockerfile: ./_docker/Dockerfile.playwright-proxy
-          - name: noauth
-            dockerfile: ./_docker/Dockerfile.playwright-noauth
-          - name: oidc
-            dockerfile: ./_docker/Dockerfile.playwright-oidc
-          - name: sharing
-            dockerfile: ./_docker/Dockerfile.playwright-sharing
     steps:
       - name: Checkout
         uses: actions/checkout@v4
-      - name: Download frontend build
-        uses: actions/download-artifact@v4
-        with:
-          name: dist
-          path: frontend/dist
-      - name: Download backend build
-        uses: actions/download-artifact@v4
-        with:
-          name: filebrowser
-          path: backend/
-      - name: Make backend executable
-        run: chmod +x backend/filebrowser
-      - name: Copy frontend build to backend
-        run: |
-          mkdir -p backend/http/embed
-          cp -r frontend/dist/* backend/http/embed
       - 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 and Test
-        id: build
+      - uses: actions/setup-node@v4
+      - working-directory: frontend
+        run: npm i && npm run build
+      - uses: actions/setup-go@v5
+        with:
+          go-version: 'stable'
+      - working-directory: backend
+        run: go build -o filebrowser .
+      - name: Build
         uses: docker/build-push-action@v6
         with:
           context: .
-          file: ${{ matrix.dockerfile }}
+          file: ./_docker/Dockerfile.playwright-general
+          push: false
+  test_playwright_proxy:
+    name: Test Playwright - proxy
+    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
+      - uses: actions/setup-node@v4
+      - working-directory: frontend
+        run: npm i && npm run build
+      - uses: actions/setup-go@v5
+        with:
+          go-version: 'stable'
+      - working-directory: backend
+        run: go build -o filebrowser .
+      - name: Build
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ./_docker/Dockerfile.playwright-proxy
+          push: false
+  test_playwright_noauth:
+    name: Test Playwright - noauth
+    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
+      - uses: actions/setup-node@v4
+      - working-directory: frontend
+        run: npm i && npm run build
+      - uses: actions/setup-go@v5
+        with:
+          go-version: 'stable'
+      - working-directory: backend
+        run: go build -o filebrowser .
+      - name: Build
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ./_docker/Dockerfile.playwright-noauth
           push: false
-          load: true
-          cache-from: |
-            type=gha,scope=${{ github.ref_name }}-playwright-base
-            type=gha,scope=main-playwright-base
-          cache-to: |
-            type=gha,mode=max,scope=${{ github.ref_name }}-playwright-base
   push_pr_to_registry:
-    if: github.event.pull_request.head.repo.fork == false
-    name: Build docker image
+    name: Push PR
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
@@ -136,12 +104,10 @@ jobs:
         uses: docker/build-push-action@v6
         with:
           context: .
-          file: ./_docker/Dockerfile.slim
+          file: ./_docker/Dockerfile
           push: false # Do not push the image for now
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
           build-args: |
             VERSION=${{ steps.meta.outputs.version }}
-            REVISION=${{ steps.meta.outputs.revision }}
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
+            REVISION=${{ steps.meta.outputs.revision }}

.github/workflows/regular-tests.yaml

@@ -1,7 +1,7 @@
 name: regular tests
 
 on:
-  pull_request:
+  push:
     branches:
       - "**"
 
@@ -22,11 +22,10 @@ jobs:
       - uses: actions/setup-go@v5
         with:
             go-version: 'stable'
-      - uses: golangci/golangci-lint-action@v7
+      - uses: golangci/golangci-lint-action@v5
         with:
-          version: 'v2.1.6'
+          version: 'v1.64'
           working-directory: backend
-          install-mode: goinstall
   format-backend:
     runs-on: ubuntu-latest
     steps:

.github/workflows/release_dev.yaml

@@ -55,7 +55,7 @@ jobs:
           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
+          platforms: linux/amd64
           file: ./_docker/Dockerfile
           push: true
           tags: ${{ steps.modify-json.outputs.cleaned_tag }}

.github/workflows/release_docker.yaml

@@ -0,0 +1,125 @@
+name: Manual Docker Build
+
+on:
+  workflow_dispatch:
+    inputs:
+      branch:
+        description: "Tag or Branch (format: v0.0.0-beta)"
+        required: true
+        type: string
+
+permissions:
+  contents: write
+
+jobs:
+  push_release_to_registry:
+    name: Push release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.PAT }} # Uses the Personal Access Token
+          ref: "${{ github.event.inputs.branch }}"
+      - 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: Login to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{github.actor}}
+          password: ${{ secrets.PAT }}
+      - name: Extract metadata (tags, labels) for Docker and GHCR
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: |
+            gtstef/filebrowser
+            ghcr.io/gtsteffaniak/filebrowser
+          tags: |
+            type=raw,value=${{ github.event.inputs.branch }}
+      - name: Modify tags (strip 'v' and add 'beta'/'stable' if needed)
+        id: modify-json
+        run: |
+          JSON='${{ steps.meta.outputs.json }}'
+          MODIFIED_JSON=$(echo "$JSON" | jq '
+            .tags |= map(sub(":v"; ":")) |
+            if any(.tags[]; test("beta")) then
+              .tags += [
+                "gtstef/filebrowser:beta",
+                "ghcr.io/gtsteffaniak/filebrowser:beta",
+                "gtstef/filebrowser:latest",
+                "ghcr.io/gtsteffaniak/filebrowser:latest"
+              ]
+            else . end |
+            if any(.tags[]; test("stable")) then
+              .tags += [
+                "gtstef/filebrowser:stable",
+                "ghcr.io/gtsteffaniak/filebrowser:stable",
+                "gtstef/filebrowser:latest",
+                "ghcr.io/gtsteffaniak/filebrowser:latest"
+              ]
+            else . end
+          ')
+          TAGS_CSV=$(echo "$MODIFIED_JSON" | jq -r '.tags | join(",")')
+          echo "$TAGS_CSV" > modified_tags.txt  # Optional debug output
+          echo "cleaned_tag=$TAGS_CSV" >> $GITHUB_OUTPUT
+      - name: Build and push
+        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: ./_docker/Dockerfile
+          push: true
+          tags: ${{ steps.modify-json.outputs.cleaned_tag }}
+          labels: ${{ steps.meta.outputs.labels }}
+      - name: Modify version names
+        id: modify-json-media
+        run: |
+          JSON='${{ steps.meta.outputs.json }}'
+          MODIFIED_JSON=$(echo "$JSON" | jq '
+            .tags |= map(
+              sub(":v"; ":") + "-media"
+            ) |
+            if any(.tags[]; test("beta-media")) then
+              .tags += [
+                "gtstef/filebrowser:beta-media",
+                "ghcr.io/gtsteffaniak/filebrowser:beta-media",
+                "gtstef/filebrowser:media",
+                "ghcr.io/gtsteffaniak/filebrowser:media"
+              ]
+            else . end |
+            if any(.tags[]; test("stable-media")) then
+              .tags += [
+                "gtstef/filebrowser:stable-media",
+                "ghcr.io/gtsteffaniak/filebrowser:stable-media",
+                "gtstef/filebrowser:media",
+                "ghcr.io/gtsteffaniak/filebrowser:media"
+              ]
+            else . end
+          ')
+          TAGS_CSV=$(echo "$MODIFIED_JSON" | jq -r '.tags | join(",")')
+          echo "$TAGS_CSV" > modified_tags.txt  # Optional debug output
+          echo "cleaned_tag=$TAGS_CSV" >> $GITHUB_OUTPUT
+      - name: Build and push media image
+        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'] }}
+          file: ./_docker/Dockerfile.media
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: ${{ steps.modify-json-media.outputs.cleaned_tag }}
+          labels: ${{ steps.meta.outputs.labels }}

.github/workflows/tag.yaml

@@ -20,9 +20,8 @@ jobs:
       - name: Install dependencies and build frontend
         run: npm i && npm run build
         working-directory: frontend
-      - name: Install OS Requirements
-        run: sudo apt update && sudo apt install -y upx build-essential musl-tools
-      - uses: goto-bus-stop/setup-zig@v2
+      - name: Install UPX
+        run: sudo apt-get install -y upx
       - name: Run GoReleaser
         uses: goreleaser/goreleaser-action@v6
         with:
@@ -64,10 +63,7 @@ jobs:
         run: |
           JSON='${{ steps.meta.outputs.json }}'
           MODIFIED_JSON=$(echo "$JSON" | jq '
-            .tags |= map(
-              sub(":v"; ":")      # Strip the 'v'
-              | select(test(":latest") | not)
-            ) |
+            .tags |= map(sub(":v"; ":")) |
             if any(.tags[]; test("beta")) then
               .tags += [
                 "gtstef/filebrowser:beta",
@@ -95,73 +91,8 @@ jobs:
           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
+          platforms: linux/amd64,linux/arm64,linux/arm/v7
           file: ./_docker/Dockerfile
           push: true
           tags: ${{ steps.modify-json.outputs.cleaned_tag }}
           labels: ${{ steps.meta.outputs.labels }}
-  push_slim_release_to_registry:
-    name: Push slim 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: Login to GitHub Container Registry
-        uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{github.actor}}
-          password: ${{ secrets.PAT }}
-      - name: Extract metadata (tags, labels) for Docker and GHCR
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: |
-            gtstef/filebrowser
-            ghcr.io/gtsteffaniak/filebrowser
-      - name: Modify tags (strip 'v' and add 'slim' if needed)
-        id: modify-json-slim
-        run: |
-          JSON='${{ steps.meta.outputs.json }}'
-          MODIFIED_JSON=$(echo "$JSON" | jq '
-            .tags |= map(
-              sub(":v"; ":")                 # Strip the 'v'
-              | select(test(":latest") | not) # Remove the "latest" tag
-              | . + "-slim"                   # Append "-slim" to the versioned tag
-            ) |
-            if any(.tags[]; test("beta")) then
-              .tags += [
-                "gtstef/filebrowser:beta-slim",
-                "ghcr.io/gtsteffaniak/filebrowser:beta-slim"
-              ]
-            else . end |
-            if any(.tags[]; test("stable")) then
-              .tags += [
-                "gtstef/filebrowser:stable-slim",
-                "ghcr.io/gtsteffaniak/filebrowser:stable-slim"
-              ]
-            else . end
-          ')
-          TAGS_CSV=$(echo "$MODIFIED_JSON" | jq -r '.tags | join(",")')
-          echo "cleaned_tag=$TAGS_CSV" >> $GITHUB_OUTPUT
-      - name: Build and push slim image
-        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: ./_docker/Dockerfile.slim
-          push: true
-          tags: ${{ steps.modify-json-slim.outputs.cleaned_tag }}
-          labels: ${{ steps.meta.outputs.labels }}

.gitignore

@@ -10,7 +10,6 @@ rice-box.go
 /backend/filebrowser.exe
 /backend/backend.exe
 /backend/tmp
-/backend/dist
 /frontend/dist
 /frontend/pkg
 /frontend/test-results
@@ -48,4 +47,3 @@ yarn-error.log*
 bin/
 build/
 *__debug*
-backend/custom.css

CHANGELOG.md

@@ -2,426 +2,6 @@
 
 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.8.4-beta
-
- **New Features**:
- - Remember folder view type (and sorting) for each folder #966
- - heic is supported in preview and viewer (via conversion) when on non-safari browser #1191
-
- **Notes**:
-
- **BugFixes**:
- - Access Management: issue with access settings #1195
- - fix shutdown panic related to sse connection
-
-## v0.8.4-beta
-
- **New Features**:
- - New media player styles and features
-   - Custom Media Player: enhanced media player using plyr thanks @Kurami32 (see #1160)
-   - Custom Media Player: also adds support for metadata
-   - added embeded video subtitle support (for both native and custom player). @maxbin123 #1072 #1157
-   - Users can disable the customer player and opt of native in profile settings.
- - Option to disable backend update check via `server.disableUpdateCheck` #1134
- - added `frontend.favicon` and `frontend.description` for html overrides
- - onlyoffice is now supported in shares. Both viewing and editing can be configured per-share.
- - Added only office debug view and wiki to assist with debugging issues #1068 #911 #1074
- - Dark mode enforcement possible for shared links #1029
- - added `System & Admin` section to settings
-   - includes a new config viewer to see current running config (hides secrets) #838
- - added `server.minSearchLength` to allow adjusting the length requirement for search #1174
-
- **Notes**:
- - access management: specific folders/files with access are shown instead permission denied for parent folder
- - navigation no longer appends last location hash which should fix some unwanted navation behavior #1070
- - altered the context menu style and behavior.
- - documentation update: comma or Space separated extensions #1138
- - Files and folders can be created with "/" or "\" on the name #1126
- - Share management should not be allowed without authentication #1163
- - Question about customizing session timeout #1184
-
- **BugFixes**:
- - access management: delay showing rule changes in the list fixed. #1131
- - Color names are not localized #1159
- - rename issues #1170 #1171
- - some shortcuts not working #1056
- - Can't copy/paste text on mobile #1168
- - Can't change between images inside of the share image viewer. #1144
- - fixed and updated translations with variables always showing english.
-
-## v0.8.3-beta
-
- **BugFixes**:
- - fixed search bar style bug in mobile #1147
-
-## v0.8.2-beta
-
- **New Features**:
- - added `source.config.denyByDefault` configuration to enable a deny-by-default access rule. A source enabled with this will deny access unless an "allow" rule was specifically created. (Similar to creating a root-level denyAll rule)
- - allow oidc user source access and permission based on username and groups is fulfilled by denyByDefault source with access rules https://github.com/gtsteffaniak/filebrowser/issues/824
- - "open parent folder" in context menu and search results https://github.com/gtsteffaniak/filebrowser/issues/1121
- - added friendly "share not found" page.
-
- **Notes**:
- - 8.0 ffmpeg version bundled with docker
- - go 1.25 upgrade with green tea GC enabled
- - totp secrets accept non-secure strings, only throwing warning
- - adjusted download limit so it also counts viewing text "content" of files (like in editor). You can also "disable file viewing" to stop the editor from showing. lower quality file image previews are not counted as downloads.
- - updated invalid share message to be more clear https://github.com/gtsteffaniak/filebrowser/issues/1120
-
- **BugFixes**:
- - fixed /public/static routes issue
- - shares redirect to login - https://github.com/gtsteffaniak/filebrowser/issues/1109
- - some static assets not available to anonymous user - https://github.com/gtsteffaniak/filebrowser/issues/1102
- - more safari style issues https://github.com/gtsteffaniak/filebrowser/issues/1110
- - fix public share download issues https://github.com/gtsteffaniak/filebrowser/issues/1118 https://github.com/gtsteffaniak/filebrowser/issues/1089
- - fixed disable file viewer setting and enforced on backend
-
-## v0.8.1-beta
-
- **New Features**:
- - api for generate download link (see swagger) https://github.com/gtsteffaniak/filebrowser/issues/1007
- - added `source.config.disabled` option to disable a source without removing it from config file.
- - added `source.config.private` option to designate as private -- currently just means no sharing permitted.
- - hide share card in share
- - download count for a share shows up on share management
-
- **Notes**:
- - updated description for indexingIntervalMinutes https://github.com/gtsteffaniak/filebrowser/issues/1067
-
- **BugFixes**:
- - fixed styling issues https://github.com/gtsteffaniak/filebrowser/issues/1086 https://github.com/gtsteffaniak/filebrowser/issues/1081 https://github.com/gtsteffaniak/filebrowser/issues/1082 https://github.com/gtsteffaniak/filebrowser/issues/1098
- - fix download limit issue https://github.com/gtsteffaniak/filebrowser/issues/1085
- - fixed oidc user defaults for new user https://github.com/gtsteffaniak/filebrowser/issues/1071
- - shares get updated when files moved in ui https://github.com/gtsteffaniak/filebrowser/issues/760
- - click listing behavior doesn't clear (introduced in 0.8.0) https://github.com/gtsteffaniak/filebrowser/issues/1101
- - show download count and limit in share list in settings https://github.com/gtsteffaniak/filebrowser/issues/1103
- - fix windows alt+arrow movement issue https://github.com/gtsteffaniak/filebrowser/issues/1094
- - nav memory issue for filenames with brackets https://github.com/gtsteffaniak/filebrowser/issues/1092
- - files with "+"" in name issue https://github.com/gtsteffaniak/filebrowser/issues/1089
- - fixed editor bug in share view https://github.com/gtsteffaniak/filebrowser/issues/1084
- - other share related issues https://github.com/gtsteffaniak/filebrowser/issues/1087 https://github.com/gtsteffaniak/filebrowser/issues/1064
-
-
-## v0.8.0-beta
-
-  This is a major release, new features and changes could introduce breaking behavior. Here are the known potentially breaking changes:
-
-  - all public api and share url's get a `/public` prefix, making it easier to use with a reverse proxy. Any existing share link will still work but get redirected.
-  - a small change to styling you may need to update your custom styling, for example the id `#input` was renamed `#search-input`
-
- **New Features**:
- - New access control system. You can add new allow / deny / denyAll rules for users/groups for specific paths on specific sources.
-   - groups currently only works with provided oidc groups, but will add a full group management option for manual creation. https://github.com/gtsteffaniak/filebrowser/issues/545
- - share view changes -- now aligns with the standard listing view. This means files can be viewed and edited (if permission allows) just like a normal listing.
- - many share links customization enhancements
-   - only share to certain authenticated users https://github.com/gtsteffaniak/filebrowser/issues/656 https://github.com/gtsteffaniak/filebrowser/issues/985
-   - one-time download links
-   - customize share theme https://github.com/gtsteffaniak/filebrowser/issues/827 https://github.com/gtsteffaniak/filebrowser/issues/1029
-   - share link public changes https://github.com/gtsteffaniak/filebrowser/issues/473
-   - shares can be modified/configured after creation.
-   - download throttling for shares
-
- **Notes**:
- - hover effect on list/compact view https://github.com/gtsteffaniak/filebrowser/issues/1036
-
- **BugFixes**:
- - fix new file "true" content issue https://github.com/gtsteffaniak/filebrowser/issues/1048
- - editor allows device default popup https://github.com/gtsteffaniak/filebrowser/issues/1049
-
-## v0.7.18-beta
-
- **Notes**:
- - desktop context menu "select multiple" enabled as optional user default (#1000)
- - onlyoffice readonly document types (".pages", ".numbers", ".key") list (#1018)
- - onlyoffice tweaks to make more consistent, added logging (#1015)
-
- **BugFixes**:
- - fix lightBackground issue (#1021)
- - fix user save issues (#1020, #1027)
- - fix image preview cache issue (#989)
- - fix file/folder count issue (#989)
- - only first file was upload on drag-n-drop (#1024)
-
-## v0.7.17-beta
-
-See an example of custom css styling that uses the reduce-rounded-corners.css by default and allows users to choose other themes. You can add your own themes as well that users can choose from in profile settings:
-
-```
-frontend:
-  styling:
-    lightBackground: "#f0f0f0"   # or names of css colors
-    darkBackground: "#121212"
-    customCSS: "custom.css"  # custom css file always applies first, then user themes on top of that.
-    customThemes:
-      "default": # if "default" is specified as the name, it will be the default option
-        description: "Reduce rounded corners"
-        css: "reduce-rounded-corners.css" # path to css file to use
-      "original":
-        description: "Original rounded theme"
-        css: ""  # you could default to no styling changes this way.
-```
-
- **New Features**:
- - more custom styling options (thanks @mordilloSan for #997)
-   - background colors can be easily set in config
-   - provided an example `reduce-rounded-corners.css` available by default in docker. (#986, #837)
-   - added feature to specify multiple css themes that users can choose from in profile settings
- - swipe between photos on mobile (#825)
-
- **Notes**:
- - changed partition calculations on linux for total disk size (#982)
- - upload conflict detection for folders offers "replace all" if the folder already exists in target location.
-
- **BugFixes**:
- - TOTP prompt not showing generated code issue https://github.com/gtsteffaniak/filebrowser/issues/996
- - select mulitple deselect on mobile (#1002)
- - viewing svg images.
-
-## v0.7.16-beta
-
- **Notes**:
- - more server logging for uploads when debug logging is enabled
-
- **BugFixes**:
- - fix onlyoffice integration viewing bug (#990)
- - fix uploading files with exec permissions (#984)
- - fix redirect on no source path (#989)
- - refresh file info on rename (#989)
- - listing refreshes when uploads finish (#989)
- - disable edit mode for certain onlyoffice files (#971)
-
-## v0.7.15-beta
-
- **New Features**:
- - added userDefault `disableViewingExt`. The new properties apply to all files, not just office.
- - code blocks in markdown viewer have line numbers and each line is highlightable
-
- **Notes**:
- - replaced `disableOfficePreviewExt` with more generally applicable `disablePreviewExt` to disable preview for any specific file type.
- - more tooltip descriptions for settings options
-
- **BugFixes**:
- - fix chinese and other language error (#972, #969)
- - fix docker dockerfile for `docker run` (#973)
- - fix double slash href on single source (#968)
- - fix sources named "files" or "share" issue (#949, #574)
- - focus input field on popups (#976)
- - hopeful fix for size calculation (#982)
- - edit button is not working on .md files (#983)
-
-## v0.7.14-beta
-
- **Notes**:
- - Updated translations https://github.com/gtsteffaniak/filebrowser/issues/957
- - enabled more doc types for onlyoffice https://github.com/gtsteffaniak/filebrowser/discussions/945
-
- **BugFixes**:
- - noauth user issue https://github.com/gtsteffaniak/filebrowser/issues/955
- - error 403 on source name with special characters https://github.com/gtsteffaniak/filebrowser/issues/952
- - delete pictures in previewer issue https://github.com/gtsteffaniak/filebrowser/issues/456
- - trailing slash source name issue https://github.com/gtsteffaniak/filebrowser/issues/920
- - image lazy loading issue causing all items to get previews at one time, not just whats in view.
-
-## v0.7.13-beta
-
- **New Features**:
- - copy and Move files between sources https://github.com/gtsteffaniak/filebrowser/issues/689
- - new enhanced upload prompt
-   - uses chunked uploads https://github.com/gtsteffaniak/filebrowser/issues/770
-   - all or individual uploads can be paused/resumed
-   - individual uploads can be retried
-   - individual file upload progress https://github.com/gtsteffaniak/filebrowser/issues/871
-   - keeps screen on https://github.com/gtsteffaniak/filebrowser/issues/900
-
- **Notes**:
- - lots of UI improvements
- - reworked a lot of the frontend path/source logic to be more consistent.
- - updated sort behavior to be natural sort https://github.com/gtsteffaniak/filebrowser/issues/551
- - optional quick save icon https://github.com/gtsteffaniak/filebrowser/issues/918
- - improved language support: zh-tw chinese traditional (tawain)
-
- **BugFixes**:
- - more accurate disk used calculation -- accounting for hard links and sparse files. https://github.com/gtsteffaniak/filebrowser/issues/921
- - fix api key revoking mechanism
- - fixed shift-select https://github.com/gtsteffaniak/filebrowser/issues/929
- - video preview images on safari https://github.com/gtsteffaniak/filebrowser/issues/932
- - sticky mode isn't sticky https://github.com/gtsteffaniak/filebrowser/issues/916
-
-## v0.7.12-beta
-
-Happy 4th of July!
-
-The most noteworthy change is that no sources will be automatically enabled for any user. In order for a user to use a source, it needs to be added for that user. Or to keep a source available for all users, you can specify `defaultEnabled` in the source config to maintain the same behavior. See the wiki
-
- **New Features**:
- - setting added `deleteWithoutConfirming`, useful for quickly deleting files -- does not apply to folders.
- - more options for minimal UI https://github.com/gtsteffaniak/filebrowser/issues/745
- - dedicated section for sidebar customization in profile settings https://github.com/gtsteffaniak/filebrowser/issues/437
-
- **Notes**:
- - Filebrowser no longer requires a default source, users can be created without any sources.
- - Disables changing login type fallback behavior https://github.com/gtsteffaniak/filebrowser/issues/620
- - Uses calculated index size as "used" and total partition size as "total" https://github.com/gtsteffaniak/filebrowser/issues/875
- - Select multiple won't show up in context menu when using a desktop browser (with keyboard), opting for keyboard shortcuts
- - Updated translations that were not complete, such as simplified chinese https://github.com/gtsteffaniak/filebrowser/issues/895
- - larger min drop target size https://github.com/gtsteffaniak/filebrowser/issues/902
- - refresh page after file actions https://github.com/gtsteffaniak/filebrowser/issues/894
- - improved user PUT handler for easier user modification via API https://github.com/gtsteffaniak/filebrowser/issues/897
- - optional sidebar actions for upload/create https://github.com/gtsteffaniak/filebrowser/issues/885
-
- **BugFixes**:
- - fix delete in preview when moving between pictures. https://github.com/gtsteffaniak/filebrowser/issues/456
- - getting file info issue when indexing is disabled.
- - fixed initial sort order https://github.com/gtsteffaniak/filebrowser/issues/551
- - incorrect filename Drag and Drop fixes https://github.com/gtsteffaniak/filebrowser/issues/880
- - fix share duration always showing just now https://github.com/gtsteffaniak/filebrowser/issues/896
-
-## v0.7.11-beta
-
- **Breaking Changes**:
-  - `auth.resetAdminOnStart` has been removed. Instead, if you have `auth.adminPassword` set it will always be reset on startup. If you want to change your default admin password afterwards, make sure to unset `auth.adminPassword` so it doesn't get reset on startup.
-  - renamed include/exclude rules see [updated example wiki](https://github.com/gtsteffaniak/filebrowser/wiki/Configuration-And-Examples#example-advanced-source-config)!
-
- **New Features**:
- - more comprehensive exclude/include rules (see example wiki above).
-   - include/exclude parts of folder names as well https://github.com/gtsteffaniak/filebrowser/issues/854
-   - include/exclude file or folder names globally.
- - `source.config.neverWatchPaths` is now functional -- a list of paths that get indexed initially, but skips re-indexing. Useful for directories you don't expect to change ever, still show up in search but get don't contribute to indexing time after initial indexing.
-
- **Notes**:
- - updated swagger docs https://github.com/gtsteffaniak/filebrowser/issues/849
-
- **BugFixes**:
- - fix version update notification for binary https://github.com/gtsteffaniak/filebrowser/issues/836
- - ctrl-click cache issue https://github.com/gtsteffaniak/filebrowser/issues/735
- - fix admin user reset OIDC user https://github.com/gtsteffaniak/filebrowser/issues/811 https://github.com/gtsteffaniak/filebrowser/issues/851
- - fix windows and binary muPdf issue https://github.com/gtsteffaniak/filebrowser/issues/744
- - fix logout oidc issue https://github.com/gtsteffaniak/filebrowser/issues/829 https://github.com/gtsteffaniak/filebrowser/issues/662
- - file name upload bug https://github.com/gtsteffaniak/filebrowser/issues/662
- - could not create share with absolute timestamps enabled https://github.com/gtsteffaniak/filebrowser/issues/764
- - context menu off screen issue https://github.com/gtsteffaniak/filebrowser/issues/828
-
-## v0.7.10-beta
-
- **OIDC change**: if you specify `oidc.userIdentifier: "username"`, originally this would map to `preferred_username` but now it maps to `username` explicitly. To maintain the same behavior update your config to `userIdentifier: "preferred_username"`. This was updated to allow for `username` to work as [some might need](https://github.com/gtsteffaniak/filebrowser/pull/789).
-
- **New Features**:
- - Added settings option to stop sidebar from automatically hiding on editor and previews. https://github.com/gtsteffaniak/filebrowser/issues/744
- - Added more secrets loadable from environment variables. https://github.com/gtsteffaniak/filebrowser/issues/790
- - Include/exclude files are checked for existence to assist with configuration, will show as warning if something is configured but doesn't exist.
- - Added open in new tab link for preview items to view the raw picture, pdf, etc. Especially helpful for safari viewing PDF documents. https://github.com/gtsteffaniak/filebrowser/issues/734
- - Added autoplay media toggle in user profile, to automatically play videos and audio.
-
- **Notes**:
- - Allowed to delete default admin user https://github.com/gtsteffaniak/filebrowser/issues/811 https://github.com/gtsteffaniak/filebrowser/issues/762
- - Better try/catch error handling for user feedback for shares https://github.com/gtsteffaniak/filebrowser/issues/732
-
- **BugFixes**:
- - Fix share scope creation issue https://github.com/gtsteffaniak/filebrowser/issues/809
- - Fix oidc token logout issue https://github.com/gtsteffaniak/filebrowser/issues/791
- - Non-admin users OTP issue https://github.com/gtsteffaniak/filebrowser/issues/815
- - Linewrap issue for a few cases https://github.com/gtsteffaniak/filebrowser/issues/810
- - BaseUrl redirect issue with proxies https://github.com/gtsteffaniak/filebrowser/issues/796
- - Fix exclude still shows up in ui issue https://github.com/gtsteffaniak/filebrowser/issues/797
- - Copy/move functions are async https://github.com/gtsteffaniak/filebrowser/issues/812
- - fix subtitle fetch issue https://github.com/gtsteffaniak/filebrowser/issues/766
- - fix location memory issue for url encoded file names
-
-## v0.7.9-beta
-
- **New Features**:
- - Admin users will get a small notification banner for available update in sidebar with link to new release.
-
- **Notes**:
- - docker now defaults to ./data/databse.db as the database path allowing a simplified initial docker-compose.yaml. Existing configurations do not need updating.
- - oidc groups header updates admin permission of existing user (either add/remove if role exists)'
- - builds amd64 binary with musl for compatibility (glic error) https://github.com/gtsteffaniak/filebrowser/issues/755
- - renamed `server.sources.config.disabled` to `server.sources.config.disableIndexing`
- - better support for running with disabled index.
- - small indexing behavior tweaks.
- - markdown viewer hides sidebar https://github.com/gtsteffaniak/filebrowser/issues/744
- - quick download only applies to files
-
- **BugFixes**:
- - subtitles filename issue https://github.com/gtsteffaniak/filebrowser/issues/678
- - search result links not working with custom baseUrl https://github.com/gtsteffaniak/filebrowser/issues/746
- - preview error for office native preview https://github.com/gtsteffaniak/filebrowser/issues/744
- - more source name safety for special characters.
- - shares with special character errors https://github.com/gtsteffaniak/filebrowser/issues/753
- - backspace navigates back a page when typing https://github.com/gtsteffaniak/filebrowser/issues/663
- - markdown viewer scrolling https://github.com/gtsteffaniak/filebrowser/issues/767
- - fix user permissions updated when modifying api key permissions
- - fix language change issue https://github.com/gtsteffaniak/filebrowser/issues/768 https://github.com/gtsteffaniak/filebrowser/issues/487
-
-## v0.7.8-beta
-
-Note: if using oidc, please update from 0.7.7 to resolve invalid_grant issue. Also - oidc no longer creates users automatically by default -- must be enabled.
-
- **New Features**:
- - More oidc user creation options https://github.com/gtsteffaniak/filebrowser/issues/685
-   - `auth.methods.oidc.createUser` must be true to automatically create user, defaults to false.
-   - `auth.methods.oidc.adminGroup` allows using oidc provider group name to enable admin user creation.
-
- **BugFixes**:
- - fix save editor info sometimes saves wrong file. https://github.com/gtsteffaniak/filebrowser/issues/701
- - make ctrl select work on mac or windows. https://github.com/gtsteffaniak/filebrowser/issues/739
- - oidc login failures introduced in 0.7.6 https://github.com/gtsteffaniak/filebrowser/issues/731
- - oidc respects non-default baseURL
-
-## v0.7.7-beta
-
-  This release cleans up some of the native preview (image preview) feature logic. And adds simple docx and epub viewers as well. Going through all of this, I think I know how I can add full-fledge google doc and microsoft office viewer support (no edit). But, for now "onlyOffice" remains the most comprehensive solution with most compatibility and ability to fully edit. One day, I think I will be able to integrate a minimal license-free server into the docker image. But that's something for another time.
-
-  Native preview (image preview) support is also available for linux arm64 and amd64 binaries, and windows exe.
-
- **New Features**:
- - since theres a wider kind of document preview types, a new disableOfficePreviewExt option has been added.
- - native (and simple) docx and epub viewers.
- - Other documents like xlsx get full size image preview when opened and no onlyoffice support.
-
- **Notes**:
- - all text mimetype files have preview support.
- - high-quality preview image sizes bumped from 512x512 to 640x640 to help make text previews readable.
- - no config is allowed and defaults to on source at current directory.
-
- **BugFixes**:
- - fix otp clearing on user save https://github.com/gtsteffaniak/filebrowser/issues/699
- - admin special characters and general login improvements https://github.com/gtsteffaniak/filebrowser/issues/594
- - updated editor caching behavior https://github.com/gtsteffaniak/filebrowser/issues/701
- - move/copy file path issue and overwrite https://github.com/gtsteffaniak/filebrowser/issues/687
- - fix popup preview loading on safari
- - `preview.highQuality` only affects gallery view mode. popop preview is always high quality, and icons are always low quality.
-
-## v0.7.6-beta
-
- **New Features**:
- - native document preview generation enabled for certain document types on the regular docker image (no office integration needed)
-   - supported native document preview types:
-     - ".pdf",  // PDF
-     - ".xps",  // XPS
-     - ".epub", // EPUB
-     - ".mobi", // MOBI
-     - ".fb2",  // FB2
-     - ".cbz",  // CBZ
-     - ".svg",  // SVG
-     - ".txt",  // TXT
-     - ".docx", // DOCX
-     - ".ppt",  // PPT
-     - ".pptx", // PPTX
-     - ".xlsx", // exel XLSX
-     - ".hwp",  // HWP
-     - ".hwp",  // HWPX
- - proxy logout redirectUrl support via `auth.methods.proxy.logoutRedirectUrl` https://github.com/gtsteffaniak/filebrowser/issues/684
-
- **Notes**:
- - image loading placeholders added and remain if image can't be loaded.
- - no more arm32 support on main image -- use a `slim` tagged image.
-
- **BugFixes**:
- - onlyoffice and other cache issues https://github.com/gtsteffaniak/filebrowser/issues/686
- - gallery size indicator centering https://github.com/gtsteffaniak/filebrowser/issues/652
-
 ## v0.7.5-beta
 
  **New Features**

CONTRIBUTING.md

@@ -1,208 +0,0 @@
-# Contributing to FileBrowser Quantum
-
-Thank you for your interest in contributing to FileBrowser Quantum! This guide will help you get started with development.
-
-## Prerequisites
-
-- **Go 1.25+** (see `backend/go.mod`)
-- **Node.js 18.0.0+** with npm 7.0.0+ (see `frontend/package.json`)
-- **Docker** (optional, for containerized development)
-- **Git**
-
-### Optional Tools
-
-- **ffmpeg**: For media features (subtitles, thumbnails, heic)
-  - Ubuntu/Debian: `sudo apt-get install ffmpeg`
-  - macOS: `brew install ffmpeg`
-  - Windows: Download from [ffmpeg.org](https://ffmpeg.org/download.html)
-
-- **mupdf-tools**: For PDF preview generation
-  - Ubuntu/Debian: `sudo apt-get install mupdf-tools`
-  - macOS: `brew install mupdf-tools`
-  - Windows: Download from [mupdf.com](https://mupdf.com/downloads/)
-
-## Quick Start
-
-```bash
-# 1. Clone the repository
-git clone https://github.com/gtsteffaniak/filebrowser.git
-cd filebrowser
-
-# 2. Initial setup - installs dependencies and creates test config
-make setup
-
-# 3. Run in development mode with hot-reloading
-make dev
-```
-
-`make setup` installs all dependencies and creates a test configuration file.
-`make run` starts the development server. Note: changes require ctrl+c and re-run.
-
-## Project Architecture
-
-### Backend (Go)
-- **Entry Point**: `backend/main.go` → `backend/cmd/`
-- **HTTP Server**: `backend/http/` - API routes, middleware, auth
-- **Storage**: BoltDB via `backend/database/storage/`
-- **Authentication**: Multiple providers in `backend/auth/`
-- **Indexing**: Real-time search in `backend/indexing/`
-- **Previews**: Image/video/document generation in `backend/preview/`
-
-### Frontend (Vue.js + TypeScript)
-- **Framework**: Vue 3 + Vite + TypeScript
-- **State**: Custom store in `frontend/src/store/`
-- **API Client**: Axios-based in `frontend/src/api/`
-- **i18n**: 25+ languages with English as main
-- **Components**: Feature-based organization
-
-## Development Commands
-
-### Essential Commands
-```bash
-make dev          # Start development server with hot-reloading
-make test         # Run all tests
-make lint         # Check code quality
-make check-all    # Lint + tests
-
-make build-frontend  # Build frontend only
-make build-backend   # Build backend only
-make build          # Build Docker image
-```
-
-### Frontend Development
-
-Note: consider using make commands above instead.
-```bash
-cd frontend
-npm run lint:fix  # Auto-fix linting issues
-npm run i18n:sync # Sync translations changes
-```
-
-## Testing
-
-### Running Tests
-```bash
-make test              # All tests
-make test-backend      # Go tests with race detection
-make test-frontend     # Frontend unit tests
-make test-playwright   # E2E tests in Docker
-```
-
-E2E tests run with three authentication modes: standard auth, no auth, and proxy auth.
-
-### Coverage & Performance
-```bash
-cd backend
-./run_check_coverage.sh  # Coverage report with HTML output
-./run_benchmark.sh       # Benchmarks
-```
-
-**Code Coverage:**
-- View report: Open `backend/coverage.html` after running coverage script
-- CI enforces coverage for critical packages
-- Use `go test -cover` for quick package coverage
-
-## Code Standards
-
-### Backend (Go)
-- **Linting**: `backend/.golangci.yml` with 30+ checks
-- **Format**: Use `gofmt` (automated in CI)
-- **Testing**: Maintain 80%+ coverage
-- **Errors**: Handle all errors explicitly
-
-### Frontend (Vue.js)
-- **Linting**: ESLint with Vue 3 + TypeScript rules
-- **i18n**: English is master locale, all text must use `$t('key')`
-- **Types**: Use TypeScript everywhere
-- **Fix**: Run `npm run lint:fix` before committing
-
-## Build & Deployment
-
-### Single Binary Build
-The project builds into a single binary with embedded frontend:
-
-```bash
-make build-frontend  # Build Vue.js app
-make build-backend   # Build Go binary with embedded assets
-```
-
-### Docker
-```bash
-make build       # Full image with ffmpeg and muPDF
-```
-
-### Configuration
-- **Test Config**: `backend/test_config.yaml` Auto-generated after running `make setup`
-
-## Contributing
-
-### Pull Request Process
-
-1. Fork and create a feature branch
-2. Make your changes following the code standards
-3. Run `make dev` to build and run with your changes. Supports hot-reloading frontend and backend changes.
-4. When ready, run `make check-all` to verify tests and linting
-5. Submit PR with a clear description
-
-### PR Requirements
-- Clear description of changes
-- All tests must pass
-- Follow existing code patterns
-- Update documentation if needed
-
-### Commit Format
-```
-type(scope): description
-
-Types: feat, fix, docs, refactor, test, chore
-```
-
-## Roadmap
-
-Check the [Project Roadmap](https://github.com/users/gtsteffaniak/projects/4/views/2) to see issues sorted by priority. This helps you understand what features are planned and where you can contribute most effectively.
-
-## Troubleshooting
-
-### Common Issues
-
-**Build failures:**
-```bash
-# Frontend
-cd frontend && rm -rf node_modules && npm install
-
-# Backend
-cd backend && go mod tidy && go clean -modcache
-```
-
-**Authentication Issues:**
-
-Always first enable debug logging in your config file if you have issues.
-
-1. **OIDC Login Fails:**
-   - Check redirect URLs match your config
-   - Verify OIDC provider settings
-   - Enable debug logs to see auth flow
-   - Common issue: mismatched callback URLs
-
-2. **Proxy Auth Not Working:**
-   - Verify header names match config
-   - Check nginx/reverse proxy passes headers
-   - Test with: `curl -H "X-Auth: username" localhost:8080`
-   - Enable `--log-level debug` to see headers
-
-3. **TOTP Issues:**
-   - Ensure server time is synchronized
-   - Check QR code generation in logs
-   - Test with authenticator app time settings
-   - Database might have stale TOTP secrets
-
-4. **Session/Cookie Problems:**
-   - Clear browser cookies and localStorage
-   - Verify cookie domain settings
-   - Try incognito/private browsing mode
-
-### Getting Help
-
-- **Wiki**: [Project Wiki](https://github.com/gtsteffaniak/filebrowser/wiki)
-- **Issues**: [GitHub Issues](https://github.com/gtsteffaniak/filebrowser/issues)
-- **PR Template**: See `.github/PULL_REQUEST_TEMPLATE.md`

README.md

@@ -6,7 +6,7 @@
   [![DockerHub Pulls](https://img.shields.io/docker/pulls/gtstef/filebrowser?label=latest%20Docker%20pulls)](https://hub.docker.com/r/gtstef/filebrowser)
   [![Apache-2.0 License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)
 
-  [![Donate](https://www.paypalobjects.com/en_US/i/btn/btn_donate_SM.gif)](https://github.com/gtsteffaniak/filebrowser/wiki/Q&A#is-there-a-way-to-donate-or-support-this-project)
+  [![Donate](https://www.paypalobjects.com/en_US/i/btn/btn_donate_SM.gif)](https://www.paypal.com/donate/?business=W5XKNXHJM2WPE&no_recurring=0&currency_code=USD)
 
   <img width="150" src="https://github.com/user-attachments/assets/59986a2a-f960-4536-aa35-4a9a7c98ad48" title="Logo">
   <h3>FileBrowser Quantum</h3>
@@ -16,27 +16,13 @@
 </div>
 
 > [!WARNING]
-> There is no stable version -- :construction: planned for 2025. ([Read more](https://github.com/gtsteffaniak/filebrowser/discussions/628))
-
-[FYI: how much RAM does it require?](https://github.com/gtsteffaniak/filebrowser/discussions/787)
-
-## About
-
-FileBrowser Quantum provides an easy way to access and manage your files from the web. It has has a modern responsive interface that has many advanced features to manage users, access, sharing, and file preview and editing.
-
-This version is called "Quantum" because it packs tons of advanced features into a tiny easy to run file. Unlike the majority of alternative options, FileBrowser Quantum is simple to install and easy to configure.
-
-The goal for this repo is to become the best open-source self-hosted file browsing application that exists -- **all for free**. This repo will always be free and open-source.
-
-Ready to try it out? See [Getting Started Wiki](https://github.com/gtsteffaniak/filebrowser/wiki/Getting-Started).
-
-## How its different
+> There is no stable version -- planned for 2025. ([Read more](https://github.com/gtsteffaniak/filebrowser/discussions/628))
 
 FileBrowser Quantum is a massive fork of the file browser open-source project with the following changes:
 
   1. ✅ Multiple sources support
   2. ✅ Login support for OIDC, password + 2FA, and proxy.
-  3. ✅ Beautiful, Responsive, and Customizable user interface.
+  3. ✅ Revamped UI
   4. ✅ Simplified configuration via `config.yaml` config file.
   5. ✅ Ultra-efficient [indexing](https://github.com/gtsteffaniak/filebrowser/wiki/Indexing) and real-time updates
      - Real-time search results as you type.
@@ -47,26 +33,28 @@ FileBrowser Quantum is a massive fork of the file browser open-source project wi
      - Instantly switches view modes and sort order without reloading data.
      - Folder sizes are displayed.
      - Navigating remembers the last scroll position.
-  7. ✅ Highly configurable and customizable sharing options, incuding:
-     - share expiration time
-     - users who can access share (including anonymous)
-     - styling and themes
-     - file viewing, editing, and uploading permissions
-  8. ✅ Directory-level access control that can be scoped to user or group.
-  8. ✅ Developer API support
+  7. ✅ Developer API support
      - Ability to create long-lived API Tokens.
      - A helpful Swagger page is available at `/swagger` endpoint for API enabled users.
 
 Notable features that this fork *does not* have (removed):
 
- - :construction: jobs are not supported yet.
+ - ❌ jobs are not supported yet (planned).
+ - ❌ rules are not supported yet (planned).
  - ❌ shell commands are completely removed and will not be returned.
 
-> [!WARNING]
-> Every file and directory in the source gets indexed (by default). This enables powerful features such as instant search, but large source filesystems can increase your system requirements. [See indexing wiki](https://github.com/gtsteffaniak/filebrowser/wiki/Indexing) for more info.
+## About
 
 FileBrowser Quantum differs significantly from the original version. Many of these changes required a significant overhaul. Creating a fork was a necessary process to make the program better. There have been many growing pains, but a stable release is planned and coming soon.
 
+This version is called "Quantum" because it packs tons of advanced features in a tiny executable file. Unlike the majority of alternative options, FileBrowser Quantum is simple to install and easy to configure.
+
+The goal for this repo is to become the best open-source self-hosted file browsing application that exists -- **all for free**.
+
+This repo will always be free and open-source.
+
+For more, see the [Q&A Wiki](https://github.com/gtsteffaniak/filebrowser/wiki/Q&A)
+
 ## The UI
 
 The UI has a simple three-component navigation system:
@@ -106,10 +94,6 @@ See [Office Support Wiki](https://github.com/gtsteffaniak/filebrowser/wiki/Offic
 
 See the [Migration Wiki](https://github.com/gtsteffaniak/filebrowser/wiki/Migration)
 
-## Other Questions
-
-For more, see the [Q&A Wiki](https://github.com/gtsteffaniak/filebrowser/wiki/Q&A)
-
 ## Comparison Chart
 
  Application Name | <img width="48" src="https://github.com/user-attachments/assets/59986a2a-f960-4536-aa35-4a9a7c98ad48" > 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
@@ -119,13 +103,13 @@ Linux                         | ✅ | ✅ | ✅ | ✅ | ❌ | ✅ |
 Windows                       | ✅ | ✅ | ✅ | ❌ | ❌ | ✅ |
 Mac                           | ✅ | ✅ | ✅ | ❌ | ❌ | ✅ |
 Self hostable                 | ✅ | ✅ | ✅ | ✅ | ❌ | ✅ |
-Has Stable Release?           | :construction: | ✅ | ✅ | ✅ | ✅ | ✅ |
+Has Stable Release?           | ❌ | ✅ | ✅ | ✅ | ✅ | ✅ |
 S3 support                    | ❌ | ❌ | ✅ | ✅ | ❌ | ❌ |
 webdav support                | ❌ | ❌ | ✅ | ✅ | ❌ | ✅ |
 FTP support                   | ❌ | ❌ | ✅ | ✅ | ❌ | ✅ |
-Dedicated docs site?          | :construction: | ✅ | ✅ | ✅ | ❌ | ✅ |
+Dedicated docs site?          | ❌ | ✅ | ✅ | ✅ | ❌ | ✅ |
 Multiple sources at once      | ✅ | ❌ | ✅ | ✅ | ❌ | ✅ |
-Docker image size             | 180 MB (with ffmpeg) | 31 MB  | 240 MB (main image) | 250 MB | ❌ | > 2 GB |
+Docker image size             | 200 MB (with ffmpeg) | 31 MB  | 240 MB (main image) | 250 MB | ❌ | > 2 GB |
 Min. Memory Requirements      | 256 MB | 128 MB | 128 MB (main image) | 512 MB | ❌ | 512 MB   |
 has standalone binary         | ✅ | ✅ | ❌ | ❌ | ❌ | ❌ |
 price                         | free | free | free | free tier | free tier | $99+ |
@@ -134,32 +118,32 @@ Upload files from the web?    | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 Advanced Search?              | ✅ | ❌ | ❌ | configurable | ✅ | ✅ |
 Indexed Search?               | ✅ | ❌ | ❌ | configurable | ✅ | ✅ |
 Content-aware search?         | ❌ | ❌ | ❌ | configurable | ✅ | ✅ |
-Custom job support            | :construction: | ✅ | ❌ | ✅ | ❌ | ✅ |
+Custom job support            | ❌ | ✅ | ❌ | ✅ | ❌ | ✅ |
 Multiple users                | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 Single sign-on support        | ✅ | ❌ | ❌ | ✅ | ✅ | ✅ |
-LDAP sign-on support          | :construction: | ❌ | ❌ | ✅ | ❌ | ✅ |
+LDAP sign-on support          | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ |
 Long-live API key support     | ✅ | ❌ | ✅ | ✅ | ✅ | ✅ |
 API documentation page        | ✅ | ❌ | ✅ | ✅ | ❌ | ✅ |
-Mobile App                    | ❌ | ❌ | ❌ | ✅ | ✅ | ❌ |
+Mobile App                    | ❌ | ❌ | ❌ | ❌ | ✅ | ❌ |
 open source?                  | ✅ | ✅ | ✅ | ✅ | ❌ | ❌ |
-tags support                  | :construction: | ❌ | ❌ | ✅ | ❌ | ✅ |
+tags support                  | ❌ | ❌ | ❌ | ✅ | ❌ | ✅ |
 shareable web links?          | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
-Event-based notifications     | :construction: | ❌ | ❌ | ❌ | ❌ | ✅ |
-Metrics                       | :construction: | ❌ | ❌ | ❌ | ❌ | ❌ |
-file space quotas             | :construction: | ❌ | ❌ | ❌ | ✅ | ✅ |
+Event-based notifications     | ❌ | ❌ | ❌ | ❌ | ❌ | ✅ |
+Metrics                       | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ |
+file space quotas             | ❌ | ❌ | ❌ | ❌ | ✅ | ✅ |
 text-based files editor       | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 Office file support           | ✅ | ❌ | ✅ | ✅ | ✅ | ✅ |
 Office file previews          | ✅ | ❌ | ❌ | ✅ | ✅ | ✅ |
 Themes                        | ✅ | ✅ | ❌ | ❌ | ❌ | ✅ |
 Branding support              | ✅ | ✅ | ❌ | ❌ | ❌ | ✅ |
-activity log                  | :construction: | ❌ | ❌ | ✅ | ✅ | ✅ |
+activity log                  | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ |
 Comments support              | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ |
-trash support                 | :construction: | ❌ | ❌ | ✅ | ✅ | ✅ |
+trash support                 | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ |
 Starred/pinned files          | ❌ | ❌ | ❌ | ❌ | ✅ | ✅ |
 Chromecast support            | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ |
-Share collections of files    | :construction: | ❌ | ❌ | ❌ | ❌ | ✅ |
-Can archive selected files    | :construction: | ❌ | ❌ | ❌ | ❌ | ✅ |
-Can browse archive files      | :construction: | ❌ | ❌ | ❌ | ❌ | ✅ |
-Can convert documents         | :construction: | ❌ | ❌ | ❌ | ❌ | ✅ |
-Can convert videos            | :construction: | ❌ | ❌ | ❌ | ❌ | ❌ |
-Can convert photos            | :construction: | ❌ | ❌ | ❌ | ❌ | ❌ |
+Share collections of files    | ❌ | ❌ | ❌ | ❌ | ❌ | ✅ |
+Can archive selected files    | ❌ | ❌ | ❌ | ❌ | ❌ | ✅ |
+Can browse archive files      | ❌ | ❌ | ❌ | ❌ | ❌ | ✅ |
+Can convert documents         | ❌ | ❌ | ❌ | ❌ | ❌ | ✅ |
+Can convert videos            | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ |
+Can convert photos            | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ |

_docker/Dockerfile

@@ -1,46 +1,57 @@
-FROM gtstef/ffmpeg:8.0-decode AS ffmpeg
-FROM golang:alpine AS base
+FROM golang:1.24-alpine AS base
 ARG VERSION
 ARG REVISION
 WORKDIR /app
 COPY ./backend ./
-RUN apk update && apk add --no-cache gcc musl-dev upx
-ENV CGO_ENABLED=1
-ENV GOEXPERIMENT=greenteagc
-RUN go build -tags mupdf,musl -ldflags="-w -s \
+#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/backend/common/version.Version=${VERSION}' \
   -X 'github.com/gtsteffaniak/filebrowser/backend/common/version.CommitSHA=${REVISION}'" \
   -o filebrowser .
-RUN upx filebrowser
 
-FROM node:lts-slim AS nbuild
+FROM node:slim AS nbuild
 WORKDIR /app
 COPY ./frontend/package.json ./
-RUN apt-get update && apt-get install -y --no-install-recommends git ca-certificates \
-    && git config --global url."https://github.com/".insteadOf "git@github.com:" \
-    && git config --global url."https://github.com/".insteadOf "ssh://git@github.com/"
 RUN npm i --maxsockets 1
 COPY  ./frontend/ ./
 RUN npm run build-docker
 
 FROM alpine:latest
-COPY --from=ffmpeg [ "/ffmpeg", "/ffprobe", "/usr/local/bin/" ]
+
+RUN apk add --no-cache curl xz && \
+    ARCH=$(uname -m) && \
+    case "$ARCH" in \
+      x86_64)   URL="https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-amd64-static.tar.xz" ;; \
+      aarch64)  URL="https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-arm64-static.tar.xz" ;; \
+      armv7l)   URL="https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-armhf-static.tar.xz" ;; \
+      *)        echo "Unsupported architecture: $ARCH" && exit 1 ;; \
+    esac && \
+    mkdir -p /tmp/ffmpeg && \
+    curl -L "$URL" | tar -xJ -C /tmp/ffmpeg && \
+    mv /tmp/ffmpeg/ffmpeg-*/ffmpeg /usr/local/bin/ && \
+    mv /tmp/ffmpeg/ffmpeg-*/ffprobe /usr/local/bin/ && \
+    chmod +x /usr/local/bin/ffmpeg /usr/local/bin/ffprobe && \
+    rm -rf /tmp/ffmpeg && \
+    apk del curl xz && \
+    rm -rf /var/cache/apk/*
+
 ENV FILEBROWSER_FFMPEG_PATH="/usr/local/bin/"
-ENV FILEBROWSER_DATABASE="/home/filebrowser/data/database.db"
+ENV FILEBROWSER_NO_EMBEDED="true"
 ENV PATH="$PATH:/home/filebrowser"
 RUN apk --no-cache add ca-certificates mailcap tzdata
 RUN adduser -D -s /bin/true -u 1000 filebrowser
 USER filebrowser
 WORKDIR /home/filebrowser
-# copy config to two locations for compatibility
-COPY --from=base --chown=filebrowser:1000 [ "/app/filebrowser", "/app/config.yaml", "./" ]
-COPY --from=base --chown=filebrowser:1000 [ "/app/config.yaml", "./data/config.yaml" ]
-COPY --from=base --chown=filebrowser:1000 [ "/app/reduce-rounded-corners.css", "./" ]
-COPY --from=nbuild --chown=filebrowser:1000 [ "/app/dist/", "./http/dist/" ]
+COPY --from=base --chown=filebrowser:1000 /app/filebrowser* ./
+COPY --from=base --chown=filebrowser:1000 /app/config.media.yaml ./config.yaml
+COPY --from=nbuild --chown=filebrowser:1000 /app/dist/ ./http/dist/
+
 ## sanity checks
 RUN [ "filebrowser", "version" ]
 RUN [ "ffmpeg", "-version" ]
 RUN [ "ffprobe", "-version" ]
+
 USER root
 # exposing default port for auto discovery.
 EXPOSE 80

_docker/Dockerfile.playwright-base

@@ -1,4 +1,4 @@
 FROM node:22-slim
 WORKDIR /app/frontend
-RUN npm i @playwright/test oauth2-mock-server @types/node
+RUN npm i @playwright/test
 RUN npx playwright install --with-deps firefox

_docker/Dockerfile.playwright-general

@@ -1,18 +1,8 @@
 FROM gtstef/playwright-base
 WORKDIR /app
-
-# Copy setup scripts first to leverage caching
 COPY [ "./_docker/src/general/", "./" ]
-
 WORKDIR /app/frontend
-COPY [ "./_docker/src/general/frontend/", "./" ]
-COPY [ "./frontend/tests/", "./tests" ]
-
+COPY [ "./frontend/", "./" ]
 WORKDIR /app/backend/
 COPY [ "./backend/filebrowser*", "./"]
-RUN mkdir -p ./http/dist
-COPY [ "./backend/http/embed/", "./http/dist/"]
-
-# Run tests
-RUN ./filebrowser set -u testuser1,testuser1
 RUN ./filebrowser & sleep 2 && cd ../frontend && npx playwright test

_docker/Dockerfile.playwright-noauth

@@ -1,16 +1,8 @@
 FROM gtstef/playwright-base
 WORKDIR /app
-
-# Copy setup scripts first to leverage caching
 COPY [ "./_docker/src/noauth/", "./" ]
-
 WORKDIR /app/frontend
-COPY [ "./frontend/tests", "./tests" ]
-
+COPY [ "./frontend/", "./" ]
 WORKDIR /app/backend/
 COPY [ "./backend/filebrowser", "./"]
-RUN mkdir -p ./http/dist
-COPY [ "./backend/http/embed/", "./http/dist/"]
-
-# Run tests
 RUN ./filebrowser & sleep 2 && cd ../frontend && npx playwright test

_docker/Dockerfile.playwright-oidc

@@ -1,13 +0,0 @@
-FROM gtstef/playwright-base
-
-COPY [ "./_docker/src/oidc/frontend/", "./" ]
-COPY [ "./frontend/tests/", "./tests" ]
-
-WORKDIR /app/backend/
-RUN mkdir -p ./http/dist
-COPY [ "./_docker/src/oidc/backend/", "./"]
-COPY ["./backend/filebrowser", "./"]
-COPY [ "./backend/http/embed/", "./http/dist/"]
-# Run tests
-WORKDIR /app/frontend
-RUN node mock-oidc-server.js & sleep 2 && cd ../backend/ && ./filebrowser & sleep 2 && cd ../frontend && npx playwright test

_docker/Dockerfile.playwright-proxy

@@ -2,13 +2,10 @@ FROM gtstef/playwright-base
 WORKDIR /app
 COPY [ "./_docker/src/proxy/", "./" ]
 WORKDIR /app/frontend
-COPY [ "./frontend/tests", "./tests" ]
+COPY [ "./frontend/", "./" ]
 WORKDIR /app/backend/
 COPY [ "./backend/filebrowser", "./"]
-RUN mkdir -p ./http/dist
-COPY [ "./backend/http/embed/", "./http/dist/"]
 RUN apt update && apt install nginx -y
 RUN mv default.conf /etc/nginx/conf.d/default.conf
-RUN mv .htpasswd /etc/nginx/conf.d/.htpasswd
 RUN sed -i 's/filebrowser/localhost/g' /etc/nginx/conf.d/default.conf
 RUN nginx & ./filebrowser & sleep 2 && cd ../frontend && npx playwright test

_docker/Dockerfile.playwright-sharing

@@ -1,17 +0,0 @@
-FROM gtstef/playwright-base
-WORKDIR /app
-
-# Copy setup scripts first to leverage caching
-COPY [ "./_docker/src/sharing/", "./" ]
-
-WORKDIR /app/frontend
-COPY [ "./_docker/src/sharing/frontend/", "./" ]
-COPY [ "./frontend/tests/", "./tests" ]
-
-WORKDIR /app/backend/
-COPY [ "./backend/filebrowser*", "./"]
-RUN mkdir -p ./http/dist
-COPY [ "./backend/http/embed/", "./http/dist/"]
-
-# Run tests
-RUN ./filebrowser & sleep 2 && cd ../frontend && npx playwright test

_docker/Dockerfile.primecache

@@ -1 +0,0 @@
-FROM gtstef/playwright-base

_docker/Dockerfile.slim

@@ -1,40 +0,0 @@
-FROM golang:alpine AS base
-ARG VERSION
-ARG REVISION
-WORKDIR /app
-COPY ./backend ./
-RUN apk update && apk add upx
-ENV GOEXPERIMENT=greenteagc
-RUN go build -ldflags="-w -s \
-  -X 'github.com/gtsteffaniak/filebrowser/backend/common/version.Version=${VERSION}' \
-  -X 'github.com/gtsteffaniak/filebrowser/backend/common/version.CommitSHA=${REVISION}'" \
-  -o filebrowser .
-RUN upx filebrowser
-
-FROM node:lts-slim AS nbuild
-WORKDIR /app
-COPY ./frontend/package.json ./
-RUN apt-get update && apt-get install -y --no-install-recommends git ca-certificates \
-    && git config --global url."https://github.com/".insteadOf "git@github.com:" \
-    && git config --global url."https://github.com/".insteadOf "ssh://git@github.com/"
-RUN npm i --maxsockets 1
-COPY  ./frontend/ ./
-RUN npm run build-docker
-
-FROM alpine:latest
-ENV FILEBROWSER_DATABASE="/home/filebrowser/data/database.db"
-ENV PATH="$PATH:/home/filebrowser"
-RUN apk --no-cache add ca-certificates mailcap tzdata
-RUN adduser -D -s /bin/true -u 1000 filebrowser
-USER filebrowser
-WORKDIR /home/filebrowser
-COPY --from=base --chown=filebrowser:1000 [ "/app/filebrowser", "./" ]
-COPY --from=base --chown=filebrowser:1000 [ "/app/config.yaml", "./data/config.yaml" ]
-COPY --from=base --chown=filebrowser:1000 [ "/app/reduce-rounded-corners.css", "./" ]
-COPY --from=nbuild --chown=filebrowser:1000 [ "/app/dist/", "./http/dist/" ]
-## sanity checks
-RUN [ "filebrowser", "version" ]
-USER root
-# exposing default port for auto discovery.
-EXPOSE 80
-ENTRYPOINT [ "./filebrowser" ]

_docker/docker-compose.yaml

@@ -6,7 +6,6 @@ services:
       - "80:80"
     volumes:
       - ./src/proxy/backend/default.conf:/etc/nginx/conf.d/default.conf
-      - ./src/proxy/backend/.htpasswd:/etc/nginx/conf.d/.htpasswd
   filebrowser:
     hostname: filebrowser
     volumes:
@@ -14,4 +13,4 @@ services:
       - "./src/proxy/backend/config.yaml:/home/filebrowser/config.yaml"
     build:
       context: ../
-      dockerfile: ./_docker/Dockerfile.slim
+      dockerfile: ./_docker/Dockerfile

_docker/src/general/backend/config.yaml

@@ -5,13 +5,8 @@ server:
     - levels: "info|error|debug"
   sources:
     - path: "../frontend/tests/playwright-files"
-      name: "playwright + files"
-      config:
-        defaultEnabled: true
     - path: "."
       name: "docker"
-      config:
-        defaultEnabled: true
 frontend:
   name: "Graham's Filebrowser"
   disableDefaultLinks: true

_docker/src/general/frontend/playwright.config.ts

@@ -10,9 +10,9 @@ import { defineConfig, devices } from "@playwright/test";
  * See https://playwright.dev/docs/test-configuration.
  */
 export default defineConfig({
-  globalSetup: "./tests/playwright/global-setup",
-  timeout: 10000,
-  testDir: "./tests/playwright/general",
+  globalSetup: "./tests-playwright/global-setup",
+  timeout: 5000,
+  testDir: "./tests-playwright/general",
   /* Run tests in files in parallel */
   fullyParallel: false,
   /* Fail the build on CI if you accidentally left test.only in the source code. */
@@ -20,7 +20,7 @@ export default defineConfig({
   /* Retry on CI only */
   retries: 2,
   /* Opt out of parallel tests on CI. */
-  workers: 1,
+  workers: 1, // required for now! todo parallel some tests
   /* Reporter to use. See https://playwright.dev/docs/test-reporters */
   reporter: "line",
   /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */

_docker/src/noauth/backend/config.yaml

@@ -5,12 +5,6 @@ server:
     - levels: "info|error|debug"
   sources:
     - path: "../frontend/tests/playwright-files"
-      config:
-        defaultEnabled: true
-        exclude:
-          folderPaths:
-            - "excluded"
-
 auth:
   methods:
     noauth: true

_docker/src/noauth/frontend/playwright.config.ts

@@ -10,9 +10,9 @@ import { defineConfig, devices } from "@playwright/test";
  * See https://playwright.dev/docs/test-configuration.
  */
 export default defineConfig({
-  globalSetup: "./tests/playwright/noauth-setup",
-  timeout: 10000,
-  testDir: "./tests/playwright/noauth",
+  globalSetup: "./tests-playwright/noauth-setup",
+  timeout: 5000,
+  testDir: "./tests-playwright/noauth",
   /* Run tests in files in parallel */
   fullyParallel: false,
   /* Fail the build on CI if you accidentally left test.only in the source code. */

_docker/src/oidc/backend/config.yaml

@@ -1,38 +0,0 @@
-server:
-  logging:
-    - levels: "info|error|warning|debug"
-  sources:
-    - path: "../frontend/tests/playwright-files"
-      config:
-        defaultEnabled: true
-        createUserDir: true
-
-frontend:
-  name: "Graham's Filebrowser"
-  disableDefaultLinks: true
-  externalLinks:
-    - text: "A playwright test"
-      url: "https://playwright.dev/"
-      title: "Playwright"
-
-auth:
-  methods:
-    password:
-      enabled: false
-    oidc:
-      enabled: true
-      createUser: true
-      clientId: "vyBrzOmcrU3OokiWEZoObdGBscw0eYPNJauBtOJr"
-      clientSecret: "gIMKbkEcckUhlGrnE2Vxi8eZhEcfxQqfwFgM0ATzk4DciHGrW2YRtQfqcpRTsmzrxEETkKvZ8yeK3sfoXnUV1IQTzqK7wxw3lEMtmeXi5clj0h7nH1rVGFq2Q3HL8zUe"
-      issuerUrl: "http://localhost:8080"
-      adminGroup: "Admins"
-
-userDefaults:
-  darkMode: true
-  disableSettings: false
-  singleClick: false
-  permissions:
-    admin: false
-    modify: true
-    share: false
-    api: false

_docker/src/oidc/frontend/mock-oidc-server.js

@@ -1,60 +0,0 @@
-
-import { OAuth2Server } from 'oauth2-mock-server';
-
-// This is a list of pre-defined users. You can add more users here.
-// The filebrowser application will use this data when a user logs in.
-const users = {
-  // Default user
-  johndoe: {
-    sub: 'johndoe',
-    preferred_username: 'johndoe',
-    email: 'johndoe@example.com',
-    groups: ['Admins', 'Users'],
-  },
-  // Another example user
-  testuser: {
-    sub: 'testuser',
-    preferred_username: 'testuser',
-    email: 'testuser@example.com',
-    groups: ['Users'],
-  },
-};
-
-const server = new OAuth2Server();
-
-// Generate a new RSA key for the server.
-await server.issuer.keys.generate('RS256');
-
-/**
- * This hook is called before the ID token is signed.
- * We're using it to add claims to the ID token.
- * This is the primary way the application will get user information.
- */
-server.service.on('beforeIdTokenSigning', (token, req) => {
-  // By default, the mock server uses 'johndoe' as the subject.
-  const user = users[token.payload.sub] || users.johndoe;
-  console.log(`[ID Token] Customizing token for user: ${user.sub}`);
-  Object.assign(token.payload, user);
-});
-
-
-/**
- * This hook is called before the userinfo response is sent.
- * We're using it to provide user claims when the application calls the /userinfo endpoint.
- */
-server.service.on('beforeUserinfo', (userInfoResponse, req) => {
-    const user = users.johndoe;
-    console.log(`[UserInfo] Customizing userinfo for user: ${user.sub}`);
-    userInfoResponse.body = user;
-});
-
-
-const port = 8080;
-const host = '0.0.0.0'; // Bind to 0.0.0.0 to be accessible within Docker
-await server.start(port, host);
-console.log(`OAuth 2 Mock Server listening on http://${host}:${port}`);
-console.log(`Issuer URL: ${server.issuer.url}`);
-console.log('---');
-console.log('Pre-defined users:');
-console.log(JSON.stringify(users, null, 2));
-console.log('---');

_docker/src/oidc/frontend/playwright.config.ts

@@ -1,48 +0,0 @@
-import { defineConfig, devices } from "@playwright/test";
-
-/**
- * Read environment variables from file.
- * https://github.com/motdotla/dotenv
- */
-// require('dotenv').config();
-
-/**
- * See https://playwright.dev/docs/test-configuration.
- */
-export default defineConfig({
-  globalSetup: "./tests/playwright/oidc-setup",
-  timeout: 5000,
-  testDir: "./tests/playwright/oidc",
-  /* Run tests in files in parallel */
-  fullyParallel: false,
-  /* Fail the build on CI if you accidentally left test.only in the source code. */
-  forbidOnly: false,
-  /* Retry on CI only */
-  retries: 2,
-  /* Opt out of parallel tests on CI. */
-  workers: 1, // required for now! todo parallel some tests
-  /* Reporter to use. See https://playwright.dev/docs/test-reporters */
-  reporter: "line",
-  /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
-  use: {
-    storageState: "loginAuth.json",
-    actionTimeout: 5000,
-    //storageState: "loginAuth.json",
-    /* Base URL to use in actions like `await page.goto('/')`. */
-    baseURL: "http://127.0.0.1",
-
-    /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
-    trace: "on-first-retry",
-
-    /* Set default locale to English (US) */
-    locale: "en-US",
-  },
-
-  /* Configure projects for major browsers */
-  projects: [
-    {
-      name: "firefox",
-      use: { ...devices["Desktop Firefox"] },
-    },
-  ],
-});

_docker/src/proxy/backend/.htpasswd

@@ -1 +0,0 @@
-demo-127.0.0.1:$apr1$j5FRA4Bc$RYdNFuM7YAAo9Qtie8w4b/

_docker/src/proxy/backend/config.yaml

@@ -1,6 +1,6 @@
 server:
   port: 8080
-  baseURL:  "/subpath"
+  baseURL:  "/"
   logging:
     - levels: "info|error|debug"
   sources:
@@ -23,7 +23,6 @@ auth:
       enabled: true
       header: "X-Username"
       createUser: true
-      logoutRedirectUrl: "https://localhost/api/auth/logout2"
 
 userDefaults:
   darkMode: true
@@ -32,5 +31,5 @@ userDefaults:
   permissions:
     admin: false
     modify: true
-    share: true
+    share: false
     api: false

_docker/src/proxy/backend/default.conf

@@ -7,25 +7,13 @@ server {
     listen 80;
     server_name localhost 127.0.0.1;
 
-    location /subpath/public/ {
-        proxy_pass http://filebrowser:8080/subpath/public/;
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $scheme;
-    } 
-
-    # requires basic auth demo-127.0.0.1:SecurePass123!
-    location /subpath {
-        auth_basic "Restricted Access";
-        auth_basic_user_file /etc/nginx/conf.d/.htpasswd;
+    location / {
         proxy_set_header X-Username $uuid;
         add_header X-Username $uuid;
-        proxy_pass http://filebrowser:8080/subpath;
+        proxy_pass http://filebrowser:8080;
         proxy_set_header Host $host;
         proxy_set_header X-Real-IP $remote_addr;
         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
         proxy_set_header X-Forwarded-Proto $scheme;
     }
-
 }

_docker/src/proxy/frontend/playwright.config.ts

@@ -10,9 +10,9 @@ import { defineConfig, devices } from "@playwright/test";
  * See https://playwright.dev/docs/test-configuration.
  */
 export default defineConfig({
-  globalSetup: "./tests/playwright/proxy-setup.ts",
-  timeout: 5000,
-  testDir: "./tests/playwright/proxy",
+  //globalSetup: "./global-setup",
+  timeout: 3000,
+  testDir: "./tests-playwright/proxy",
   /* Run tests in files in parallel */
   fullyParallel: false,
   /* Fail the build on CI if you accidentally left test.only in the source code. */
@@ -25,8 +25,8 @@ export default defineConfig({
   reporter: "line",
   /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
   use: {
-    actionTimeout: 5000,
-    storageState: "loginAuth.json",
+    actionTimeout: 3000,
+    //storageState: "loginAuth.json",
     /* Base URL to use in actions like `await page.goto('/')`. */
     baseURL: "http://127.0.0.1",
 

_docker/src/sharing/backend/config.yaml

@@ -1,22 +0,0 @@
-server:
-  port: 80
-  baseURL:  "/"
-  logging:
-    - levels: "info|error|debug"
-  sources:
-    - path: "../frontend/tests/playwright-files"
-      name: "playwright + files"
-      config:
-        defaultEnabled: true
-    - path: "."
-      name: "docker"
-      config:
-        private: true
-        defaultEnabled: true
-frontend:
-  name: "Graham's Filebrowser"
-  disableDefaultLinks: true
-  externalLinks:
-    - text: "A playwright test"
-      url: "https://playwright.dev/"
-      title: "Playwright"

_docker/src/sharing/frontend/playwright.config.ts

@@ -1,47 +0,0 @@
-import { defineConfig, devices } from "@playwright/test";
-
-/**
- * Read environment variables from file.
- * https://github.com/motdotla/dotenv
- */
-// require('dotenv').config();
-
-/**
- * See https://playwright.dev/docs/test-configuration.
- */
-export default defineConfig({
-  globalSetup: "./tests/playwright/global-setup",
-  timeout: 10000,
-  testDir: "./tests/playwright/sharing",
-  /* Run tests in files in parallel */
-  fullyParallel: false,
-  /* Fail the build on CI if you accidentally left test.only in the source code. */
-  forbidOnly: false,
-  /* Retry on CI only */
-  retries: 2,
-  /* Opt out of parallel tests on CI. */
-  workers: 1,
-  /* Reporter to use. See https://playwright.dev/docs/test-reporters */
-  reporter: "line",
-  /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
-  use: {
-    actionTimeout: 5000,
-    storageState: "loginAuth.json",
-    /* Base URL to use in actions like `await page.goto('/')`. */
-    baseURL: "http://127.0.0.1/",
-
-    /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
-    trace: "on-first-retry",
-
-    /* Set default locale to English (US) */
-    locale: "en-US",
-  },
-
-  /* Configure projects for major browsers */
-  projects: [
-    {
-      name: "firefox",
-      use: { ...devices["Desktop Firefox"] },
-    },
-  ],
-});

backend/.air.toml

@@ -1,17 +0,0 @@
-root = "."
-tmp_dir = "tmp"
-
-[build]
-  cmd = "go build -o ./tmp/filebrowser --tags=mupdf --ldflags=\"-w -s -X 'github.com/gtsteffaniak/filebrowser/backend/version.CommitSHA=testingCommit' -X 'github.com/gtsteffaniak/filebrowser/backend/version.Version=testing'\" ."
-  bin = "tmp/filebrowser"
-  full_bin = "FILEBROWSER_DEVMODE=true CGO_ENABLED=1 ./tmp/filebrowser -c test_config.yaml"
-  include_ext = ["go", "tpl", "tmpl", "html"]
-  exclude_dir = ["tmp", "vendor", "http/dist", "http/embed", "swagger/docs"]
-  log = "air.log"
-  delay = 1000 # ms
-
-[log]
-  time = true
-
-[misc]
-  clean_on_exit = true

backend/.gitignore

@@ -1,5 +0,0 @@
-tmp/
-air.log
-filebrowser
-generated.yaml
-test_config.yaml

backend/.golangci.yml

@@ -1,146 +1,232 @@
-version: "2"
-linters:
-  settings:
-    staticcheck:
-      checks:
-        - all
-        - '-QF1001'
-        - '-ST1003'
-        - '-ST1016'
-        - '-QF1004'
-        - '-QF1003'
-    cyclop:
-      max-complexity: 30
-      package-average: 10
-    errcheck:
-      check-type-assertions: true
-    exhaustive:
-      check:
-        - switch
-        - map
-    exhaustruct:
-      exclude:
-        - ^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$
-        - ^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:
-      lines: 100
-      statements: 50
-      ignore-comments: true
-    gocognit:
-      min-complexity: 20
-    gocritic:
-      settings:
-        captLocal:
-          paramsOnly: false
-        underef:
-          skipRecvDeref: false
-    gomodguard:
-      blocked:
-        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:
-      disable:
-        - fieldalignment
-      enable-all: true
-      settings:
-        shadow:
-          strict: false
-    inamedparam:
-      skip-single-param: true
-    mnd:
-      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:
-      max-func-lines: 0
-    nolintlint:
-      require-explanation: true
-      require-specific: true
-      allow-no-explanation:
-        - funlen
-        - gocognit
-        - lll
-    perfsprint:
-      strconcat: false
-    rowserrcheck:
-      packages:
-        - github.com/jmoiron/sqlx
-    sloglint:
-      no-global: all
-      context: scope
-  exclusions:
-    generated: lax
-    presets:
-      - comments
-      - common-false-positives
-      - legacy
-      - std-error-handling
-    rules:
-      - linters:
-          - godot
-        source: (noinspection|TODO)
-      - linters:
-          - gocritic
-        source: //noinspection
-      - linters:
-          - bodyclose
-          - dupl
-          - funlen
-          - goconst
-          - gosec
-          - noctx
-          - wrapcheck
-        path: _test\.go
-    paths:
-      - third_party$
-      - builtin$
-      - examples$
+# 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
-formatters:
-  exclusions:
-    generated: lax
-    paths:
-      - third_party$
-      - builtin$
-      - examples$
+
+  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

@@ -3,54 +3,18 @@ project_name: filebrowser
 version: 2
 
 builds:
-  # Build configuration for linux amd64
-  - id: linux-amd64
-    env:
-      - CGO_ENABLED=1
-      - CC=zig cc -target x86_64-linux-musl
-    tags:
-      - mupdf
-      - musl
+  # Build configuration for darwin and linux
+  - id: default
     ldflags: &ldflags
-      - -s -w -X github.com/gtsteffaniak/filebrowser/backend/common/version.Version=v{{ .Version }} -X github.com/gtsteffaniak/filebrowser/backend/common/version.CommitSHA={{ .ShortCommit }}
+      - -s -w -X github.com/gtsteffaniak/filebrowser/backend/common/version.Version={{ .Version }} -X github.com/gtsteffaniak/filebrowser/backend/common/version.CommitSHA={{ .ShortCommit }}
     main: main.go
     binary: filebrowser
     goos:
       - linux
     goarch:
       - amd64
-    hooks:
-      post:
-        - upx {{ .Path }}
-
-  # Build configuration for linux arm64
-  - id: linux-arm64
-    ldflags: *ldflags
-    main: main.go
-    binary: filebrowser
-    env:
-      - CGO_ENABLED=1
-      - CC=zig cc -target aarch64-linux-musl
-    tags:
-      - mupdf
-      - musl
-    goos:
-      - linux
-    goarch:
-      - arm64
-    hooks:
-      post:
-        - upx {{ .Path }}
-
-  # Build configuration for linux
-  - id: linux-arm32
-    ldflags: *ldflags
-    main: main.go
-    binary: filebrowser
-    goos:
-      - linux
-    goarch:
       - arm
+      - arm64
     goarm:
       - "6"
       - "7"
@@ -60,11 +24,6 @@ builds:
 
   # Build configuration for windows without arm
   - id: windows
-    env:
-      - CGO_ENABLED=1
-      - CC=zig cc -target x86_64-windows
-    tags:
-      - mupdf
     ldflags: *ldflags
     main: main.go
     binary: filebrowser
@@ -76,16 +35,6 @@ builds:
       post:
         - upx {{ .Path }}  # Compress the binary with UPX
 
-  # Build configuration for freebsd without arm & upx
-  - id: freeBSD and freebsd-arm
-    ldflags: *ldflags
-    main: main.go
-    binary: filebrowser
-    goos:
-      - freebsd
-    goarch:
-      - amd64
-
   # Build configuration for macos without upx
   - id: macos
     ldflags: *ldflags
@@ -94,7 +43,17 @@ builds:
     goos:
       - darwin
     goarch:
+      - amd64
       - arm64
+
+  # Build configuration for freebsd without arm & upx
+  - id: freeBSD
+    ldflags: *ldflags
+    main: main.go
+    binary: filebrowser
+    goos:
+      - freebsd
+    goarch:
       - amd64
 
 archives:
@@ -108,3 +67,4 @@ archives:
 
 checksum:
   disable: true
+

backend/adapters/fs/diskcache/file_cache.go

@@ -31,6 +31,10 @@ type FileCache struct {
 
 // NewFileCache creates a new FileCache
 func NewFileCache(dir string) (*FileCache, error) {
+	if err := os.MkdirAll(filepath.Join(dir, "thumbnails", "video"), 0700); err != nil {
+		return nil, fmt.Errorf("can't make directory %s: %v", dir, err)
+	}
+
 	return &FileCache{dir: dir}, nil
 }
 

backend/adapters/fs/files/files.go

@@ -9,126 +9,100 @@ import (
 	"fmt"
 	"hash"
 	"io"
-	"unicode"
-	"unicode/utf8"
 
 	"os"
 	"path/filepath"
 	"strconv"
 	"strings"
 	"time"
+	"unicode/utf8"
 
 	"github.com/gtsteffaniak/filebrowser/backend/adapters/fs/fileutils"
 	"github.com/gtsteffaniak/filebrowser/backend/common/errors"
 	"github.com/gtsteffaniak/filebrowser/backend/common/settings"
 	"github.com/gtsteffaniak/filebrowser/backend/common/utils"
-	"github.com/gtsteffaniak/filebrowser/backend/database/share"
 	"github.com/gtsteffaniak/filebrowser/backend/indexing"
 	"github.com/gtsteffaniak/filebrowser/backend/indexing/iteminfo"
+	"github.com/gtsteffaniak/go-cache/cache"
 	"github.com/gtsteffaniak/go-logger/logger"
 )
 
-func FileInfoFaster(opts iteminfo.FileOptions) (*iteminfo.ExtendedFileInfo, error) {
-	response := &iteminfo.ExtendedFileInfo{}
+var OnlyOfficeCache = cache.NewCache(48 * time.Hour)
+
+func FileInfoFaster(opts iteminfo.FileOptions) (iteminfo.ExtendedFileInfo, error) {
+	response := iteminfo.ExtendedFileInfo{}
+	if opts.Source == "" {
+		opts.Source = settings.Config.Server.DefaultSource.Name
+	}
 	index := indexing.GetIndex(opts.Source)
 	if index == nil {
 		return response, fmt.Errorf("could not get index: %v ", opts.Source)
 	}
-
 	realPath, isDir, err := index.GetRealPath(opts.Path)
 	if err != nil {
-		return response, fmt.Errorf("could not get real path for requested path: %v", opts.Path)
+		return response, err
 	}
 	opts.IsDir = isDir
-	var info *iteminfo.FileInfo
-	var exists bool
+	// TODO: whats the best way to save trips to disk here?
+	// disabled using cache because its not clear if this is helping or hurting
+	// check if the file exists in the index
+	//info, exists := index.GetReducedMetadata(opts.Path, opts.IsDir)
+	//if exists {
+	//	err := RefreshFileInfo(opts)
+	//	if err != nil {
+	//		return info, err
+	//	}
+	//	if opts.Content {
+	//		content := ""
+	//		content, err = getContent(opts.Path)
+	//		if err != nil {
+	//			return info, err
+	//		}
+	//		info.Content = content
+	//	}
+	//	return info, nil
+	//}
 	err = index.RefreshFileInfo(opts)
 	if err != nil {
-		if err == errors.ErrNotIndexed && index.Config.DisableIndexing {
-			info, err = index.GetFsDirInfo(opts.Path)
+		return response, err
+	}
+	info, exists := index.GetReducedMetadata(opts.Path, opts.IsDir)
+	if !exists {
+		return response, fmt.Errorf("could not get metadata for path: %v", opts.Path)
+	}
+	if opts.Content && strings.HasPrefix(info.Type, "text") {
+		if info.Size < 20*1024*1024 { // 20 megabytes in bytes
+			content, err := getContent(realPath)
 			if err != nil {
+				logger.Debugf("could not get content for file: "+info.Path, info.Name, err)
 				return response, err
 			}
-		} else if err == errors.ErrNotIndexed {
-			return response, fmt.Errorf("could not refresh file info: %v", err)
-		}
-	} else {
-		info, exists = index.GetReducedMetadata(opts.Path, opts.IsDir)
-		if !exists {
-			return response, fmt.Errorf("could not get metadata for path: %v", opts.Path)
+			response.Content = content
+		} else {
+			logger.Debug("skipping large text file contents (20MB limit): "+info.Path, info.Name)
 		}
 	}
 	response.FileInfo = *info
 	response.RealPath = realPath
 	response.Source = opts.Source
-
-	if opts.Access != nil && !opts.Access.Permitted(index.Path, opts.Path, opts.Username) {
-		// check if any subpath is permitted
-		// keep track of permitted paths and only show them at the end
-		subFolders := info.Folders
-		subFiles := info.Files
-		response.Folders = make([]iteminfo.ItemInfo, 0)
-		response.Files = make([]iteminfo.ItemInfo, 0)
-		hasPermittedPaths := false
-		for _, subFolder := range subFolders {
-			indexPath := info.Path + subFolder.Name
-			if opts.Access.Permitted(index.Path, indexPath, opts.Username) {
-				hasPermittedPaths = true
-				response.Folders = append(response.Folders, subFolder)
-			}
-		}
-		for _, subFile := range subFiles {
-			indexPath := info.Path + subFile.Name
-			if opts.Access.Permitted(index.Path, indexPath, opts.Username) {
-				hasPermittedPaths = true
-				response.Files = append(response.Files, subFile)
-			}
-		}
-		if !hasPermittedPaths {
-			return response, errors.ErrPermissionDenied
-		}
-	}
-	if opts.Content {
-		processContent(response, index)
-	}
 	if settings.Config.Integrations.OnlyOffice.Secret != "" && info.Type != "directory" && iteminfo.IsOnlyOffice(info.Name) {
 		response.OnlyOfficeId = generateOfficeId(realPath)
 	}
-
+	if strings.HasPrefix(info.Type, "video") {
+		parentInfo, exists := index.GetReducedMetadata(filepath.Dir(info.Path), true)
+		if exists {
+			response.DetectSubtitles(parentInfo)
+		}
+	}
 	return response, nil
 }
 
-func processContent(info *iteminfo.ExtendedFileInfo, idx *indexing.Index) {
-	isVideo := strings.HasPrefix(info.Type, "video")
-	if isVideo {
-		parentInfo, exists := idx.GetReducedMetadata(filepath.Dir(info.Path), true)
-		if exists {
-			info.DetectSubtitles(parentInfo)
-			err := info.LoadSubtitleContent()
-			if err != nil {
-				logger.Debug("failed to load subtitle content: " + err.Error())
-			}
-		}
-		return
-	}
-	if info.Size < 20*1024*1024 { // 20 megabytes in bytes
-		content, err := getContent(info.RealPath)
-		if err != nil {
-			logger.Debugf("could not get content for file: "+info.RealPath, info.Name, err)
-			return
-		}
-		info.Content = content
-	} else {
-		logger.Debug("skipping large text file contents (20MB limit): "+info.Path, info.Name)
-	}
-}
-
 func generateOfficeId(realPath string) string {
-	key, ok := utils.OnlyOfficeCache.Get(realPath).(string)
+	key, ok := OnlyOfficeCache.Get(realPath).(string)
 	if !ok {
 		timestamp := strconv.FormatInt(time.Now().UnixMilli(), 10)
 		documentKey := utils.HashSHA256(realPath + timestamp)
-		utils.OnlyOfficeCache.Set(realPath, documentKey)
+		OnlyOfficeCache.Set(realPath, documentKey)
 		return documentKey
 	}
 	return key
@@ -173,9 +147,6 @@ func DeleteFiles(source, absPath string, absDirPath string) error {
 	if index == nil {
 		return fmt.Errorf("could not get index: %v ", source)
 	}
-	if index.Config.DisableIndexing {
-		return nil
-	}
 	refreshConfig := iteminfo.FileOptions{Path: index.MakeIndexPath(absDirPath), IsDir: true}
 	err = index.RefreshFileInfo(refreshConfig)
 	if err != nil {
@@ -184,88 +155,71 @@ func DeleteFiles(source, absPath string, absDirPath string) error {
 	return nil
 }
 
-func RefreshIndex(source string, path string, isDir bool) error {
-	idx := indexing.GetIndex(source)
-	if idx == nil {
-		return fmt.Errorf("could not get index: %v ", source)
-	}
-	if idx.Config.DisableIndexing {
-		return nil
-	}
-	path = idx.MakeIndexPath(path)
-	return idx.RefreshFileInfo(iteminfo.FileOptions{Path: path, IsDir: isDir})
-}
-
-// validateMoveDestination checks if a move/rename operation is valid
-// It prevents moving a directory into itself or its subdirectories
-func validateMoveDestination(src, dst string, isSrcDir bool) error {
-	// Clean and normalize paths
-	src = filepath.Clean(src)
-	dst = filepath.Clean(dst)
-
-	// If source is a directory, check if destination is within source
-	if isSrcDir {
-		// Get the parent directory of the destination
-		dstParent := filepath.Dir(dst)
-
-		// Check if destination parent is the source directory or a subdirectory of it
-		if strings.HasPrefix(dstParent+string(filepath.Separator), src+string(filepath.Separator)) || dstParent == src {
-			return fmt.Errorf("cannot move directory '%s' to a location within itself: '%s'", src, dst)
-		}
-	}
-
-	// Check if destination parent directory exists
-	dstParent := filepath.Dir(dst)
-	if dstParent != "." && dstParent != "/" {
-		if _, err := os.Stat(dstParent); os.IsNotExist(err) {
-			return fmt.Errorf("destination directory does not exist: '%s'", dstParent)
-		}
-	}
-
-	return nil
-}
-
-func MoveResource(isSrcDir, isDestDir bool, sourceIndex, destIndex, realsrc, realdst string, s *share.Storage) error {
-	// Validate the move operation before executing
-	if err := validateMoveDestination(realsrc, realdst, isSrcDir); err != nil {
-		return err
-	}
-
+func MoveResource(sourceIndex, destIndex, realsrc, realdst string) error {
 	err := fileutils.MoveFile(realsrc, realdst)
 	if err != nil {
 		return err
 	}
-	go RefreshIndex(sourceIndex, realsrc, isSrcDir) //nolint:errcheck
-	go RefreshIndex(destIndex, realdst, isDestDir)  //nolint:errcheck
-
-	// update shares
-	idx := indexing.GetIndex(sourceIndex)
-	if idx == nil {
+	idxSrc := indexing.GetIndex(sourceIndex)
+	if idxSrc == nil {
 		return fmt.Errorf("could not get index: %v ", sourceIndex)
 	}
-	idx2 := indexing.GetIndex(destIndex)
-	if idx2 == nil {
-		return fmt.Errorf("could not get index: %v ", destIndex)
+	idxDst := indexing.GetIndex(destIndex)
+	if idxDst == nil {
+		return fmt.Errorf("could not get index: %v ", sourceIndex)
+	}
+	refreshSourceDir := idxSrc.MakeIndexPath(filepath.Dir(realsrc))
+	refreshDestDir := idxDst.MakeIndexPath(filepath.Dir(realdst))
+	// refresh info for source and dest
+	err = idxSrc.RefreshFileInfo(iteminfo.FileOptions{
+		Path:  refreshSourceDir,
+		IsDir: true,
+	})
+	if err != nil {
+		return fmt.Errorf("could not refresh index for source: %v", err)
+	}
+	if refreshSourceDir == refreshDestDir {
+		return nil
+	}
+	refreshConfig := iteminfo.FileOptions{Path: refreshDestDir, IsDir: true}
+	err = idxDst.RefreshFileInfo(refreshConfig)
+	if err != nil {
+		return fmt.Errorf("could not refresh index for dest: %v", err)
 	}
-
-	// Use backend source paths to match how shares are stored
-	go s.UpdateShares(idx.Path, idx.MakeIndexPath(realsrc), idx2.Path, idx2.MakeIndexPath(realdst)) //nolint:errcheck
 	return nil
 }
 
-func CopyResource(isSrcDir, isDestDir bool, sourceIndex, destIndex, realsrc, realdst string) error {
-	// Validate the copy operation before executing
-	if err := validateMoveDestination(realsrc, realdst, isSrcDir); err != nil {
-		return err
-	}
-
+func CopyResource(sourceIndex, destIndex, realsrc, realdst string) error {
 	err := fileutils.CopyFile(realsrc, realdst)
 	if err != nil {
 		return err
 	}
-	go RefreshIndex(sourceIndex, realsrc, isSrcDir) //nolint:errcheck
-	go RefreshIndex(destIndex, realdst, isDestDir)  //nolint:errcheck
-	// update shares
+	idxSrc := indexing.GetIndex(sourceIndex)
+	if idxSrc == nil {
+		return fmt.Errorf("could not get index: %v ", sourceIndex)
+	}
+	idxDst := indexing.GetIndex(destIndex)
+	if idxDst == nil {
+		return fmt.Errorf("could not get index: %v ", sourceIndex)
+	}
+	refreshSourceDir := idxSrc.MakeIndexPath(filepath.Dir(realsrc))
+	refreshDestDir := idxDst.MakeIndexPath(filepath.Dir(realdst))
+	index := indexing.GetIndex(sourceIndex)
+	if index == nil {
+		return fmt.Errorf("could not get index: %v ", sourceIndex)
+	}
+	refreshConfig := iteminfo.FileOptions{Path: refreshSourceDir, IsDir: true}
+	// refresh info for source and dest
+	err = index.RefreshFileInfo(refreshConfig)
+	if err != nil {
+		return fmt.Errorf("could not refresh index for source: %v", err)
+	}
+	refreshConfig.Path = refreshDestDir
+	err = index.RefreshFileInfo(refreshConfig)
+	if err != nil {
+		return errors.ErrEmptyKey
+	}
+
 	return nil
 }
 
@@ -276,11 +230,15 @@ func WriteDirectory(opts iteminfo.FileOptions) error {
 	}
 	realPath, _, _ := idx.GetRealPath(opts.Path)
 	// Ensure the parent directories exist
-	err := os.MkdirAll(realPath, fileutils.PermDir)
+	err := os.MkdirAll(realPath, 0775)
 	if err != nil {
 		return err
 	}
-	return RefreshIndex(idx.Name, opts.Path, true)
+	err = idx.RefreshFileInfo(opts)
+	if err != nil {
+		return errors.ErrEmptyKey
+	}
+	return nil
 }
 
 func WriteFile(opts iteminfo.FileOptions, in io.Reader) error {
@@ -289,13 +247,15 @@ func WriteFile(opts iteminfo.FileOptions, in io.Reader) error {
 		return fmt.Errorf("could not get index: %v ", opts.Source)
 	}
 	dst, _, _ := idx.GetRealPath(opts.Path)
-	// Ensure the parent directories exist
-	err := os.MkdirAll(filepath.Dir(dst), fileutils.PermDir)
+	parentDir := filepath.Dir(dst)
+	// Create the directory and all necessary parents
+	err := os.MkdirAll(parentDir, 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, fileutils.PermFile)
+	file, err := os.OpenFile(dst, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0775)
 	if err != nil {
 		return err
 	}
@@ -306,131 +266,33 @@ func WriteFile(opts iteminfo.FileOptions, in io.Reader) error {
 	if err != nil {
 		return err
 	}
-	return RefreshIndex(opts.Source, opts.Path, false)
+	opts.Path = idx.MakeIndexPath(parentDir)
+	opts.IsDir = true
+	return idx.RefreshFileInfo(opts)
 }
 
-// getContent reads and returns the file content if it's considered an editable text file.
+// getContent reads and returns the file content if it's UTF-8 readable.
 func getContent(realPath string) (string, error) {
-	const headerSize = 4096
-	// Thresholds for detecting binary-like content (these can be tuned)
-	const maxNullBytesInHeaderAbs = 10    // Max absolute null bytes in header
-	const maxNullByteRatioInHeader = 0.1  // Max 10% null bytes in header
-	const maxNullByteRatioInFile = 0.05   // Max 5% null bytes in the entire file
-	const maxNonPrintableRuneRatio = 0.05 // Max 5% non-printable runes in the entire file
-
-	// Open file
-	f, err := os.Open(realPath)
-	if err != nil {
-		return "", err
-	}
-	defer f.Close()
-
-	// Read header
-	headerBytes := make([]byte, headerSize)
-	n, err := f.Read(headerBytes)
-	if err != nil && err != io.EOF {
-		return "", err
-	}
-	actualHeader := headerBytes[:n]
-
-	// --- Start of new heuristic checks ---
-
-	if n > 0 {
-		// 1. Basic Check: Is the header valid UTF-8?
-		// If not, it's unlikely an editable UTF-8 text file.
-		if !utf8.Valid(actualHeader) {
-			return "", nil // Not an error, just not the text file we want
-		}
-
-		// 2. Check for excessive null bytes in the header
-		nullCountInHeader := 0
-		for _, b := range actualHeader {
-			if b == 0x00 {
-				nullCountInHeader++
-			}
-		}
-		// Reject if too many nulls absolutely or relatively in the header
-		if nullCountInHeader > 0 { // Only perform check if there are any nulls
-			if nullCountInHeader > maxNullBytesInHeaderAbs ||
-				(float64(nullCountInHeader)/float64(n) > maxNullByteRatioInHeader) {
-				return "", nil // Too many nulls in header
-			}
-		}
-
-		// 3. Check for other non-text ASCII control characters in the header
-		// (C0 controls excluding \t, \n, \r)
-		for _, b := range actualHeader {
-			if b < 0x20 && b != '\t' && b != '\n' && b != '\r' {
-				return "", nil // Found problematic control character
-			}
-			// C1 control characters (0x80-0x9F) would be caught by utf8.Valid if part of invalid sequences,
-			// or by the non-printable rune check later if they form valid (but undesirable) codepoints.
-		}
-
-		// Optional: Use http.DetectContentType for an additional check on the header
-		// contentType := http.DetectContentType(actualHeader)
-		// if !strings.HasPrefix(contentType, "text/") && contentType != "application/octet-stream" {
-		//     // If it's clearly a non-text MIME type (e.g., "image/jpeg"), reject it.
-		//     // "application/octet-stream" is ambiguous, so we rely on other heuristics.
-		//     return "", nil
-		// }
-	}
-	// --- End of new heuristic checks for header ---
-
-	// Now read the full file (original logic)
+	// Read the entire file in one go. This is more efficient.
 	content, err := os.ReadFile(realPath)
 	if err != nil {
 		return "", err
 	}
-	// Handle empty file (original logic - returns specific string)
+
+	// Check if the file content is valid UTF-8.
+	// This allows for all characters, including ASCII and emojis.
+	if !utf8.Valid(content) {
+		// File is not valid text (e.g., a binary image), so we reject it.
+		return "", nil
+	}
+
+	// Handle the special case for an empty file, as in your original code.
 	if len(content) == 0 {
 		return "empty-file-x6OlSil", nil
 	}
 
-	stringContent := string(content)
-
-	// 4. Final UTF-8 validation for the entire file
-	// (This is crucial as the header might be fine, but the rest of the file isn't)
-	if !utf8.ValidString(stringContent) {
-		return "", nil
-	}
-
-	// 5. Check for excessive null bytes in the entire file content
-	if len(content) > 0 { // Check only for non-empty files
-		totalNullCount := 0
-		for _, b := range content {
-			if b == 0x00 {
-				totalNullCount++
-			}
-		}
-		if float64(totalNullCount)/float64(len(content)) > maxNullByteRatioInFile {
-			return "", nil // Too many nulls in the entire file
-		}
-	}
-
-	// 6. Check for excessive non-printable runes in the entire file content
-	// (Excluding tab, newline, carriage return, which are common in text files)
-	if len(stringContent) > 0 { // Check only for non-empty strings
-		nonPrintableRuneCount := 0
-		totalRuneCount := 0
-		for _, r := range stringContent {
-			totalRuneCount++
-			// unicode.IsPrint includes letters, numbers, punctuation, symbols, and spaces.
-			// It excludes control characters. We explicitly allow \t, \n, \r.
-			if !unicode.IsPrint(r) && r != '\t' && r != '\n' && r != '\r' {
-				nonPrintableRuneCount++
-			}
-		}
-
-		if totalRuneCount > 0 { // Avoid division by zero
-			if float64(nonPrintableRuneCount)/float64(totalRuneCount) > maxNonPrintableRuneRatio {
-				return "", nil // Too many non-printable runes
-			}
-		}
-	}
-
-	// The file has passed all checks and is considered editable text.
-	return stringContent, nil
+	// The file is valid, so return its string content.
+	return string(content), nil
 }
 
 func IsNamedPipe(mode os.FileMode) bool {

backend/adapters/fs/files/user.go

@@ -20,12 +20,12 @@ func MakeUserDir(fullPath string) error {
 func MakeUserDirs(u *users.User, disableScopeChange bool) error {
 	cleanedUserName := users.CleanUsername(u.Username)
 	if cleanedUserName == "" || cleanedUserName == "-" || cleanedUserName == "." {
-		return fmt.Errorf("MakeUserDirs: invalid user for home dir creation: [%s]", u.Username)
+		return fmt.Errorf("create user: invalid user for home dir creation: [%s]", u.Username)
 	}
 	for i, scope := range u.Scopes {
 		source, ok := settings.Config.Server.SourceMap[scope.Name]
 		if !ok {
-			return fmt.Errorf("MakeUserDirs: source not found: %s", scope.Name)
+			return fmt.Errorf("create user: source not found: %s", scope.Name)
 		}
 		// create directory and append user name
 		if filepath.Base(scope.Scope) != cleanedUserName && source.Config.CreateUserDir && !disableScopeChange {
@@ -33,19 +33,19 @@ func MakeUserDirs(u *users.User, disableScopeChange bool) error {
 			parentDir := filepath.Join(source.Path, scope.Scope)
 			// validate that scope path exists
 			if !Exists(parentDir) {
-				return fmt.Errorf("MakeUserDirs: scope path does not exist: %s", scope.Scope)
+				return fmt.Errorf("create user: scope path does not exist: %s", scope.Scope)
 			}
 			scope.Scope = filepath.Join(scope.Scope, cleanedUserName)
 			err := MakeUserDir(fullPath)
 			if err != nil {
-				return fmt.Errorf("MakeUserDirs: failed to create user home dir: %s", err)
+				return fmt.Errorf("create user: failed to create user home dir: %s", err)
 			}
 		} else if filepath.Base(scope.Scope) == cleanedUserName && source.Config.CreateUserDir {
 			// create directory exactly as specified
 			fullPath := filepath.Join(source.Path, scope.Scope)
 			parentDir := filepath.Dir(fullPath)
 			if !Exists(parentDir) {
-				return fmt.Errorf("MakeUserDirs: scope folder does not exist: %s", parentDir)
+				return fmt.Errorf("create user: scope folder does not exist: %s", parentDir)
 			}
 			err := MakeUserDir(fullPath)
 			if err != nil {
@@ -55,7 +55,7 @@ func MakeUserDirs(u *users.User, disableScopeChange bool) error {
 			// just assigning scope to path provided, so just check that it exists
 			path := filepath.Join(source.Path, scope.Scope)
 			if !Exists(path) {
-				return fmt.Errorf("MakeUserDirs: scope folder does not exist: %s", path)
+				return fmt.Errorf("create user: scope folder does not exist: %s", path)
 			}
 		}
 		u.Scopes[i] = scope

backend/adapters/fs/fileutils/file.go

@@ -10,9 +10,6 @@ import (
 	"github.com/gtsteffaniak/go-logger/logger"
 )
 
-const PermFile = 0644
-const PermDir = 0755
-
 // 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.
@@ -66,13 +63,13 @@ func copySingleFile(source, dest string) error {
 	defer src.Close()
 
 	// Create the destination directory if needed.
-	err = os.MkdirAll(filepath.Dir(dest), PermDir)
+	err = os.MkdirAll(filepath.Dir(dest), 0775) //nolint:gomnd
 	if err != nil {
 		return err
 	}
 
 	// Create the destination file.
-	dst, err := os.OpenFile(dest, os.O_RDWR|os.O_CREATE|os.O_TRUNC, PermFile)
+	dst, err := os.OpenFile(dest, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666) //nolint:gomnd
 	if err != nil {
 		return err
 	}
@@ -100,7 +97,7 @@ func copySingleFile(source, dest string) error {
 // copyDirectory handles copying directories recursively.
 func copyDirectory(source, dest string) error {
 	// Create the destination directory.
-	err := os.MkdirAll(dest, PermDir)
+	err := os.MkdirAll(dest, 0775) //nolint:gomnd
 	if err != nil {
 		return err
 	}

backend/auth/auth.go

@@ -8,14 +8,10 @@ import (
 )
 
 var (
-	revokedApiKeyList map[string]struct{}
+	revokedApiKeyList map[string]bool
 	revokeMu          sync.Mutex
 )
 
-func init() {
-	revokedApiKeyList = make(map[string]struct{})
-}
-
 // Auther is the authentication interface.
 type Auther interface {
 	// Auth is called to authenticate a request.
@@ -31,6 +27,6 @@ func IsRevokedApiKey(key string) bool {
 
 func RevokeAPIKey(key string) {
 	revokeMu.Lock()
-	defer revokeMu.Unlock()
-	revokedApiKeyList[key] = struct{}{}
+	delete(revokedApiKeyList, key)
+	revokeMu.Unlock()
 }

backend/auth/hook.go

@@ -0,0 +1,278 @@
+package auth
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+	"os/exec"
+	"strings"
+
+	"github.com/gtsteffaniak/filebrowser/backend/common/errors"
+	"github.com/gtsteffaniak/filebrowser/backend/common/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/database/users"
+	"github.com/gtsteffaniak/go-logger/logger"
+)
+
+type hookCred struct {
+	Password string `json:"password"`
+	Username string `json:"username"`
+}
+
+// HookAuth is a hook implementation of an Auther.
+type HookAuth struct {
+	Users    users.Store        `json:"-"`
+	Settings *settings.Settings `json:"-"`
+	Server   *settings.Server   `json:"-"`
+	Cred     hookCred           `json:"-"`
+	Fields   hookFields         `json:"-"`
+	Command  string             `json:"command"`
+}
+
+// Auth authenticates the user via a json in content body.
+func (a *HookAuth) Auth(r *http.Request, usr *users.Storage) (*users.User, error) {
+	var cred hookCred
+	if r.Body == nil {
+		return nil, os.ErrPermission
+	}
+
+	err := json.NewDecoder(r.Body).Decode(&cred)
+	if err != nil {
+		logger.Error("decode body error")
+		return nil, os.ErrPermission
+	}
+
+	a.Users = usr
+	a.Settings = &settings.Config
+	a.Server = &settings.Config.Server
+	a.Cred = cred
+
+	action, err := a.RunCommand()
+	if err != nil {
+		return nil, err
+	}
+	logger.Debugf("hook auth %v", action)
+
+	switch action {
+	case "auth":
+		u, err := a.SaveUser()
+		if err != nil {
+			return nil, err
+		}
+		return u, nil
+	case "block":
+		logger.Error("block error")
+
+		return nil, os.ErrPermission
+	case "pass":
+		logger.Error("pass error")
+
+		u, err := a.Users.Get(a.Cred.Username)
+		if err != nil {
+			return nil, fmt.Errorf("unable to get user from store: %v", err)
+		}
+		err = users.CheckPwd(cred.Password, u.Password)
+		if err != nil {
+			return nil, err
+		}
+		return u, nil
+	default:
+		return nil, fmt.Errorf("invalid hook action: %s", action)
+	}
+}
+
+// LoginPage tells that hook auth requires a login page.
+func (a *HookAuth) LoginPage() bool {
+	return true
+}
+
+// RunCommand starts the hook command and returns the action
+func (a *HookAuth) RunCommand() (string, error) {
+	command := strings.Split(a.Command, " ")
+	envMapping := func(key string) string {
+		switch key {
+		case "USERNAME":
+			return a.Cred.Username
+		case "PASSWORD":
+			return a.Cred.Password
+		default:
+			return os.Getenv(key)
+		}
+	}
+	for i, arg := range command {
+		if i == 0 {
+			continue
+		}
+		command[i] = os.Expand(arg, envMapping)
+	}
+
+	cmd := exec.Command(command[0], command[1:]...) //nolint:gosec
+	cmd.Env = append(os.Environ(), fmt.Sprintf("USERNAME=%s", a.Cred.Username))
+	cmd.Env = append(cmd.Env, fmt.Sprintf("PASSWORD=%s", a.Cred.Password))
+	out, err := cmd.Output()
+	if err != nil {
+		return "", err
+	}
+
+	a.GetValues(string(out))
+
+	return a.Fields.Values["hook.action"], nil
+}
+
+// GetValues creates a map with values from the key-value format string
+func (a *HookAuth) GetValues(s string) {
+	m := map[string]string{}
+
+	// make line breaks consistent on Windows platform
+	s = strings.ReplaceAll(s, "\r\n", "\n")
+
+	// iterate input lines
+	for _, val := range strings.Split(s, "\n") {
+		v := strings.SplitN(val, "=", 2) //nolint: gomnd
+
+		// skips non key and value format
+		if len(v) != 2 { //nolint: gomnd
+			continue
+		}
+
+		fieldKey := strings.TrimSpace(v[0])
+		fieldValue := strings.TrimSpace(v[1])
+
+		if a.Fields.IsValid(fieldKey) {
+			m[fieldKey] = fieldValue
+		}
+	}
+
+	a.Fields.Values = m
+}
+
+// SaveUser updates the existing user or creates a new one when not found
+func (a *HookAuth) SaveUser() (*users.User, error) {
+	u, err := a.Users.Get(a.Cred.Username)
+	if err != nil && err != errors.ErrNotExist {
+		return nil, err
+	}
+
+	if u == nil {
+		// create user with the provided credentials
+		d := &users.User{
+			NonAdminEditable: users.NonAdminEditable{
+				Password:    a.Cred.Password,
+				Locale:      a.Settings.UserDefaults.Locale,
+				ViewMode:    a.Settings.UserDefaults.ViewMode,
+				SingleClick: a.Settings.UserDefaults.SingleClick,
+				ShowHidden:  a.Settings.UserDefaults.ShowHidden,
+			},
+			Username:    a.Cred.Username,
+			Permissions: a.Settings.UserDefaults.Permissions,
+		}
+		u = a.GetUser(d)
+
+		err = a.Users.Save(u, false, false)
+		if err != nil {
+			return nil, err
+		}
+		return u, nil
+	}
+	err = users.CheckPwd(a.Cred.Password, u.Password)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(a.Fields.Values) > 1 {
+		u = a.GetUser(u)
+		// update user with provided fields
+		err := a.Users.Update(u, u.Permissions.Admin)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return u, nil
+}
+
+// GetUser returns a User filled with hook values or provided defaults
+func (a *HookAuth) GetUser(d *users.User) *users.User {
+	// adds all permissions when user is admin
+	isAdmin := d.Permissions.Admin
+	perms := users.Permissions{
+		Admin:  isAdmin,
+		Modify: isAdmin || d.Permissions.Modify,
+		Share:  isAdmin || d.Permissions.Share,
+	}
+	user := users.User{
+		NonAdminEditable: users.NonAdminEditable{
+			Password:    d.Password,
+			Locale:      a.Fields.GetString("user.locale", d.Locale),
+			ViewMode:    a.Fields.GetString("user.viewMode", d.ViewMode),
+			SingleClick: a.Fields.GetBoolean("user.singleClick", d.SingleClick),
+			ShowHidden:  a.Fields.GetBoolean("user.showHidden", d.ShowHidden),
+		},
+		ID:           d.ID,
+		Username:     d.Username,
+		Scopes:       d.Scopes,
+		Permissions:  perms,
+		LockPassword: true,
+	}
+
+	return &user
+}
+
+// hookFields is used to access fields from the hook
+type hookFields struct {
+	Values map[string]string
+}
+
+// validHookFields contains names of the fields that can be used
+var validHookFields = []string{
+	"hook.action",
+	"user.scope",
+	"user.locale",
+	"user.viewMode",
+	"user.singleClick",
+	"user.sorting.by",
+	"user.sorting.asc",
+	"user.showHidden",
+	"user.perm.admin",
+	"user.perm.modify",
+	"user.perm.share",
+	"user.perm.api",
+}
+
+// IsValid checks if the provided field is on the valid fields list
+func (hf *hookFields) IsValid(field string) bool {
+	for _, val := range validHookFields {
+		if field == val {
+			return true
+		}
+	}
+
+	return false
+}
+
+// GetString returns the string value or provided default
+func (hf *hookFields) GetString(k, dv string) string {
+	val, ok := hf.Values[k]
+	if ok {
+		return val
+	}
+	return dv
+}
+
+// GetBoolean returns the bool value or provided default
+func (hf *hookFields) GetBoolean(k string, dv bool) bool {
+	val, ok := hf.Values[k]
+	if ok {
+		return val == "true"
+	}
+	return dv
+}
+
+// GetArray returns the array value or provided default
+func (hf *hookFields) GetArray(k string, dv []string) []string {
+	val, ok := hf.Values[k]
+	if ok && strings.TrimSpace(val) != "" {
+		return strings.Split(val, " ")
+	}
+	return dv
+}

backend/auth/json.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/gtsteffaniak/filebrowser/backend/common/errors"
 	"github.com/gtsteffaniak/filebrowser/backend/database/users"
+	"github.com/gtsteffaniak/go-logger/logger"
 )
 
 // JSONAuth is a json implementation of an Auther.
@@ -19,10 +20,10 @@ type JSONAuth struct {
 
 // Auth authenticates the user via a json in content body.
 func (auther JSONAuth) Auth(r *http.Request, userStore *users.Storage) (*users.User, error) {
+	password := r.URL.Query().Get("password")
 	username := r.URL.Query().Get("username")
 	recaptcha := r.URL.Query().Get("recaptcha")
-	password := r.Header.Get("X-Password")
-	totpCode := r.Header.Get("X-Secret")
+	totpCode := r.URL.Query().Get("code")
 
 	// If ReCaptcha is enabled, check the code.
 	if auther.ReCaptcha != nil && len(auther.ReCaptcha.Secret) > 0 {
@@ -53,12 +54,21 @@ func (auther JSONAuth) Auth(r *http.Request, userStore *users.Storage) (*users.U
 		}
 		err = VerifyTotpCode(user, totpCode, userStore)
 		if err != nil {
+			logger.Error("OTP verification failed")
 			return nil, err
 		}
 	}
 
 	if user.LoginMethod != users.LoginMethodPassword {
-		return nil, errors.ErrWrongLoginMethod
+		logger.Warningf("user %s is not allowed to login with password authentication, bypassing and updating login method", user.Username)
+		user.LoginMethod = users.LoginMethodPassword
+		// Perform the user update
+		err = userStore.Update(user, true, "LoginMethod")
+		if err != nil {
+			logger.Debug(err.Error())
+		}
+		//http.Error(w, http.StatusText(http.StatusForbidden), http.StatusForbidden)
+		//return
 	}
 
 	return user, nil

backend/auth/storage.go

@@ -2,13 +2,10 @@ package auth
 
 import (
 	"encoding/base64"
-	"log"
-
-	"crypto/sha256"
 
 	"github.com/gtsteffaniak/filebrowser/backend/common/settings"
 	"github.com/gtsteffaniak/filebrowser/backend/database/users"
-	"golang.org/x/crypto/pbkdf2"
+	"github.com/gtsteffaniak/go-logger/logger"
 )
 
 // StorageBackend is a storage backend for auth storage.
@@ -34,23 +31,17 @@ func NewStorage(back StorageBackend, userStore *users.Storage) (*Storage, error)
 	if err != nil {
 		return nil, err
 	}
+	err = store.Save(&HookAuth{})
+	if err != nil {
+		return nil, err
+	}
 	err = store.Save(&NoAuth{})
 	if err != nil {
 		return nil, err
 	}
-	if settings.Config.Auth.TotpSecret != "" {
-		key, err := base64.StdEncoding.DecodeString(settings.Config.Auth.TotpSecret)
-		keyLen := len(key)
-
-		if err == nil && (keyLen == 16 || keyLen == 24 || keyLen == 25) {
-			// Use the user-provided key if it's valid
-			encryptionKey = key
-		} else {
-			// Otherwise, derive the key from the provided secret string
-			log.Println("[WARN] totpSecret is not a valid Base64 encoded key. Deriving a key from it. For better security, generate a secret with 'openssl rand -base64 32'.")
-			salt := []byte{0xda, 0x90, 0x45, 0xc3, 0x06, 0xb5, 0x99, 0x9f, 0xb6, 0xae, 0xfc, 0x14, 0xef, 0x27, 0x6e, 0x6a}
-			encryptionKey = pbkdf2.Key([]byte(settings.Config.Auth.TotpSecret), salt, 4096, 32, sha256.New)
-		}
+	encryptionKey, err = base64.StdEncoding.DecodeString(settings.Config.Auth.TotpSecret)
+	if err != nil {
+		logger.Warning("failed to decode TOTP secret, using default key. This is insecure and should be fixed.")
 	}
 	return store, nil
 }

backend/auth/totp.go

@@ -76,7 +76,7 @@ func GenerateOtpForUser(user *users.User, userStore *users.Storage) (string, err
 	}
 	// set cache so verify can attempt to use it but not require it for user yet.
 	TotpCache.Set(user.Username, secretText+"||"+nonce)
-	url := fmt.Sprintf("otpauth://totp/%v?secret=%v", "FileBrowser Quantum: "+user.Username, secretText)
+	url := "otpauth://totp/FileBrowser%20Quantum?secret=" + secretText
 	return url, nil
 }
 
@@ -190,14 +190,11 @@ func VerifyTotpCode(user *users.User, code string, userStore *users.Storage) err
 		user.TOTPSecret = totpSecret // The encrypted or plaintext secret
 		user.TOTPNonce = totpNonce   // The nonce if encrypted, or empty if plaintext
 		user.OtpEnabled = true       // Enable OTP for the user
-		// save user
-		if err := userStore.Update(user, true, "TOTPSecret", "TOTPNonce"); err != nil {
-			logger.Error("error updating user with OTP token:", err)
-			return fmt.Errorf("error updating user with OTP token: %w", err)
-		}
-	} else {
-		return fmt.Errorf("opt secret is empty, cannot enable TOTP")
 	}
-
+	// save user
+	if err := userStore.Update(user, user.Permissions.Admin, "TOTPSecret", "TOTPNonce"); err != nil {
+		logger.Debug("error updating user with OTP token:", err)
+		return fmt.Errorf("error updating user with OTP token: %w", err)
+	}
 	return nil
 }

backend/cmd/cli.go

@@ -11,10 +11,10 @@ import (
 
 	"github.com/goccy/go-yaml"
 	"github.com/gtsteffaniak/filebrowser/backend/common/settings"
+	"github.com/gtsteffaniak/filebrowser/backend/common/utils"
 	"github.com/gtsteffaniak/filebrowser/backend/common/version"
 	"github.com/gtsteffaniak/filebrowser/backend/database/storage"
 	"github.com/gtsteffaniak/filebrowser/backend/database/users"
-	"github.com/gtsteffaniak/filebrowser/backend/indexing/iteminfo"
 	"github.com/gtsteffaniak/go-logger/logger"
 )
 
@@ -36,15 +36,10 @@ func runCLI() bool {
 
 	if configPath == "" {
 		configPath = os.Getenv("FILEBROWSER_CONFIG")
-		// backwards compatibility in docker, prefer config.yaml if it exists
-		if configPath != "" {
-			_, err := os.Stat(configPath)
-			if err != nil {
-				logger.Fatalf("config file %v does not exist, please create it or set the FILEBROWSER_CONFIG environment variable to a valid config file path", configPath)
-			}
-		} else {
-			configPath = "config.yaml"
-		}
+	}
+
+	if configPath == "" {
+		configPath = "config.yaml"
 	}
 
 	// Parse global flags (before subcommands)
@@ -58,11 +53,12 @@ func runCLI() bool {
 
 	// Create a new FlagSet for the 'set' subcommand
 	setCmd := flag.NewFlagSet("set", flag.ExitOnError)
-	var user, dbConfig string
+	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 a user as admin user, used in combination with -u")
+	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", "config.yaml", "Path to the config file, default: config.yaml")
 
 	// Parse subcommand flags only if a subcommand is specified
@@ -85,7 +81,10 @@ func runCLI() bool {
 			}
 			username := userInfo[0]
 			password := userInfo[1]
-			_ = getStore(dbConfig) // ignore bool check
+			ok := getStore(dbConfig)
+			if !ok {
+				logger.Fatal("could not load db info")
+			}
 			user, err := store.Users.Get(username)
 			if err != nil {
 				newUser := users.User{
@@ -110,16 +109,14 @@ func runCLI() bool {
 				} else {
 					logger.Infof("Creating non-admin user: %s\n", username)
 				}
-				newUser.Permissions = settings.Config.UserDefaults.Permissions
-				newUser.Permissions.Admin = asAdmin
-				err = storage.CreateUser(newUser)
+				err = storage.CreateUser(newUser, asAdmin)
 				if err != nil {
 					logger.Errorf("could not create user: %v", err)
 				}
 				return false
 			}
 			if user.LoginMethod != users.LoginMethodPassword {
-				logger.Fatalf("user %s is not allowed to login with password authentication, cannot set password", username)
+				logger.Warningf("user %s is not allowed to login with password authentication, bypassing and updating login method", user.Username)
 			}
 			user.Password = password
 			user.TOTPSecret = "" // reset TOTP secret if it exists
@@ -258,7 +255,7 @@ func createConfig(configpath string) {
 		if err == nil {
 			var isDir bool
 			// Resolve symlinks and get the real path
-			realPath, isDir, _ = iteminfo.ResolveSymlinks(absolutePath)
+			realPath, isDir, _ = utils.ResolveSymlinks(absolutePath)
 			if realPath != "" && isDir {
 				break // Valid path found, exit loop
 			}

backend/cmd/root.go

@@ -7,23 +7,20 @@ import (
 	"os/signal"
 	"syscall"
 
-	_ "net/http/pprof"
-
 	"github.com/gtsteffaniak/filebrowser/backend/adapters/fs/fileutils"
 	"github.com/gtsteffaniak/filebrowser/backend/common/settings"
-	"github.com/gtsteffaniak/filebrowser/backend/common/utils"
-	"github.com/gtsteffaniak/filebrowser/backend/common/version"
 	"github.com/gtsteffaniak/filebrowser/backend/database/storage"
-	"github.com/gtsteffaniak/filebrowser/backend/database/storage/bolt"
 	fbhttp "github.com/gtsteffaniak/filebrowser/backend/http"
 	"github.com/gtsteffaniak/filebrowser/backend/indexing"
 	"github.com/gtsteffaniak/filebrowser/backend/preview"
 	"github.com/gtsteffaniak/filebrowser/backend/swagger/docs"
 	"github.com/gtsteffaniak/go-logger/logger"
 	"github.com/swaggo/swag"
+
+	"github.com/gtsteffaniak/filebrowser/backend/common/version"
 )
 
-var store *bolt.BoltStore
+var store *storage.Storage
 
 func getStore(configFile string) bool {
 	// Use the config file (global flag)
@@ -54,15 +51,6 @@ func StartFilebrowser() {
 	if !keepGoing {
 		return
 	}
-	if !settings.Config.Server.DisableUpdateCheck {
-		info, _ := utils.CheckForUpdates()
-		if info.LatestVersion != "" {
-			logger.Infof("A new version is available: %s (current: %s)", info.LatestVersion, info.CurrentVersion)
-			logger.Infof("Release notes: %s", info.ReleaseNotes)
-		}
-		go utils.StartCheckForUpdates()
-	}
-
 	// Create context and channels for graceful shutdown
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
@@ -122,7 +110,7 @@ func StartFilebrowser() {
 	logger.Info("Shutdown complete.")
 }
 
-func rootCMD(ctx context.Context, store *bolt.BoltStore, serverConfig *settings.Server, shutdownComplete chan struct{}) error {
+func rootCMD(ctx context.Context, store *storage.Storage, serverConfig *settings.Server, shutdownComplete chan struct{}) error {
 	if serverConfig.NumImageProcessors < 1 {
 		logger.Fatal("Image resize workers count could not be < 1")
 	}

backend/cmd/user.go

@@ -19,8 +19,11 @@ func validateUserInfo() {
 		logger.Fatalf("could not load users: %v", err)
 	}
 	for _, user := range usersList {
-		changePass := false
 		updateUser := false
+		if user.Username == "publicUser" {
+			settings.ApplyUserDefaults(user)
+			updateUser = true
+		}
 		if updateUserScopes(user) {
 			updateUser = true
 		}
@@ -33,16 +36,6 @@ func validateUserInfo() {
 		if updateLoginType(user) {
 			updateUser = true
 		}
-		adminUser := settings.Config.Auth.AdminUsername
-		adminPass := settings.Config.Auth.AdminPassword
-		passwordEnabled := settings.Config.Auth.Methods.PasswordAuth.Enabled
-		if user.Username == adminUser && adminPass != "" && passwordEnabled {
-			logger.Info("Resetting admin user to default username and password.")
-			user.Permissions.Admin = true
-			user.Password = settings.Config.Auth.AdminPassword
-			updateUser = true
-			changePass = true
-		}
 		if updateUser {
 			if len(createBackup) == 1 {
 				logger.Warning("Incompatible user settings detected, creating backup of database before converting.")
@@ -51,17 +44,31 @@ func validateUserInfo() {
 					logger.Fatalf("Unable to create automatic backup of database due to error: %v", err)
 				}
 			}
-			err := store.Users.Save(user, changePass, true)
+			err := store.Users.Save(user, false, true)
 			if err != nil {
 				logger.Errorf("could not update user: %v", err)
 			}
 		}
 	}
+	if settings.Config.Auth.ResetAdminOnStart {
+		logger.Info("Resetting admin user to default username and password.")
+		adminUser, err := store.Users.Get(1)
+		if err != nil {
+			logger.Fatalf("could not load admin user: %v", err)
+		}
+		adminUser.Username = settings.Config.Auth.AdminUsername
+		adminUser.Password = settings.Config.Auth.AdminPassword
+		adminUser.Permissions.Admin = true
+		err = store.Users.Save(adminUser, true, true)
+		if err != nil {
+			logger.Errorf("could not Save admin user: %v", err)
+		}
+	}
 }
 
 func updateUserScopes(user *users.User) bool {
 	newScopes := []users.SourceScope{}
-	seen := make(map[string]struct{})
+	seen := make(map[string]bool)
 
 	// Build map for existing scopes by Name
 	existing := make(map[string]users.SourceScope)
@@ -91,12 +98,12 @@ func updateUserScopes(user *users.User) bool {
 			Name:  realsource.Path,
 			Scope: existingScope.Scope,
 		})
-		seen[realsource.Path] = struct{}{}
+		seen[realsource.Path] = true
 	}
 
 	// Preserve user-defined scopes not matching current sources, append to end
 	for _, s := range user.Scopes {
-		if _, ok := seen[s.Name]; !ok {
+		if !seen[s.Name] {
 			newScopes = append(newScopes, s)
 		}
 	}

backend/cmd/user_test.go

@@ -17,6 +17,7 @@ func TestUpdateUserScopes_Phases(t *testing.T) {
 	}}
 	sourceB := settings.Source{Path: "/pathB", Name: "sourceB", Config: settings.SourceConfig{DefaultEnabled: true, DefaultUserScope: "/defaultB"}}
 	settings.Config.Server.Sources = []settings.Source{sourceA, sourceB}
+	settings.Config.Server.DefaultSource = sourceB
 	settings.Config.Server.SourceMap = map[string]settings.Source{
 		"/pathA": sourceA,
 		"/pathB": sourceB,
@@ -160,6 +161,7 @@ func TestUpdateUserScopes_Phases(t *testing.T) {
 	}}
 	sourceB = settings.Source{Path: "/pathB", Name: "sourceB", Config: settings.SourceConfig{DefaultEnabled: true, DefaultUserScope: "/defaultB"}}
 	settings.Config.Server.Sources = []settings.Source{sourceA, sourceB}
+	settings.Config.Server.DefaultSource = sourceB
 	settings.Config.Server.SourceMap = map[string]settings.Source{
 		"/pathA": sourceA,
 		"/pathB": sourceB,

backend/common/errors/errors.go

@@ -17,9 +17,8 @@ var (
 	ErrPermissionDenied     = errors.New("permission denied")
 	ErrInvalidRequestParams = errors.New("invalid request params")
 	ErrSourceIsParent       = errors.New("source is parent")
+	ErrRootUserDeletion     = errors.New("user with id 1 can't be deleted")
 	ErrNoTotpProvided       = errors.New("OTP code is required for user")
 	ErrNoTotpConfigured     = errors.New("OTP is enforced, but user is not yet configured")
 	ErrUnauthorized         = errors.New("user unauthorized")
-	ErrNotIndexed           = errors.New("directory or item excluded from indexing")
-	ErrWrongLoginMethod     = errors.New("user attempted to login with wrong login method")
 )

backend/common/settings/auth.go

@@ -12,12 +12,13 @@ import (
 )
 
 type Auth struct {
-	TokenExpirationHours int          `json:"tokenExpirationHours"` // time in hours each web UI session token is valid for. Default is 2 hours.
+	TokenExpirationHours int          `json:"tokenExpirationHours"` // the number of hours until the token expires. Default is 2 hours.
 	Methods              LoginMethods `json:"methods"`
-	Key                  string       `json:"key"`           // secret: the key used to sign the JWT tokens. If not set, a random key will be generated.
-	AdminUsername        string       `json:"adminUsername"` // secret: the username of the admin user. If not set, the default is "admin".
-	AdminPassword        string       `json:"adminPassword"` // secret: the password of the admin user. If not set, the default is "admin".
-	TotpSecret           string       `json:"totpSecret"`    // secret: secret used to encrypt TOTP secrets
+	Key                  string       `json:"key"`               // the key used to sign the JWT tokens. If not set, a random key will be generated.
+	AdminUsername        string       `json:"adminUsername"`     // the username of the admin user. If not set, the default is "admin".
+	AdminPassword        string       `json:"adminPassword"`     // the password of the admin user. If not set, the default is "admin".
+	ResetAdminOnStart    bool         `json:"resetAdminOnStart"` // if set to true, the admin user will be reset to the default username and password on startup.
+	TotpSecret           string       `json:"totpSecret"`        // secret used to encrypt TOTP secrets
 	AuthMethods          []string     `json:"-"`
 }
 
@@ -30,17 +31,16 @@ type LoginMethods struct {
 
 type PasswordAuthConfig struct {
 	Enabled     bool      `json:"enabled"`
-	MinLength   int       `json:"minLength" validate:"omitempty"` // minimum pasword length required, default is 5.
-	Signup      bool      `json:"signup" validate:"omitempty"`    // allow signups on login page if enabled -- not secure.
-	Recaptcha   Recaptcha `json:"recaptcha" validate:"omitempty"` // recaptcha config, only used if signup is enabled
-	EnforcedOtp bool      `json:"enforcedOtp"`                    // if set to true, TOTP is enforced for all password users users. Otherwise, users can choose to enable TOTP.
+	MinLength   int       `json:"minLength" validate:"omitempty,min=5"` // minimum pasword length required.
+	Signup      bool      `json:"signup" validate:"omitempty"`          // allow signups on login page if enabled -- not secure.
+	Recaptcha   Recaptcha `json:"recaptcha" validate:"omitempty"`       // recaptcha config, only used if signup is enabled
+	EnforcedOtp bool      `json:"enforcedOtp"`                          // if set to true, TOTP is enforced for all password users users. Otherwise, users can choose to enable TOTP.
 }
 
 type ProxyAuthConfig struct {
-	Enabled           bool   `json:"enabled"`
-	CreateUser        bool   `json:"createUser"`        // create user if not exists
-	Header            string `json:"header"`            // required header to use for authentication. Security Warning: FileBrowser blindly accepts the header value as username.
-	LogoutRedirectUrl string `json:"logoutRedirectUrl"` // if provider logout url is provided, filebrowser will also redirect to logout url. Custom logout query params are respected.
+	Enabled    bool   `json:"enabled"`
+	CreateUser bool   `json:"createUser"` // create user if not exists
+	Header     string `json:"header"`     // required header to use for authentication. Security Warning: FileBrowser blindly accepts the header value as username.
 }
 
 type Recaptcha struct {
@@ -52,16 +52,13 @@ type Recaptcha struct {
 // OpenID OAuth2.0
 type OidcConfig struct {
 	Enabled           bool                  `json:"enabled"`           // whether to enable OIDC authentication
-	ClientID          string                `json:"clientId"`          // secret: client id of the OIDC application
-	ClientSecret      string                `json:"clientSecret"`      // secret: client secret of the OIDC application
+	ClientID          string                `json:"clientId"`          // client id of the OIDC application
+	ClientSecret      string                `json:"clientSecret"`      // client secret of the OIDC application
 	IssuerUrl         string                `json:"issuerUrl"`         // authorization URL of the OIDC provider
 	Scopes            string                `json:"scopes"`            // scopes to request from the OIDC provider
-	UserIdentifier    string                `json:"userIdentifier"`    // the field value to use as the username. Default is "preferred_username", can also be "email" or "username", or "phone"
+	UserIdentifier    string                `json:"userIdentifier"`    // the user identifier to use for authentication. Default is "username", can be "email" or "username", or "phone"
 	DisableVerifyTLS  bool                  `json:"disableVerifyTLS"`  // disable TLS verification for the OIDC provider. This is insecure and should only be used for testing.
 	LogoutRedirectUrl string                `json:"logoutRedirectUrl"` // if provider logout url is provided, filebrowser will also redirect to logout url. Custom logout query params are respected.
-	CreateUser        bool                  `json:"createUser"`        // create user if not exists
-	AdminGroup        string                `json:"adminGroup"`        // if set, users in this group will be granted admin privileges.
-	GroupsClaim       string                `json:"groupsClaim"`       // the JSON field name to read groups from. Default is "groups"
 	Provider          *oidc.Provider        `json:"-"`                 // OIDC provider
 	Verifier          *oidc.IDTokenVerifier `json:"-"`                 // OIDC verifier
 }
@@ -69,19 +66,13 @@ type OidcConfig struct {
 // ValidateOidcAuth processes the OIDC callback and retrieves user identity
 func validateOidcAuth() error {
 	oidcCfg := &Config.Auth.Methods.OidcAuth // Use a pointer to modify the original config
-	if oidcCfg.GroupsClaim == "" {
-		oidcCfg.GroupsClaim = "groups"
-	}
-	if oidcCfg.UserIdentifier == "" {
-		oidcCfg.UserIdentifier = "preferred_username"
-	}
-	if oidcCfg.Scopes == "" {
-		oidcCfg.Scopes = "openid email profile"
-	}
-
 	if !oidcCfg.Enabled {
 		return errors.New("OIDC is not enabled")
 	}
+	if oidcCfg.UserIdentifier == "" {
+		oidcCfg.UserIdentifier = "username"
+	}
+
 	ctx := context.Background()
 
 	// If disableVerifyTLS is true, create a custom HTTP client
@@ -106,6 +97,9 @@ func validateOidcAuth() error {
 	}
 	oidcCfg.Provider = provider
 	oidcCfg.Verifier = provider.Verifier(&oidc.Config{ClientID: oidcCfg.ClientID})
+	if oidcCfg.Scopes == "" {
+		oidcCfg.Scopes = "openid email profile"
+	}
 
 	return nil
 }

backend/common/settings/config.go

@@ -5,7 +5,6 @@ import (
 	"log"
 	"os"
 	"path/filepath"
-	"runtime"
 	"slices"
 	"strings"
 	"time"
@@ -24,33 +23,28 @@ const (
 )
 
 func Initialize(configFile string) {
-	err := loadConfigWithDefaults(configFile, false)
+	err := loadConfigWithDefaults(configFile)
 	if err != nil {
-		logger.Error("unable to load config, waiting 5 seconds before exiting...")
-		time.Sleep(5 * time.Second) // allow sleep time before exiting to give docker/kubernetes time before restarting
 		logger.Fatal(err.Error())
 	}
 	err = ValidateConfig(Config)
 	if err != nil {
 		errmsg := "The provided config file failed validation. "
-		errmsg += "If you are seeing this on a config that worked before, "
-		errmsg += "then check the latest releases for breaking changes. "
+		errmsg += "If you are seeing this on a config that worked previeously, "
+		errmsg += "please review your config for typos and invalid keys which are no longer supported. "
 		errmsg += "visit https://github.com/gtsteffaniak/filebrowser/wiki/Full-Config-Example for more information."
 		logger.Error(errmsg)
 		time.Sleep(5 * time.Second) // allow sleep time before exiting to give docker/kubernetes time before restarting
 		logger.Fatal(err.Error())
 	}
 	setupLogging()
-	setupAuth(false)
+	setupAuth()
 	setupSources(false)
 	setupUrls()
-	setupFrontend(false)
+	setupFrontend()
 }
 
-func setupFrontend(generate bool) {
-	if Config.Server.MinSearchLength == 0 {
-		Config.Server.MinSearchLength = 3
-	}
+func setupFrontend() {
 	if !Config.Frontend.DisableDefaultLinks {
 		Config.Frontend.ExternalLinks = append(Config.Frontend.ExternalLinks, ExternalLink{
 			Text:  fmt.Sprintf("(%v)", version.Version),
@@ -59,41 +53,9 @@ func setupFrontend(generate bool) {
 		})
 		Config.Frontend.ExternalLinks = append(Config.Frontend.ExternalLinks, ExternalLink{
 			Text: "Help",
-			Url:  "help prompt",
+			Url:  "https://github.com/gtsteffaniak/filebrowser/wiki",
 		})
 	}
-	if Config.Frontend.Description == "" {
-		Config.Frontend.Description = "FileBrowser Quantum is a file manager for the web which can be used to manage files on your server"
-	}
-	Config.Frontend.Styling.LightBackground = FallbackColor(Config.Frontend.Styling.LightBackground, "#f5f5f5")
-	Config.Frontend.Styling.DarkBackground = FallbackColor(Config.Frontend.Styling.DarkBackground, "#141D24")
-	Config.Frontend.Styling.CustomCSSRaw = readCustomCSS(Config.Frontend.Styling.CustomCSS)
-	Config.Frontend.Styling.CustomThemeOptions = map[string]CustomTheme{}
-	Config.Frontend.Styling.CustomThemes = map[string]CustomTheme{}
-	for name, theme := range Config.Frontend.Styling.CustomThemes {
-		addCustomTheme(name, theme.Description, theme.CSS)
-	}
-	noThemes := len(Config.Frontend.Styling.CustomThemes) == 0
-	if noThemes {
-		addCustomTheme("default", "The default theme", "")
-		// check if file exists
-		if _, err := os.Stat("reduce-rounded-corners.css"); err == nil {
-			addCustomTheme("alternative", "Reduce rounded corners", "reduce-rounded-corners.css")
-			if generate {
-				Config.Frontend.Styling.CustomThemes["alternative"] = CustomTheme{
-					Description: "Reduce rounded corners",
-					CSS:         "reduce-rounded-corners.css",
-				}
-			}
-		}
-	}
-	_, ok := Config.Frontend.Styling.CustomThemes["default"]
-	if !ok {
-		addCustomTheme("default", "The default theme", "")
-	}
-
-	// Load custom favicon if configured
-	loadCustomFavicon()
 }
 
 func getRealPath(path string) string {
@@ -113,9 +75,6 @@ func setupSources(generate bool) {
 		logger.Fatal("There are no `server.sources` configured. If you have `server.root` configured, please update the config and add at least one `server.sources` with a `path` configured.")
 	} else {
 		for k, source := range Config.Server.Sources {
-			if source.Config.Disabled {
-				continue
-			}
 			realPath := getRealPath(source.Path)
 			name := filepath.Base(realPath)
 			if name == "\\" {
@@ -133,9 +92,10 @@ func setupSources(generate bool) {
 				} else {
 					source.Name = name
 				}
+				if Config.Server.DefaultSource.Path == "" {
+					Config.Server.DefaultSource = source
+				}
 			}
-			modifyExcludeInclude(&source)
-
 			if source.Config.DefaultUserScope == "" {
 				source.Config.DefaultUserScope = "/"
 			}
@@ -147,6 +107,8 @@ func setupSources(generate bool) {
 	sourceList := []Source{}
 	defaultScopes := []users.SourceScope{}
 	allSourceNames := []string{}
+	first := true
+	potentialDefaultSource := Config.Server.DefaultSource
 	for _, sourcePathOnly := range Config.Server.Sources {
 		realPath := getRealPath(sourcePathOnly.Path)
 		if generate {
@@ -154,8 +116,15 @@ func setupSources(generate bool) {
 		}
 		source, ok := Config.Server.SourceMap[realPath]
 		if ok && !slices.Contains(allSourceNames, source.Name) {
+			if first {
+				potentialDefaultSource = source
+			}
+			first = false
 			sourceList = append(sourceList, source)
 			if source.Config.DefaultEnabled {
+				if Config.Server.DefaultSource.Path == "" {
+					Config.Server.DefaultSource = source
+				}
 				defaultScopes = append(defaultScopes, users.SourceScope{
 					Name:  source.Path,
 					Scope: source.Config.DefaultUserScope,
@@ -166,6 +135,19 @@ func setupSources(generate bool) {
 			logger.Warningf("source %v is not configured correctly, skipping", sourcePathOnly.Path)
 		}
 	}
+	if Config.Server.DefaultSource.Path == "" {
+		Config.Server.DefaultSource = potentialDefaultSource
+	}
+	sourceList2 := []Source{}
+	for _, s := range sourceList {
+		if s.Path == Config.Server.DefaultSource.Path {
+			s.Config.DefaultEnabled = true
+			Config.Server.SourceMap[s.Path] = s
+			Config.Server.NameToSource[s.Name] = s
+		}
+		sourceList2 = append(sourceList2, s)
+	}
+	sourceList = sourceList2
 	Config.UserDefaults.DefaultScopes = defaultScopes
 	Config.Server.Sources = sourceList
 }
@@ -177,24 +159,13 @@ func setupUrls() {
 	} else {
 		Config.Server.BaseURL = "/" + baseurl + "/"
 	}
-	if Config.Server.BaseURL != "/" {
-		if Config.Server.ExternalUrl != "" {
-			Config.Server.ExternalUrl = strings.TrimSuffix(Config.Server.ExternalUrl, "/") + "/"
-			Config.Server.ExternalUrl = strings.TrimSuffix(Config.Server.ExternalUrl, Config.Server.BaseURL)
-		}
-		if Config.Server.InternalUrl != "" {
-			Config.Server.InternalUrl = strings.TrimSuffix(Config.Server.InternalUrl, "/") + "/"
-			Config.Server.InternalUrl = strings.TrimSuffix(Config.Server.InternalUrl, Config.Server.BaseURL)
-		}
-	}
+	Config.Server.InternalUrl = strings.Trim(Config.Server.InternalUrl, "/")
+	Config.Server.ExternalUrl = strings.Trim(Config.Server.ExternalUrl, "/")
 	Config.Integrations.OnlyOffice.Url = strings.Trim(Config.Integrations.OnlyOffice.Url, "/")
 	Config.Integrations.OnlyOffice.InternalUrl = strings.Trim(Config.Integrations.OnlyOffice.InternalUrl, "/")
 }
 
-func setupAuth(generate bool) {
-	if generate {
-		Config.Auth.AdminPassword = "admin"
-	}
+func setupAuth() {
 	if Config.Auth.Methods.PasswordAuth.Enabled {
 		Config.Auth.AuthMethods = append(Config.Auth.AuthMethods, "password")
 	}
@@ -208,9 +179,9 @@ func setupAuth(generate bool) {
 		logger.Warning("Configured with no authentication, this is not recommended.")
 		Config.Auth.AuthMethods = []string{"disabled"}
 	}
-	if Config.Auth.Methods.OidcAuth.Enabled || generate {
+	if Config.Auth.Methods.OidcAuth.Enabled {
 		err := validateOidcAuth()
-		if err != nil && !generate {
+		if err != nil {
 			logger.Fatalf("Error validating OIDC auth: %v", err)
 		}
 		logger.Info("OIDC Auth configured successfully")
@@ -234,14 +205,8 @@ func setupLogging() {
 		}
 	}
 	for _, logConfig := range Config.Server.Logging {
-		// Enable debug logging automatically in dev mode
-		levels := logConfig.Levels
-		if os.Getenv("FILEBROWSER_DEVMODE") == "true" {
-			levels = "info|warning|error|debug"
-		}
-
 		logConfig := logger.JsonConfig{
-			Levels:    levels,
+			Levels:    logConfig.Levels,
 			ApiLevels: logConfig.ApiLevels,
 			Output:    logConfig.Output,
 			Utc:       logConfig.Utc,
@@ -255,21 +220,12 @@ func setupLogging() {
 	}
 }
 
-func loadConfigWithDefaults(configFile string, generate bool) error {
-	Config = setDefaults(generate)
+func loadConfigWithDefaults(configFile string) error {
+	Config = setDefaults()
 	// Open and read the YAML file
 	yamlFile, err := os.Open(configFile)
 	if err != nil {
-		if configFile != "" {
-			logger.Errorf("could not open config file '%v', using default settings.", configFile)
-		}
-		Config.Server.Sources = []Source{
-			{
-				Path: ".",
-			},
-		}
-		loadEnvConfig()
-		return nil
+		logger.Warningf("could not open config file '%v', using default settings", configFile)
 	}
 	defer yamlFile.Close()
 	stat, err := yamlFile.Stat()
@@ -303,6 +259,7 @@ func ValidateConfig(config Settings) error {
 }
 
 func loadEnvConfig() {
+
 	adminPassword, ok := os.LookupEnv("FILEBROWSER_ADMIN_PASSWORD")
 	if ok {
 		logger.Info("Using admin password from FILEBROWSER_ADMIN_PASSWORD environment variable")
@@ -319,55 +276,15 @@ func loadEnvConfig() {
 		Config.Integrations.Media.FfmpegPath = ffmpegPath
 	}
 
-	oidcClientId := os.Getenv("FILEBROWSER_OIDC_CLIENT_ID")
-	if oidcClientId != "" {
-		Config.Auth.Methods.OidcAuth.ClientID = oidcClientId
-		logger.Info("Using OIDC Client ID from FILEBROWSER_OIDC_CLIENT_ID environment variable")
-	}
-
-	oidcClientSecret := os.Getenv("FILEBROWSER_OIDC_CLIENT_SECRET")
-	if oidcClientSecret != "" {
-		Config.Auth.Methods.OidcAuth.ClientSecret = oidcClientSecret
-		logger.Info("Using OIDC Client Secret from FILEBROWSER_OIDC_CLIENT_SECRET environment variable")
-	}
-
-	jwtTokenSecret := os.Getenv("FILEBROWSER_JWT_TOKEN_SECRET")
-	if jwtTokenSecret != "" {
-		Config.Auth.Key = jwtTokenSecret
-		logger.Info("Using JWT Token Secret from FILEBROWSER_JWT_TOKEN_SECRET environment variable")
-	}
-
-	totpSecret := os.Getenv("FILEBROWSER_TOTP_SECRET")
-	if totpSecret != "" {
-		Config.Auth.TotpSecret = totpSecret
-		logger.Info("Using TOTP Secret from FILEBROWSER_TOTP_SECRET environment variable")
-	}
-
-	recaptchaSecret := os.Getenv("FILEBROWSER_RECAPTCHA_SECRET")
-	if recaptchaSecret != "" {
-		Config.Auth.Methods.PasswordAuth.Recaptcha.Secret = recaptchaSecret
-		logger.Info("Using ReCaptcha Secret from FILEBROWSER_RECAPTCHA_SECRET environment variable")
-	}
-
 }
 
-func setDefaults(generate bool) Settings {
-	// get number of CPUs available
-	numCpus := 4 // default to 4 CPUs if runtime.NumCPU() fails or is not available
-	cpus := runtime.NumCPU()
-	if cpus > 0 && !generate {
-		numCpus = cpus
-	}
-	database := os.Getenv("FILEBROWSER_DATABASE")
-	if database == "" {
-		database = "database.db"
-	}
+func setDefaults() Settings {
 	return Settings{
 		Server: Server{
 			Port:               80,
-			NumImageProcessors: numCpus,
+			NumImageProcessors: 4,
 			BaseURL:            "",
-			Database:           database,
+			Database:           "database.db",
 			SourceMap:          map[string]Source{},
 			NameToSource:       map[string]Source{},
 			MaxArchiveSizeGB:   50,
@@ -375,6 +292,7 @@ func setDefaults(generate bool) Settings {
 		},
 		Auth: Auth{
 			AdminUsername:        "admin",
+			AdminPassword:        "admin",
 			TokenExpirationHours: 2,
 			Methods: LoginMethods{
 				PasswordAuth: PasswordAuthConfig{
@@ -387,27 +305,23 @@ func setDefaults(generate bool) Settings {
 		Frontend: Frontend{
 			Name: "FileBrowser Quantum",
 		},
-
 		UserDefaults: UserDefaults{
-			StickySidebar:   true,
-			LockPassword:    false,
-			ShowHidden:      false,
-			DarkMode:        true,
-			DisableSettings: false,
-			ViewMode:        "normal",
-			Locale:          "en",
-			GallerySize:     3,
-			ThemeColor:      "var(--blue)",
+			DisableOnlyOfficeExt: ".txt .csv .html .pdf",
+			StickySidebar:        true,
+			LockPassword:         false,
+			ShowHidden:           false,
+			DarkMode:             true,
+			DisableSettings:      false,
+			ViewMode:             "normal",
+			Locale:               "en",
+			GallerySize:          3,
+			ThemeColor:           "var(--blue)",
 			Permissions: users.Permissions{
 				Modify: false,
 				Share:  false,
 				Admin:  false,
 				Api:    false,
 			},
-			FileLoading: users.FileLoading{
-				MaxConcurrent: 10,
-				ChunkSize:     10, // 10MB
-			},
 		},
 	}
 }
@@ -519,76 +433,3 @@ func GetSources(u *users.User) []string {
 	}
 	return sources
 }
-
-func loadCustomFavicon() {
-	// Check if a custom favicon path is configured
-	if Config.Frontend.Favicon == "" {
-		logger.Debug("No custom favicon configured, using default")
-		return
-	}
-
-	// Get absolute path for the favicon
-	faviconPath, err := filepath.Abs(Config.Frontend.Favicon)
-	if err != nil {
-		logger.Warningf("Could not resolve favicon path '%v': %v", Config.Frontend.Favicon, err)
-		Config.Frontend.Favicon = "" // Unset invalid path
-		return
-	}
-
-	// Check if the favicon file exists and get info
-	stat, err := os.Stat(faviconPath)
-	if err != nil {
-		logger.Warningf("Could not access custom favicon file '%v': %v", faviconPath, err)
-		Config.Frontend.Favicon = "" // Unset invalid path
-		return
-	}
-
-	// Check file size (limit to 1MB for security)
-	const maxFaviconSize = 1024 * 1024 // 1MB
-	if stat.Size() > maxFaviconSize {
-		logger.Warningf("Favicon file '%v' is too large (%d bytes), maximum allowed is %d bytes", faviconPath, stat.Size(), maxFaviconSize)
-		Config.Frontend.Favicon = "" // Unset invalid path
-		return
-	}
-
-	// Validate file format based on extension
-	ext := strings.ToLower(filepath.Ext(faviconPath))
-	switch ext {
-	case ".ico", ".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp":
-		// Valid favicon formats
-	default:
-		logger.Warningf("Unsupported favicon format '%v', supported formats: .ico, .png, .jpg, .gif, .svg, .webp", ext)
-		Config.Frontend.Favicon = "" // Unset invalid path
-		return
-	}
-
-	// Update to absolute path and mark as valid
-	Config.Frontend.Favicon = faviconPath
-
-	logger.Infof("Successfully validated custom favicon at '%v' (%d bytes, %s)", faviconPath, stat.Size(), ext)
-}
-
-func modifyExcludeInclude(config *Source) {
-	normalize := func(s []string, checkExists bool) {
-		for i, v := range s {
-			s[i] = "/" + strings.Trim(v, "/")
-			// check if file/folder exists
-			if checkExists {
-				realPath, err := filepath.Abs(config.Path + s[i])
-				if err != nil {
-					logger.Warningf("could not get absolute path for %v: %v", s[i], err)
-					continue
-				}
-				if _, err := os.Stat(realPath); os.IsNotExist(err) {
-					logger.Warningf("configured exclude/include path %v does not exist", realPath)
-				}
-			}
-		}
-	}
-
-	normalize(config.Config.Exclude.FolderPaths, true)
-	normalize(config.Config.Exclude.FilePaths, true)
-	normalize(config.Config.Include.RootFolders, true)
-	normalize(config.Config.Include.RootFiles, true)
-	normalize(config.Config.NeverWatchPaths, true)
-}

backend/common/settings/config_test.go

@@ -34,7 +34,7 @@ func Test_setDefaults(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if got := setDefaults(true); !reflect.DeepEqual(got, tt.want) {
+			if got := setDefaults(); !reflect.DeepEqual(got, tt.want) {
 				t.Errorf("setDefaults() = %v, want %v", got, tt.want)
 			}
 		})
@@ -42,8 +42,8 @@ func Test_setDefaults(t *testing.T) {
 }
 
 func TestConfigLoadChanged(t *testing.T) {
-	defaultConfig := setDefaults(true)
-	err := loadConfigWithDefaults("./validConfig.yaml", true)
+	defaultConfig := setDefaults()
+	err := loadConfigWithDefaults("./validConfig.yaml")
 	if err != nil {
 		t.Fatalf("error loading config file: %v", err)
 	}
@@ -54,11 +54,11 @@ func TestConfigLoadChanged(t *testing.T) {
 }
 
 func TestConfigLoadEnvVars(t *testing.T) {
-	defaultConfig := setDefaults(true)
+	defaultConfig := setDefaults()
 	expectedKey := "MYKEY"
 	// mock environment variables
 	os.Setenv("FILEBROWSER_ONLYOFFICE_SECRET", expectedKey)
-	err := loadConfigWithDefaults("./validConfig.yaml", true)
+	err := loadConfigWithDefaults("./validConfig.yaml")
 	if err != nil {
 		t.Fatalf("error loading config file: %v", err)
 	}
@@ -72,8 +72,8 @@ func TestConfigLoadEnvVars(t *testing.T) {
 }
 
 func TestConfigLoadSpecificValues(t *testing.T) {
-	defaultConfig := setDefaults(true)
-	err := loadConfigWithDefaults("./validConfig.yaml", true)
+	defaultConfig := setDefaults()
+	err := loadConfigWithDefaults("./validConfig.yaml")
 	if err != nil {
 		t.Fatalf("error loading config file: %v", err)
 	}
@@ -94,7 +94,7 @@ func TestConfigLoadSpecificValues(t *testing.T) {
 
 func TestInvalidConfig(t *testing.T) {
 	configFile := "./invalidConfig.yaml"
-	err := loadConfigWithDefaults(configFile, true)
+	err := loadConfigWithDefaults(configFile)
 	if err == nil {
 		t.Fatalf("expected error loading config file %s, got nil", configFile)
 	}

backend/common/settings/generator.go

@@ -14,44 +14,19 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
-// CommentsMap[typeName][fieldName] = combined doc+inline comment text
-type CommentsMap map[string]map[string]string
+// commentsMap[typeName][fieldName] = combined doc+inline comment text
+type commentsMap map[string]map[string]string
 
-// SecretFieldsMap[typeName][fieldName] = true if field should be redacted
-type SecretFieldsMap map[string]map[string]bool
-
-// DeprecatedFieldsMap[typeName][fieldName] = true if field is deprecated
-type DeprecatedFieldsMap map[string]map[string]bool
-
-// getStringStyle determines whether a string should be quoted in YAML
-func getStringStyle(value string) yaml.Style {
-	// Always quote all strings for consistency
-	return yaml.DoubleQuotedStyle
-}
-
-// CollectComments parses all Go source in the directory of srcPath and returns CommentsMap.
-func CollectComments(srcPath string) (CommentsMap, error) {
-	comments, _, _, err := CollectCommentsAndSecrets(srcPath)
-	return comments, err
-}
-
-// CollectCommentsAndSecrets parses all Go source and returns comments, secrets, and deprecated field mappings
-func CollectCommentsAndSecrets(srcPath string) (CommentsMap, SecretFieldsMap, DeprecatedFieldsMap, error) {
+// collectComments parses all Go source in the directory of srcPath and returns commentsMap.
+func collectComments(srcPath string) (commentsMap, error) {
 	// parse entire package so we capture comments on all types
-	dir := srcPath
-	if filepath.IsAbs(srcPath) {
-		// If it's an absolute path to a file, get the directory
-		dir = filepath.Dir(srcPath)
-	}
-
+	dir := filepath.Dir(srcPath)
 	fset := token.NewFileSet()
 	pkgs, err := parser.ParseDir(fset, dir, nil, parser.ParseComments)
 	if err != nil {
-		return nil, nil, nil, err
+		return nil, err
 	}
-	comments := make(CommentsMap)
-	secrets := make(SecretFieldsMap)
-	deprecated := make(DeprecatedFieldsMap)
+	out := make(commentsMap)
 	for _, pkg := range pkgs {
 		for _, file := range pkg.Files {
 			for _, decl := range file.Decls {
@@ -68,82 +43,42 @@ func CollectCommentsAndSecrets(srcPath string) (CommentsMap, SecretFieldsMap, De
 					if !ok {
 						continue
 					}
-					typeName := ts.Name.Name
-					commentMap := make(map[string]string)
-					secretMap := make(map[string]bool)
-					deprecatedMap := make(map[string]bool)
-					comments[typeName] = commentMap
-					secrets[typeName] = secretMap
-					deprecated[typeName] = deprecatedMap
-
+					m := make(map[string]string)
+					out[ts.Name.Name] = m
 					for _, field := range st.Fields.List {
 						if len(field.Names) == 0 {
 							continue
 						}
 						name := field.Names[0].Name
 						var parts []string
-						var fullComment string
-
 						if field.Doc != nil {
-							docText := strings.TrimSpace(field.Doc.Text())
-							parts = append(parts, docText)
-							fullComment += docText + " "
+							parts = append(parts, strings.TrimSpace(field.Doc.Text()))
 						}
 						if field.Comment != nil {
-							commentText := strings.TrimSpace(field.Comment.Text())
-							parts = append(parts, commentText)
-							fullComment += commentText
+							parts = append(parts, strings.TrimSpace(field.Comment.Text()))
 						}
-
 						if len(parts) > 0 {
-							commentMap[name] = strings.Join(parts, " : ")
-						}
-
-						// Check if field should be treated as secret
-						if strings.Contains(strings.ToLower(fullComment), "secret:") {
-							secretMap[name] = true
-						}
-
-						// Check if field should be treated as deprecated
-						if strings.Contains(strings.ToLower(fullComment), "deprecated:") {
-							deprecatedMap[name] = true
+							m[name] = strings.Join(parts, " : ")
 						}
 					}
 				}
 			}
 		}
 	}
-	return comments, secrets, deprecated, nil
+	return out, nil
 }
 
-// BuildNode constructs a yaml.Node for any Go value, injecting comments on struct fields.
-func BuildNode(v reflect.Value, comm CommentsMap) (*yaml.Node, error) {
-	return buildNodeWithDefaults(v, comm, reflect.Value{}, SecretFieldsMap{}, DeprecatedFieldsMap{})
-}
-
-// buildNodeWithDefaults constructs a yaml.Node for any Go value, skipping fields that match defaults, redacting secrets, and filtering deprecated fields
-func buildNodeWithDefaults(v reflect.Value, comm CommentsMap, defaults reflect.Value, secrets SecretFieldsMap, deprecated DeprecatedFieldsMap) (*yaml.Node, error) {
+// buildNode constructs a yaml.Node for any Go value, injecting comments on struct fields.
+func buildNode(v reflect.Value, comm commentsMap) (*yaml.Node, error) {
 	// Dereference pointers
 	if v.Kind() == reflect.Ptr {
 		if v.IsNil() {
 			return &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!null", Value: "null"}, nil
 		}
-		var defaultsElem reflect.Value
-		if defaults.IsValid() && !defaults.IsNil() {
-			defaultsElem = defaults.Elem()
-		}
-		return buildNodeWithDefaults(v.Elem(), comm, defaultsElem, secrets, deprecated)
+		return buildNode(v.Elem(), comm)
 	}
 
 	switch v.Kind() {
-	case reflect.String:
-		value := v.String()
-		return &yaml.Node{
-			Kind:  yaml.ScalarNode,
-			Tag:   "!!str",
-			Value: value,
-			Style: getStringStyle(value),
-		}, nil
 	case reflect.Struct:
 		rt := v.Type()
 		typeName := rt.Name()
@@ -162,26 +97,6 @@ func buildNodeWithDefaults(v reflect.Value, comm CommentsMap, defaults reflect.V
 				continue
 			}
 
-			// Skip deprecated fields if filtering is enabled
-			if len(deprecated) > 0 && deprecated[typeName][sf.Name] {
-				continue
-			}
-
-			currentField := v.Field(i)
-
-			// If we have defaults, compare and skip if values match
-			if defaults.IsValid() && i < defaults.NumField() {
-				defaultField := defaults.Field(i)
-				currentValue := currentField.Interface()
-				defaultValue := defaultField.Interface()
-
-				isEqual := reflect.DeepEqual(currentValue, defaultValue)
-
-				if isEqual {
-					continue // Skip this field as it matches the default
-				}
-			}
-
 			// determine key: yaml tag > json tag > field name
 			yamlTag := sf.Tag.Get("yaml")
 			jsonTag := sf.Tag.Get("json")
@@ -196,43 +111,22 @@ func buildNodeWithDefaults(v reflect.Value, comm CommentsMap, defaults reflect.V
 
 			keyNode := &yaml.Node{Kind: yaml.ScalarNode, Value: keyName}
 
-			// attach validate and comments inline (only when comments are enabled)
+			// attach validate and comments inline
 			var parts []string
 			if cm := comm[typeName][sf.Name]; cm != "" {
 				parts = append(parts, cm)
 			}
-			// Only add validation tags if comments map is not empty (meaning comments are enabled)
-			if len(comm) > 0 {
-				if vt := sf.Tag.Get("validate"); vt != "" {
-					parts = append(parts, fmt.Sprintf(" validate:%s", vt))
-				}
+			if vt := sf.Tag.Get("validate"); vt != "" {
+				parts = append(parts, fmt.Sprintf(" validate:%s", vt))
 			}
 
 			if len(parts) > 0 {
 				keyNode.LineComment = strings.Join(parts, " ")
 			}
 
-			// Check if this field should be redacted as a secret
-			var valNode *yaml.Node
-			var err error
-			if secrets[typeName][sf.Name] {
-				valNode = &yaml.Node{
-					Kind:  yaml.ScalarNode,
-					Tag:   "!!str",
-					Value: "**hidden**",
-					Style: yaml.DoubleQuotedStyle, // Keep secrets quoted for clarity
-				}
-			} else {
-				// Pass through the corresponding default field for recursive comparison
-				var defaultField reflect.Value
-				if defaults.IsValid() && i < defaults.NumField() {
-					defaultField = defaults.Field(i)
-				}
-
-				valNode, err = buildNodeWithDefaults(currentField, comm, defaultField, secrets, deprecated)
-				if err != nil {
-					return nil, err
-				}
+			valNode, err := buildNode(v.Field(i), comm)
+			if err != nil {
+				return nil, err
 			}
 			mapNode.Content = append(mapNode.Content, keyNode, valNode)
 		}
@@ -247,11 +141,7 @@ func buildNodeWithDefaults(v reflect.Value, comm CommentsMap, defaults reflect.V
 		// placeholder for empty slice of structs
 		if v.Len() == 0 && v.Type().Elem().Kind() == reflect.Struct {
 			zero := reflect.Zero(v.Type().Elem())
-			var defaultElem reflect.Value
-			if defaults.IsValid() && defaults.Len() > 0 {
-				defaultElem = defaults.Index(0)
-			}
-			n, err := buildNodeWithDefaults(zero, comm, defaultElem, secrets, deprecated)
+			n, err := buildNode(zero, comm)
 			if err != nil {
 				return nil, err
 			}
@@ -259,11 +149,7 @@ func buildNodeWithDefaults(v reflect.Value, comm CommentsMap, defaults reflect.V
 			return seq, nil
 		}
 		for i := 0; i < v.Len(); i++ {
-			var defaultElem reflect.Value
-			if defaults.IsValid() && i < defaults.Len() {
-				defaultElem = defaults.Index(i)
-			}
-			n, err := buildNodeWithDefaults(v.Index(i), comm, defaultElem, secrets, deprecated)
+			n, err := buildNode(v.Index(i), comm)
 			if err != nil {
 				return nil, err
 			}
@@ -271,33 +157,6 @@ func buildNodeWithDefaults(v reflect.Value, comm CommentsMap, defaults reflect.V
 		}
 		return seq, nil
 
-	case reflect.Map:
-		mapNode := &yaml.Node{Kind: yaml.MappingNode}
-
-		for _, key := range v.MapKeys() {
-			// Handle key
-			keyStr := fmt.Sprintf("%v", key.Interface())
-			keyNode := &yaml.Node{
-				Kind:  yaml.ScalarNode,
-				Value: keyStr,
-			}
-
-			// Handle value recursively
-			mapVal := v.MapIndex(key)
-			var defaultVal reflect.Value
-			if defaults.IsValid() {
-				defaultVal = defaults.MapIndex(key)
-			}
-
-			valNode, err := buildNodeWithDefaults(mapVal, comm, defaultVal, secrets, deprecated)
-			if err != nil {
-				return nil, err
-			}
-
-			mapNode.Content = append(mapNode.Content, keyNode, valNode)
-		}
-		return mapNode, nil
-
 	default:
 		n := &yaml.Node{}
 		if err := n.Encode(v.Interface()); err != nil {
@@ -308,7 +167,7 @@ func buildNodeWithDefaults(v reflect.Value, comm CommentsMap, defaults reflect.V
 }
 
 func GenerateYaml() {
-	_ = loadConfigWithDefaults("", true)
+	_ = loadConfigWithDefaults("")
 	Config.Server.Sources = []Source{
 		{
 			Path: ".",
@@ -316,156 +175,43 @@ func GenerateYaml() {
 	}
 
 	setupLogging()
-	setupAuth(true)
+	setupAuth()
 	setupSources(true)
 	setupUrls()
-	setupFrontend(true)
-	output := "generated.yaml" // "output YAML file"
+	setupFrontend()
+	input := "common/settings/settings.go" // "path to Go source file or directory containing structs"
+	output := "generated.yaml"             // "output YAML file"
 
-	// Generate YAML with comments enabled, full config, and deprecated fields filtered
-	// Force the source path to be correct for static generation
-	yamlContent, err := GenerateConfigYamlWithSource(&Config, true, true, true, "common/settings")
+	comm, err := collectComments(input)
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "error generating YAML: %v\n", err)
+		fmt.Fprintf(os.Stderr, "error parsing comments: %v\n", err)
 		os.Exit(1)
 	}
 
-	if err := os.WriteFile(output, []byte(yamlContent), 0644); err != nil {
+	node, err := buildNode(reflect.ValueOf(Config), comm)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "error building YAML node: %v\n", err)
+		os.Exit(1)
+	}
+
+	doc := &yaml.Node{Kind: yaml.DocumentNode}
+	doc.Content = []*yaml.Node{node}
+
+	var rawBuf bytes.Buffer
+	enc := yaml.NewEncoder(&rawBuf)
+	enc.SetIndent(2)
+	if err := enc.Encode(doc); err != nil {
+		fmt.Fprintf(os.Stderr, "error encoding YAML: %v\n", err)
+		os.Exit(1)
+	}
+
+	aligned := alignComments(rawBuf.String())
+
+	if err := os.WriteFile(output, []byte(aligned), 0644); err != nil {
 		fmt.Fprintf(os.Stderr, "error writing YAML: %v\n", err)
 		os.Exit(1)
 	}
-	fmt.Printf("Generated YAML with comments (deprecated fields filtered): %s\n", output)
-}
-
-// GenerateConfigYaml generates YAML from a given config with options for comments and filtering
-func GenerateConfigYaml(config *Settings, showComments bool, showFull bool, filterDeprecated bool) (string, error) {
-	// Try different source paths to handle both runtime and test scenarios
-	sourcePaths := []string{
-		"common/settings", // When running from backend directory
-		".",               // When running tests from settings directory
-		"../settings",     // Alternative test path
-	}
-
-	for _, sourcePath := range sourcePaths {
-		yamlOutput, err := GenerateConfigYamlWithSource(config, showComments, showFull, filterDeprecated, sourcePath)
-		if err == nil {
-			return yamlOutput, nil
-		}
-		// If it's not a file not found error, return immediately
-		if !strings.Contains(err.Error(), "no such file or directory") && !strings.Contains(err.Error(), "cannot find") {
-			return "", err
-		}
-	}
-
-	// If all paths failed, try with empty maps to at least generate basic YAML
-	return GenerateConfigYamlWithEmptyMaps(config, showFull)
-}
-
-// GenerateConfigYamlWithEmptyMaps generates YAML without comment parsing when source files are unavailable
-func GenerateConfigYamlWithEmptyMaps(config *Settings, showFull bool) (string, error) {
-	// Create empty maps
-	comm := make(CommentsMap)
-	secrets := make(SecretFieldsMap)
-	deprecated := make(DeprecatedFieldsMap)
-
-	var node *yaml.Node
-	var err error
-
-	if showFull {
-		// Show the full current config
-		node, err = buildNodeWithDefaults(reflect.ValueOf(config), comm, reflect.Value{}, secrets, deprecated)
-	} else {
-		// Show only non-default values by comparing with defaults during node building
-		defaultConfig := setDefaults(true)
-		defaultConfig.Server.Sources = []Source{{Path: "."}}
-
-		node, err = buildNodeWithDefaults(reflect.ValueOf(config), comm, reflect.ValueOf(&defaultConfig), secrets, deprecated)
-	}
-
-	if err != nil {
-		return "", err
-	}
-
-	// Convert to YAML
-	doc := &yaml.Node{Kind: yaml.DocumentNode}
-	doc.Content = []*yaml.Node{node}
-
-	var rawBuf bytes.Buffer
-	enc := yaml.NewEncoder(&rawBuf)
-	enc.SetIndent(2)
-	if err := enc.Encode(doc); err != nil {
-		return "", err
-	}
-
-	return AlignComments(rawBuf.String()), nil
-}
-
-// GenerateConfigYamlWithSource generates YAML from a given config with options for comments and filtering, using a custom source path
-func GenerateConfigYamlWithSource(config *Settings, showComments bool, showFull bool, filterDeprecated bool, sourcePath string) (string, error) {
-	var comm CommentsMap
-	var secrets SecretFieldsMap
-	var deprecated DeprecatedFieldsMap
-	var err error
-
-	if showComments {
-		// Collect comments, secrets, and deprecated fields from the settings source files
-		comm, secrets, deprecated, err = CollectCommentsAndSecrets(sourcePath)
-		if err != nil {
-			return "", err
-		}
-	} else {
-		// Still need to collect secrets and deprecated fields even if not showing comments
-		_, secrets, deprecated, err = CollectCommentsAndSecrets(sourcePath)
-		if err != nil {
-			return "", err
-		}
-		// Create empty comments map
-		comm = make(CommentsMap)
-	}
-
-	// If not filtering deprecated fields, clear the deprecated map
-	if !filterDeprecated {
-		deprecated = make(DeprecatedFieldsMap)
-	}
-
-	var node *yaml.Node
-
-	if showFull {
-		// Show the full current config
-		node, err = buildNodeWithDefaults(reflect.ValueOf(config), comm, reflect.Value{}, secrets, deprecated)
-	} else {
-		// Show only non-default values by comparing with defaults during node building
-		// Create a clean default config (no file loading, just pure defaults)
-		defaultConfig := setDefaults(true)
-		// Apply same setup as a fresh instance would have
-		defaultConfig.Server.Sources = []Source{{Path: "."}}
-
-		node, err = buildNodeWithDefaults(reflect.ValueOf(config), comm, reflect.ValueOf(&defaultConfig), secrets, deprecated)
-	}
-
-	if err != nil {
-		return "", err
-	}
-
-	// Create document
-	doc := &yaml.Node{Kind: yaml.DocumentNode}
-	doc.Content = []*yaml.Node{node}
-
-	// Encode to YAML
-	var rawBuf bytes.Buffer
-	enc := yaml.NewEncoder(&rawBuf)
-	enc.SetIndent(2)
-	if err := enc.Encode(doc); err != nil {
-		return "", err
-	}
-
-	// Apply comment alignment if comments are enabled
-	yamlOutput := rawBuf.String()
-	if showComments {
-		yamlOutput = AlignComments(yamlOutput)
-	}
-
-	return yamlOutput, nil
+	fmt.Printf("Generated YAML with comments: %s\n", output)
 }
 
 // formatLine applies padding to a single line so its comment starts at a target column.
@@ -473,39 +219,31 @@ func formatLine(line string) string {
 	const targetCol = 42
 	const defaultPadding = 1
 
-	// Find the first # character that is NOT inside double or single quotes.
-	inSingle, inDouble := false, false
-	for i := 0; i < len(line); i++ {
-		c := line[i]
-		switch c {
-		case '\'':
-			if !inDouble {
-				inSingle = !inSingle
-			}
-		case '"':
-			if !inSingle {
-				inDouble = !inDouble
-			}
-		case '#':
-			if !inSingle && !inDouble {
-				// found a comment
-				contentPart := line[:i]
-				commentPart := line[i:]
-				trimmedContent := strings.TrimRight(contentPart, " ")
-				if len(trimmedContent) >= targetCol {
-					return trimmedContent + strings.Repeat(" ", defaultPadding) + commentPart
-				}
-				paddingNeeded := targetCol - len(trimmedContent)
-				return trimmedContent + strings.Repeat(" ", paddingNeeded) + commentPart
-			}
-		}
+	idx := strings.Index(line, "#")
+	// If there's no comment, do nothing.
+	if idx == -1 {
+		return line
 	}
-	// No comment found
-	return line
+
+	// Separate the content (before #) from the comment (from # onwards).
+	contentPart := line[:idx]
+	commentPart := line[idx:]
+
+	// The YAML encoder adds a space; trim it so we measure only the content length.
+	trimmedContent := strings.TrimRight(contentPart, " ")
+
+	// If the content already extends past our target column, just add a single space.
+	if len(trimmedContent) >= targetCol {
+		return trimmedContent + strings.Repeat(" ", defaultPadding) + commentPart
+	}
+
+	// Otherwise, calculate the needed padding to reach the target column and add it.
+	paddingNeeded := targetCol - len(trimmedContent)
+	return trimmedContent + strings.Repeat(" ", paddingNeeded) + commentPart
 }
 
-// AlignComments formats each line of the YAML string independently.
-func AlignComments(input string) string {
+// alignComments formats each line of the YAML string independently.
+func alignComments(input string) string {
 	lines := strings.Split(input, "\n")
 	outputLines := make([]string, len(lines))
 

backend/common/settings/generator_simple_test.go

@@ -1,230 +0,0 @@
-package settings
-
-import (
-	"regexp"
-	"strings"
-	"testing"
-)
-
-func TestGenerateConfigYaml_Basic(t *testing.T) {
-	reNumber := regexp.MustCompile(`^-?\d+(\.\d+)?$`)
-	// Test using the actual source directory structure
-	config := &Settings{
-		UserDefaults: UserDefaults{
-			Locale:                  "es",          // Non-default value
-			DarkMode:                true,          // Default value
-			DisableOfficePreviewExt: ".docx .xlsx", // This field is deprecated
-		},
-		Auth: Auth{
-			Key:           "secret123",    // This is a secret field
-			AdminUsername: "testadmin",    // This is a secret field
-			AdminPassword: "testpassword", // This is a secret field
-		},
-	}
-
-	// Test different combinations
-	testCases := []struct {
-		name             string
-		showComments     bool
-		showFull         bool
-		filterDeprecated bool
-		expectSecrets    bool
-		expectDeprecated bool
-	}{
-		{
-			name:             "API_mode_all_fields",
-			showComments:     false,
-			showFull:         true,
-			filterDeprecated: false,
-			expectSecrets:    true, // Secrets should be hidden
-			expectDeprecated: true, // Deprecated should be shown
-		},
-		{
-			name:             "Static_config_filter_deprecated",
-			showComments:     true,
-			showFull:         true,
-			filterDeprecated: true,
-			expectSecrets:    true,  // Secrets should be hidden
-			expectDeprecated: false, // Deprecated should be filtered
-		},
-		{
-			name:             "Filtered_non_defaults",
-			showComments:     false,
-			showFull:         false,
-			filterDeprecated: false,
-			expectSecrets:    true,  // Secrets should be hidden
-			expectDeprecated: false, // Might not appear if matches default
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			// Use the current directory structure for real testing
-			yamlOutput, err := GenerateConfigYaml(config, tc.showComments, tc.showFull, tc.filterDeprecated)
-			if err != nil {
-				t.Fatalf("GenerateConfigYaml failed: %v", err)
-			}
-
-			// Basic validation - should produce some output
-			if len(yamlOutput) == 0 {
-				t.Fatal("Generated empty YAML")
-			}
-
-			// Test string quoting - string values should be quoted, numbers and booleans should not
-			lines := strings.Split(yamlOutput, "\n")
-			for _, line := range lines {
-				if strings.Contains(line, ":") && !strings.HasSuffix(strings.TrimSpace(line), ":") {
-					// This is a key-value line, skip comment portion
-					parts := strings.SplitN(line, ":", 2)
-					if len(parts) == 2 {
-						value := strings.TrimSpace(parts[1])
-						// Remove comments
-						if commentIdx := strings.Index(value, "#"); commentIdx >= 0 {
-							value = strings.TrimSpace(value[:commentIdx])
-						}
-
-						// Skip empty values, arrays, and objects
-						if value == "" || strings.HasPrefix(value, "[") || strings.HasPrefix(value, "{") {
-							continue
-						}
-
-						// Check if it's a number (should NOT be quoted)
-						if reNumber.MatchString(value) {
-							if strings.HasPrefix(value, "\"") {
-								t.Errorf("Numeric value should not be quoted in line: %s (value: '%s')", line, value)
-							}
-							continue
-						}
-
-						// Check if it's a boolean (should NOT be quoted)
-						if value == "true" || value == "false" {
-							if strings.HasPrefix(value, "\"") {
-								t.Errorf("Boolean value should not be quoted in line: %s (value: '%s')", line, value)
-							}
-							continue
-						}
-
-						// Everything else should be a quoted string
-						if !strings.HasPrefix(value, "\"") || !strings.HasSuffix(value, "\"") {
-							// Add debug info to see what's wrong
-							t.Logf("DEBUG: Checking value '%s' from line '%s'", value, strings.TrimSpace(line))
-							t.Errorf("String value should be quoted in line: %s (value: %s)", strings.TrimSpace(line), value)
-						}
-					}
-				}
-			}
-
-			// Test secret hiding
-			if tc.expectSecrets {
-				if !strings.Contains(yamlOutput, "**hidden**") {
-					t.Error("Expected secrets to be hidden with **hidden**")
-				}
-				if strings.Contains(yamlOutput, "secret123") || strings.Contains(yamlOutput, "testadmin") || strings.Contains(yamlOutput, "testpassword") {
-					t.Error("Secret values should not appear in output")
-				}
-			}
-
-			// Test deprecated field filtering
-			hasDeprecated := strings.Contains(yamlOutput, "disableOfficePreviewExt")
-			if tc.expectDeprecated && !hasDeprecated {
-				t.Error("Expected deprecated field to be present")
-			}
-			if !tc.expectDeprecated && hasDeprecated && tc.filterDeprecated {
-				t.Error("Expected deprecated field to be filtered out when filterDeprecated=true")
-			}
-
-			// Test comments
-			hasComments := strings.Contains(yamlOutput, "#")
-			if tc.showComments && !hasComments {
-				t.Error("Expected comments to be present when showComments=true")
-			}
-
-			t.Logf("Test case: %s\nGenerated YAML:\n%s\n", tc.name, yamlOutput)
-		})
-	}
-}
-
-func TestCollectCommentsAndSecrets_Basic(t *testing.T) {
-	// Test the comment and secret collection directly
-	comments, secrets, deprecated, err := CollectCommentsAndSecrets(".")
-	if err != nil {
-		t.Fatalf("CollectCommentsAndSecrets failed: %v", err)
-	}
-
-	// Should find some secrets in the actual source files
-	foundSecrets := false
-	for typeName, typeSecrets := range secrets {
-		for fieldName := range typeSecrets {
-			t.Logf("Found secret: %s.%s", typeName, fieldName)
-			foundSecrets = true
-		}
-	}
-	if !foundSecrets {
-		t.Error("Expected to find some secret fields in the actual source code")
-	}
-
-	// Should find some deprecated fields
-	foundDeprecated := false
-	for typeName, typeDeprecated := range deprecated {
-		for fieldName := range typeDeprecated {
-			t.Logf("Found deprecated: %s.%s", typeName, fieldName)
-			foundDeprecated = true
-		}
-	}
-	if !foundDeprecated {
-		t.Error("Expected to find some deprecated fields in the actual source code")
-	}
-
-	t.Logf("Comments: %d types", len(comments))
-	t.Logf("Secrets: %d types", len(secrets))
-	t.Logf("Deprecated: %d types", len(deprecated))
-}
-
-func TestGenerateYaml_StaticGeneration(t *testing.T) {
-	// Test the static generation function that's used by FILEBROWSER_GENERATE_CONFIG=true
-
-	// Create a temporary config for testing
-	config := &Settings{
-		UserDefaults: UserDefaults{
-			Locale:                  "en",
-			DisableOfficePreviewExt: ".docx .xlsx", // This should be filtered out
-		},
-		Auth: Auth{
-			Key: "test-secret", // This should be redacted
-		},
-	}
-
-	// Test static generation with comments and deprecated filtering
-	yamlOutput, err := GenerateConfigYamlWithSource(config, true, true, true, ".")
-	if err != nil {
-		t.Fatalf("Static generation failed: %v", err)
-	}
-
-	// Verify comments are included
-	if !strings.Contains(yamlOutput, "#") {
-		t.Error("Static generation should include comments")
-	}
-
-	// Verify deprecated field is filtered out
-	if strings.Contains(yamlOutput, "disableOfficePreviewExt") {
-		t.Error("Static generation should filter out deprecated field disableOfficePreviewExt")
-	}
-
-	// Verify secrets are redacted
-	if !strings.Contains(yamlOutput, "**hidden**") {
-		t.Error("Static generation should redact secrets")
-	}
-	if strings.Contains(yamlOutput, "test-secret") {
-		t.Error("Static generation should not contain actual secret values")
-	}
-
-	// Verify it has proper structure
-	if !strings.Contains(yamlOutput, "userDefaults:") {
-		t.Error("Static generation should contain userDefaults section")
-	}
-	if !strings.Contains(yamlOutput, "auth:") {
-		t.Error("Static generation should contain auth section")
-	}
-
-	t.Logf("Static generation successful with comments and proper filtering")
-}

backend/common/settings/generator_test.go

@@ -1,470 +0,0 @@
-package settings
-
-import (
-	"os"
-	"regexp"
-	"strings"
-	"testing"
-)
-
-// Test structs for comprehensive testing
-type TestConfig struct {
-	PublicField     string     `json:"publicField"`     // A regular public field
-	SecretField     string     `json:"secretField"`     // secret: this should be hidden
-	DeprecatedField string     `json:"deprecatedField"` // deprecated: this field is old
-	EmptyField      string     `json:"emptyField"`      // An empty string field
-	DefaultField    string     `json:"defaultField"`    // A field that matches default
-	NonDefaultField string     `json:"nonDefaultField"` // A field that differs from default
-	NestedStruct    TestNested `json:"nestedStruct"`
-}
-
-type TestNested struct {
-	NestedPublic     string `json:"nestedPublic"`     // A nested public field
-	NestedSecret     string `json:"nestedSecret"`     // secret: nested secret field
-	NestedDeprecated string `json:"nestedDeprecated"` // deprecated: nested deprecated field
-}
-
-// Helper to create test source files for comment parsing
-func createTestSourceFile(t *testing.T, content string) (string, func()) {
-	tmpFile, err := os.CreateTemp("", "test_*.go")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if _, err := tmpFile.WriteString(content); err != nil {
-		t.Fatal(err)
-	}
-	tmpFile.Close()
-
-	cleanup := func() {
-		os.Remove(tmpFile.Name())
-	}
-
-	return tmpFile.Name(), cleanup
-}
-
-func TestGenerateConfigYaml_StringQuoting(t *testing.T) {
-	reNumber := regexp.MustCompile(`^-?\d+(\.\d+)?$`)
-	// Create a simple test source file for this test
-	sourceContent := `package settings
-
-type Settings struct {
-	UserDefaults UserDefaults ` + "`json:\"userDefaults\"`" + `
-	Auth Auth ` + "`json:\"auth\"`" + `
-}
-
-type UserDefaults struct {
-	Locale string ` + "`json:\"locale\"`" + `
-}
-
-type Auth struct {
-	AdminUsername string ` + "`json:\"adminUsername\"`" + `
-}
-`
-	tmpFile, cleanup := createTestSourceFile(t, sourceContent)
-	defer cleanup()
-	sourcePath := tmpFile[:strings.LastIndex(tmpFile, "/")]
-
-	// Create real Settings with string values to test quoting
-	settings := &Settings{
-		UserDefaults: UserDefaults{
-			Locale: "en-US",
-		},
-		Auth: Auth{
-			AdminUsername: "admin",
-		},
-	}
-
-	// Test with no filtering - should quote all strings
-	yamlOutput, err := GenerateConfigYamlWithSource(settings, false, true, false, sourcePath)
-	if err != nil {
-		t.Fatalf("GenerateConfigYaml failed: %v", err)
-	}
-
-	// All string values should be quoted
-	lines := strings.Split(yamlOutput, "\n")
-	for _, line := range lines {
-		if strings.Contains(line, ":") && !strings.HasSuffix(strings.TrimSpace(line), ":") {
-			// This is a key-value line
-			parts := strings.SplitN(line, ":", 2)
-			if len(parts) == 2 {
-				value := strings.TrimSpace(parts[1])
-
-				// Remove comments
-				if commentIdx := strings.Index(value, "#"); commentIdx >= 0 {
-					value = strings.TrimSpace(value[:commentIdx])
-				}
-
-				// Skip empty values, arrays, objects, booleans
-				if value == "" || value == "false" || value == "true" || strings.HasPrefix(value, "[") || strings.HasPrefix(value, "{") {
-					continue
-				}
-
-				// Check if it's a number (should NOT be quoted)
-				if reNumber.MatchString(value) {
-					if strings.HasPrefix(value, "\"") {
-						t.Errorf("Numeric value should not be quoted: %s (value: '%s')", line, value)
-					}
-					continue
-				}
-
-				// Everything else should be a quoted string
-				if !strings.HasPrefix(value, "\"") || !strings.HasSuffix(value, "\"") {
-					t.Errorf("String value should be quoted: %s (value: '%s')", line, value)
-				}
-			}
-		}
-	}
-}
-
-func TestGenerateConfigYaml_SecretHiding(t *testing.T) {
-	// Create temporary source file with our test structs
-	sourceContent := `package settings
-
-type TestConfig struct {
-	PublicField string ` + "`json:\"publicField\"`" + ` // A regular public field
-	SecretField string ` + "`json:\"secretField\"`" + ` // secret: this should be hidden
-}
-
-type TestNested struct {
-	NestedPublic string ` + "`json:\"nestedPublic\"`" + ` // A nested public field
-	NestedSecret string ` + "`json:\"nestedSecret\"`" + ` // secret: nested secret field
-}
-`
-
-	tmpFile, cleanup := createTestSourceFile(t, sourceContent)
-	defer cleanup()
-
-	// Test secret detection
-	_, secrets, _, err := CollectCommentsAndSecrets(tmpFile)
-	if err != nil {
-		t.Fatalf("CollectCommentsAndSecrets failed: %v", err)
-	}
-
-	// Verify secret fields are detected
-	if !secrets["TestConfig"]["SecretField"] {
-		t.Error("SecretField should be marked as secret")
-	}
-	if !secrets["TestNested"]["NestedSecret"] {
-		t.Error("NestedSecret should be marked as secret")
-	}
-	if secrets["TestConfig"]["PublicField"] {
-		t.Error("PublicField should not be marked as secret")
-	}
-
-	// Test that secrets are properly collected
-	if len(secrets["TestConfig"]) != 1 {
-		t.Errorf("Expected 1 secret field in TestConfig, got %d", len(secrets["TestConfig"]))
-	}
-}
-
-func TestGenerateConfigYaml_DeprecatedFiltering(t *testing.T) {
-	// Create temporary source file with deprecated fields
-	sourceContent := `package settings
-
-type TestConfig struct {
-	PublicField     string ` + "`json:\"publicField\"`" + ` // A regular public field
-	DeprecatedField string ` + "`json:\"deprecatedField\"`" + ` // deprecated: this field is old
-}
-`
-
-	tmpFile, cleanup := createTestSourceFile(t, sourceContent)
-	defer cleanup()
-
-	// Test deprecated detection
-	_, _, deprecated, err := CollectCommentsAndSecrets(tmpFile)
-	if err != nil {
-		t.Fatalf("CollectCommentsAndSecrets failed: %v", err)
-	}
-
-	// Verify deprecated fields are detected
-	if !deprecated["TestConfig"]["DeprecatedField"] {
-		t.Error("DeprecatedField should be marked as deprecated")
-	}
-	if deprecated["TestConfig"]["PublicField"] {
-		t.Error("PublicField should not be marked as deprecated")
-	}
-}
-
-func TestGenerateConfigYaml_FullVsFiltered(t *testing.T) {
-	// Create minimal test source
-	sourceContent := `package settings
-
-type Settings struct {
-	UserDefaults UserDefaults ` + "`json:\"userDefaults\"`" + `
-}
-
-type UserDefaults struct {
-	DarkMode bool ` + "`json:\"darkMode\"`" + `
-	Locale string ` + "`json:\"locale\"`" + `
-}
-`
-	tmpFile, cleanup := createTestSourceFile(t, sourceContent)
-	defer cleanup()
-	sourcePath := tmpFile[:strings.LastIndex(tmpFile, "/")]
-
-	// Create a config with both default and non-default values
-	config := &Settings{
-		UserDefaults: UserDefaults{
-			DarkMode: true, // This matches default
-			Locale:   "es", // This differs from default ("en")
-		},
-	}
-
-	// Test full=true - should show all fields
-	fullYaml, err := GenerateConfigYamlWithSource(config, false, true, false, sourcePath)
-	if err != nil {
-		t.Fatalf("GenerateConfigYaml with full=true failed: %v", err)
-	}
-
-	// Test full=false - should only show non-default fields
-	filteredYaml, err := GenerateConfigYamlWithSource(config, false, false, false, sourcePath)
-	if err != nil {
-		t.Fatalf("GenerateConfigYaml with full=false failed: %v", err)
-	}
-
-	// Full output should be longer than filtered
-	if len(fullYaml) <= len(filteredYaml) {
-		t.Error("Full YAML should be longer than filtered YAML")
-	}
-
-	// Filtered output should contain the non-default field
-	if !strings.Contains(filteredYaml, "locale") {
-		t.Error("Filtered YAML should contain non-default locale field")
-	}
-
-	// Full output should contain default fields
-	if !strings.Contains(fullYaml, "darkMode") {
-		t.Error("Full YAML should contain darkMode field")
-	}
-}
-
-func TestGenerateConfigYaml_CommentsOnOff(t *testing.T) {
-	// Use the actual settings source directory since comments work there
-	config := &Settings{
-		UserDefaults: UserDefaults{
-			Locale: "en",
-		},
-	}
-
-	// Test with comments=true using the real source
-	withComments, err := GenerateConfigYaml(config, true, true, false)
-	if err != nil {
-		t.Fatalf("GenerateConfigYaml with comments=true failed: %v", err)
-	}
-
-	// Test with comments=false using the real source
-	withoutComments, err := GenerateConfigYaml(config, false, true, false)
-	if err != nil {
-		t.Fatalf("GenerateConfigYaml with comments=false failed: %v", err)
-	}
-
-	// Output with comments should be longer
-	if len(withComments) <= len(withoutComments) {
-		t.Errorf("YAML with comments (%d chars) should be longer than without comments (%d chars)", len(withComments), len(withoutComments))
-	}
-
-	// With comments should contain '#' characters
-	if !strings.Contains(withComments, "#") {
-		t.Error("YAML with comments should contain '#' characters")
-	}
-
-	// Without comments should not contain '#' characters
-	if strings.Contains(withoutComments, "#") {
-		t.Error("YAML without comments should not contain '#' characters")
-	}
-}
-
-func TestGenerateConfigYaml_IntegrationTest(t *testing.T) {
-	reNumber := regexp.MustCompile(`^-?\d+(\.\d+)?$`)
-	// Comprehensive test with all features
-	config := &Settings{
-		UserDefaults: UserDefaults{
-			Locale:                  "es",          // Non-default
-			DarkMode:                true,          // Default
-			DisableOfficePreviewExt: ".docx .xlsx", // This is deprecated
-		},
-		Auth: Auth{
-			Key:           "secret123", // This is secret
-			AdminUsername: "admin",     // This is secret
-			AdminPassword: "password",  // This is secret
-		},
-	}
-
-	tests := []struct {
-		name             string
-		showComments     bool
-		showFull         bool
-		filterDeprecated bool
-		expectSecret     bool
-		expectDeprecated bool
-		expectFull       bool
-		expectComments   bool
-	}{
-		{
-			name:             "API mode: show all including deprecated",
-			showComments:     false,
-			showFull:         true,
-			filterDeprecated: false,
-			expectSecret:     true,  // secrets should be hidden
-			expectDeprecated: true,  // deprecated should be shown
-			expectFull:       true,  // all fields shown
-			expectComments:   false, // no comments
-		},
-		{
-			name:             "Static config mode: filter deprecated",
-			showComments:     true,
-			showFull:         true,
-			filterDeprecated: true,
-			expectSecret:     true,  // secrets should be hidden
-			expectDeprecated: false, // deprecated should be filtered
-			expectFull:       true,  // all non-deprecated fields shown
-			expectComments:   true,  // comments included
-		},
-		{
-			name:             "Filtered output: only changes",
-			showComments:     false,
-			showFull:         false,
-			filterDeprecated: false,
-			expectSecret:     true,  // secrets should be hidden
-			expectDeprecated: false, // might not appear if matches default
-			expectFull:       false, // only non-default fields
-			expectComments:   false, // no comments
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			yamlOutput, err := GenerateConfigYaml(config, tt.showComments, tt.showFull, tt.filterDeprecated)
-			if err != nil {
-				t.Fatalf("GenerateConfigYaml failed: %v", err)
-			}
-
-			// Check secret hiding
-			if tt.expectSecret {
-				if !strings.Contains(yamlOutput, "**hidden**") {
-					t.Error("Expected secrets to be hidden with **hidden**")
-				}
-				if strings.Contains(yamlOutput, "secret123") {
-					t.Error("Secret values should not appear in output")
-				}
-			}
-
-			// Check deprecated field filtering
-			hasDeprecated := strings.Contains(yamlOutput, "disableOfficePreviewExt")
-			if tt.expectDeprecated && !hasDeprecated {
-				t.Error("Expected deprecated field to be present")
-			}
-			if !tt.expectDeprecated && hasDeprecated && tt.filterDeprecated {
-				t.Error("Expected deprecated field to be filtered out")
-			}
-
-			// Check comments
-			hasComments := strings.Contains(yamlOutput, "#")
-			if tt.expectComments && !hasComments {
-				t.Error("Expected comments to be present")
-			}
-			if !tt.expectComments && hasComments {
-				t.Error("Expected no comments")
-			}
-
-			// Check string quoting - all string values should be quoted
-			lines := strings.Split(yamlOutput, "\n")
-			for _, line := range lines {
-				if strings.Contains(line, ":") && !strings.HasSuffix(strings.TrimSpace(line), ":") {
-					// This is a key-value line
-					parts := strings.SplitN(line, ":", 2)
-					if len(parts) == 2 {
-						value := strings.TrimSpace(parts[1])
-						// Skip comments and empty values
-						if commentIdx := strings.Index(value, "#"); commentIdx >= 0 {
-							// If comment starts at the beginning, there's no value, just a comment
-							if commentIdx == 0 {
-								continue
-							}
-							value = strings.TrimSpace(value[:commentIdx])
-						}
-						// Check if it's a number (should NOT be quoted)
-						if reNumber.MatchString(value) {
-							if strings.HasPrefix(value, "\"") {
-								t.Errorf("Numeric value should not be quoted in line: %s (value: '%s')", line, value)
-							}
-							continue
-						}
-
-						// Check if it's a boolean (should NOT be quoted)
-						if value == "true" || value == "false" {
-							if strings.HasPrefix(value, "\"") {
-								t.Errorf("Boolean value should not be quoted in line: %s (value: '%s')", line, value)
-							}
-							continue
-						}
-
-						// Skip arrays, objects, and empty values
-						if value == "" || strings.HasPrefix(value, "[") || strings.HasPrefix(value, "{") || strings.Contains(value, ":") {
-							continue
-						}
-
-						// Everything else should be a quoted string
-						if !strings.HasPrefix(value, "\"") || !strings.HasSuffix(value, "\"") {
-							t.Errorf("String value should be quoted in line: %s (value: '%s')", line, value)
-						}
-					}
-				}
-			}
-
-			t.Logf("Generated YAML for %s:\n%s", tt.name, yamlOutput)
-		})
-	}
-}
-
-func TestGenerateConfigYaml_EdgeCases(t *testing.T) {
-	tests := []struct {
-		name   string
-		config *Settings
-		desc   string
-	}{
-		{
-			name:   "empty_config",
-			config: &Settings{},
-			desc:   "Empty config should generate valid YAML",
-		},
-		{
-			name: "only_defaults",
-			config: &Settings{
-				UserDefaults: UserDefaults{
-					DarkMode: true, // default value
-					Locale:   "en", // default value
-				},
-			},
-			desc: "Config with only default values",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Test all combinations
-			for _, showComments := range []bool{false, true} {
-				for _, showFull := range []bool{false, true} {
-					for _, filterDeprecated := range []bool{false, true} {
-						yamlOutput, err := GenerateConfigYaml(tt.config, showComments, showFull, filterDeprecated)
-						if err != nil {
-							t.Fatalf("GenerateConfigYaml failed for %s (comments=%v, full=%v, filterDeprecated=%v): %v",
-								tt.desc, showComments, showFull, filterDeprecated, err)
-						}
-
-						// Basic validation - should produce valid YAML structure
-						if yamlOutput == "" {
-							t.Errorf("Generated empty YAML for %s", tt.desc)
-						}
-
-						// Should not contain obvious error messages (but allow "error" in log levels etc)
-						if strings.Contains(yamlOutput, "Error:") || strings.Contains(yamlOutput, "ERROR:") {
-							t.Errorf("YAML contains error for %s", tt.desc)
-						}
-					}
-				}
-			}
-		})
-	}
-}

backend/common/settings/settings.go

@@ -49,7 +49,7 @@ func ApplyUserDefaults(u *users.User) {
 	u.Preview = Config.UserDefaults.Preview
 	u.ShowHidden = Config.UserDefaults.ShowHidden
 	u.DateFormat = Config.UserDefaults.DateFormat
-	u.DisableViewingExt = Config.UserDefaults.DisableViewingExt
+	u.DisableOnlyOfficeExt = Config.UserDefaults.DisableOnlyOfficeExt
 	u.ThemeColor = Config.UserDefaults.ThemeColor
 	u.GallerySize = Config.UserDefaults.GallerySize
 	u.QuickDownload = Config.UserDefaults.QuickDownload

backend/common/settings/structs.go

@@ -21,9 +21,7 @@ type Settings struct {
 }
 
 type Server struct {
-	MinSearchLength              int         `json:"minSearchLength"`              // minimum length of search query to begin searching (default: 3)
-	DisableUpdateCheck           bool        `json:"disableUpdateCheck"`           // disables backend update check service
-	NumImageProcessors           int         `json:"numImageProcessors"`           // number of concurrent image processing jobs used to create previews, default is number of cpu cores available.
+	NumImageProcessors           int         `json:"numImageProcessors"`           // number of concurrent image processing jobs
 	Socket                       string      `json:"socket"`                       // socket to listen on
 	TLSKey                       string      `json:"tlsKey"`                       // path to TLS key
 	TLSCert                      string      `json:"tlsCert"`                      // path to TLS cert
@@ -36,14 +34,14 @@ type Server struct {
 	DebugMedia                   bool        `json:"debugMedia"` // output ffmpeg stdout for media integration -- careful can produces lots of output!
 	Database                     string      `json:"database"`   // path to the database file
 	Sources                      []Source    `json:"sources" validate:"required,dive"`
-	ExternalUrl                  string      `json:"externalUrl"`    // used by share links if set (eg. http://mydomain.com)
-	InternalUrl                  string      `json:"internalUrl"`    // used by integrations if set, this is the base domain that an integration service will use to communicate with filebrowser (eg. http://localhost:8080)
+	ExternalUrl                  string      `json:"externalUrl"`    // used by share links if set
+	InternalUrl                  string      `json:"internalUrl"`    // used by integrations if set, this is the url that an integration service will use to communicate with filebrowser
 	CacheDir                     string      `json:"cacheDir"`       // path to the cache directory, used for thumbnails and other cached files
 	MaxArchiveSizeGB             int64       `json:"maxArchiveSize"` // max pre-archive combined size of files/folder that are allowed to be archived (in GB)
 	// not exposed to config
-	SourceMap      map[string]Source `json:"-" validate:"omitempty"` // uses realpath as key
-	NameToSource   map[string]Source `json:"-" validate:"omitempty"` // uses name as key
-	MuPdfAvailable bool              `json:"-"`                      // used internally if compiled with mupdf support
+	SourceMap     map[string]Source `json:"-" validate:"omitempty"` // uses realpath as key
+	NameToSource  map[string]Source `json:"-" validate:"omitempty"` // uses name as key
+	DefaultSource Source            `json:"-" validate:"omitempty"`
 }
 
 type Integrations struct {
@@ -54,9 +52,9 @@ type Integrations struct {
 // onlyoffice secret is stored in the local.json file
 // docker exec <containerID> /var/www/onlyoffice/documentserver/npm/json -f /etc/onlyoffice/documentserver/local.json 'services.CoAuthoring.secret.session.string'
 type OnlyOffice struct {
-	Url         string `json:"url" validate:"required"`    // The URL to the OnlyOffice Document Server, needs to be accessible to the user.
-	InternalUrl string `json:"internalUrl"`                // An optional internal address that the filebrowser server can use to communicate with the OnlyOffice Document Server, could be useful to bypass proxy.
-	Secret      string `json:"secret" validate:"required"` // secret: authentication key for OnlyOffice integration
+	Url         string `json:"url" validate:"required"` // The URL to the OnlyOffice Document Server, needs to be accessible to the user.
+	InternalUrl string `json:"internalUrl"`             // An optional internal address that the filebrowser server can use to communicate with the OnlyOffice Document Server, could be useful to bypass proxy.
+	Secret      string `json:"secret" validate:"required"`
 }
 
 type Media struct {
@@ -75,38 +73,27 @@ type LogConfig struct {
 type Source struct {
 	Path   string       `json:"path" validate:"required"` // file system path. (Can be relative)
 	Name   string       `json:"name"`                     // display name
-	Config SourceConfig `json:"config,omitempty"`
+	Config SourceConfig `json:"config"`
 }
 
 type SourceConfig struct {
-	DenyByDefault    bool               `json:"denyByDefault,omitempty"`           // deny access unless an "allow" access rule was specifically created.
-	Private          bool               `json:"private"`                           // designate as source as private -- currently just means no sharing permitted.
-	Disabled         bool               `json:"disabled,omitempty"`                // disable the source, this is useful so you don't need to remove it from the config file
-	IndexingInterval uint32             `json:"indexingIntervalMinutes,omitempty"` // optional manual overide interval in minutes to re-index the source
-	DisableIndexing  bool               `json:"disableIndexing,omitempty"`         // disable the indexing of this source
-	MaxWatchers      int                `json:"maxWatchers"`                       // number of concurrent watchers to use for this source, currently not supported
-	NeverWatchPaths  []string           `json:"neverWatchPaths"`                   // paths that get initially once. Useful for folders that rarely change contents (without source path prefix)
-	Exclude          ExcludeIndexFilter `json:"exclude"`                           // exclude files and folders from indexing, if include is not set
-	Include          IncludeIndexFilter `json:"include"`                           // include files and folders from indexing, if exclude is not set
-	DefaultUserScope string             `json:"defaultUserScope"`                  // default "/" should match folders under path
-	DefaultEnabled   bool               `json:"defaultEnabled"`                    // should be added as a default source for new users?
-	CreateUserDir    bool               `json:"createUserDir"`                     // create a user directory for each user
+	IndexingInterval      uint32      `json:"indexingInterval"`      // optional manual overide interval in seconds to re-index the source
+	Disabled              bool        `json:"disabled"`              // disable the indexing of this source
+	MaxWatchers           int         `json:"maxWatchers"`           // number of concurrent watchers to use for this source, currently not supported
+	NeverWatch            []string    `json:"neverWatchPaths"`       // paths to never watch, relative to the source path (eg. "/folder/file.txt")
+	IgnoreHidden          bool        `json:"ignoreHidden"`          // ignore hidden files and folders.
+	IgnoreZeroSizeFolders bool        `json:"ignoreZeroSizeFolders"` // ignore folders with 0 size
+	Exclude               IndexFilter `json:"exclude"`               // exclude files and folders from indexing, if include is not set
+	Include               IndexFilter `json:"include"`               // include files and folders from indexing, if exclude is not set
+	DefaultUserScope      string      `json:"defaultUserScope"`      // default "/" should match folders under path
+	DefaultEnabled        bool        `json:"defaultEnabled"`        // should be added as a default source for new users?
+	CreateUserDir         bool        `json:"createUserDir"`         // create a user directory for each user
 }
 
-type IncludeIndexFilter struct {
-	RootFolders []string `json:"rootFolders"` // list of root folders to include, relative to the source path (eg. "folder1")
-	RootFiles   []string `json:"rootFiles"`   // list of root files to include, relative to the source path (eg. "file1.txt")
-}
-
-type ExcludeIndexFilter struct {
-	Hidden          bool     `json:"hidden"`                // exclude hidden files and folders.
-	ZeroSizeFolders bool     `json:"ignoreZeroSizeFolders"` // ignore folders with 0 size
-	FilePaths       []string `json:"filePaths"`             // list of filepaths Eg. "folder1" or "file1.txt" or "folder1/file1.txt" (without source path prefix)
-	FolderPaths     []string `json:"folderPaths"`           // (filepath) list of folder names to include/exclude. Eg. "folder1" or "folder1/subfolder" (do not include source path, just the subpaths from the source path)
-	FileNames       []string `json:"fileNames"`             // (global) list of file names to include/exclude. Eg. "a.jpg"
-	FolderNames     []string `json:"folderNames"`           // (global) list of folder names to include/exclude. Eg. "@eadir" or ".thumbnails"
-	FileEndsWith    []string `json:"fileEndsWith"`          // (global) exclude files that end with these suffixes. Eg. ".jpg" or ".txt"
-	FolderEndsWith  []string `json:"folderEndsWith"`        // (global) exclude folders that end with these suffixes. Eg. ".thumbnails" or ".git"
+type IndexFilter struct {
+	Files        []string `json:"files"`        // array of file names to include/exclude
+	Folders      []string `json:"folders"`      // array of folder names to include/exclude
+	FileEndsWith []string `json:"fileEndsWith"` // array of file names to include/exclude (eg "a.jpg")
 }
 
 type Frontend struct {
@@ -114,26 +101,6 @@ type Frontend struct {
 	DisableDefaultLinks   bool           `json:"disableDefaultLinks"`   // disable default links in the sidebar
 	DisableUsedPercentage bool           `json:"disableUsedPercentage"` // disable used percentage for the sources in the sidebar
 	ExternalLinks         []ExternalLink `json:"externalLinks"`
-	DisableNavButtons     bool           `json:"disableNavButtons"` // disable the nav buttons in the sidebar
-	Styling               StylingConfig  `json:"styling"`
-	Favicon               string         `json:"favicon"`     // path to a favicon to use for the frontend
-	Description           string         `json:"description"` // description that shows up in html head meta description
-}
-
-type StylingConfig struct {
-	CustomCSS       string                 `json:"customCSS"`       // if a valid path to a css file is provided, it will be applied for all users. (eg. "reduce-rounded-corners.css")
-	CustomCSSRaw    string                 `json:"-"`               // The css raw content to use for the custom css.
-	LightBackground string                 `json:"lightBackground"` // specify a valid CSS color property value to use as the background color in light mode
-	DarkBackground  string                 `json:"darkBackground"`  // Specify a valid CSS color property value to use as the background color in dark mode
-	CustomThemes    map[string]CustomTheme `json:"customThemes"`    // A list of custom css files that each user can select to override the default styling. if "default" is key name then it will be the default option.
-	// In-memory (not exposed to config)
-	CustomThemeOptions map[string]CustomTheme `json:"-"` // not exposed
-}
-
-type CustomTheme struct {
-	Description string `json:"description"`   // The description of the theme to display in the UI.
-	CSS         string `json:"css,omitempty"` // The css file path and filename to use for the theme.
-	CssRaw      string `json:"-"`             // The css raw content to use for the theme.
 }
 
 type ExternalLink struct {
@@ -145,34 +112,21 @@ type ExternalLink struct {
 // UserDefaults is a type that holds the default values
 // for some fields on User.
 type UserDefaults struct {
-	EditorQuickSave            bool                `json:"editorQuickSave"`           // show quick save button in editor
-	HideSidebarFileActions     bool                `json:"hideSidebarFileActions"`    // hide the file actions in the sidebar
-	DisableQuickToggles        bool                `json:"disableQuickToggles"`       // disable the quick toggles in the sidebar
-	DisableSearchOptions       bool                `json:"disableSearchOptions"`      // disable the search options in the search bar
-	StickySidebar              bool                `json:"stickySidebar"`             // keep sidebar open when navigating
-	DarkMode                   bool                `json:"darkMode"`                  // should dark mode be enabled
-	Locale                     string              `json:"locale"`                    // language to use: eg. de, en, or fr
-	ViewMode                   string              `json:"viewMode"`                  // view mode to use: eg. normal, list, grid, or compact
-	SingleClick                bool                `json:"singleClick"`               // open directory on single click, also enables middle click to open in new tab
-	ShowHidden                 bool                `json:"showHidden"`                // show hidden files in the UI. On windows this includes files starting with a dot and windows hidden files
-	DateFormat                 bool                `json:"dateFormat"`                // when false, the date is relative, when true, the date is an exact timestamp
-	GallerySize                int                 `json:"gallerySize"`               // 0-9 - the size of the gallery thumbnails
-	ThemeColor                 string              `json:"themeColor"`                // theme color to use: eg. #ff0000, or var(--red), var(--purple), etc
-	QuickDownload              bool                `json:"quickDownload"`             // show icon to download in one click
-	DisablePreviewExt          string              `json:"disablePreviewExt"`         // space separated list of file extensions to disable preview for
-	DisableViewingExt          string              `json:"disableViewingExt"`         // space separated list of file extensions to disable viewing for
-	LockPassword               bool                `json:"lockPassword"`              // disable the user from changing their password
-	DisableSettings            bool                `json:"disableSettings,omitempty"` // disable the user from viewing the settings page
-	Preview                    users.Preview       `json:"preview"`
-	DefaultScopes              []users.SourceScope `json:"-"`
-	Permissions                users.Permissions   `json:"permissions"`
-	LoginMethod                string              `json:"loginMethod,omitempty"`      // login method to use: eg. password, proxy, oidc
-	DisableUpdateNotifications bool                `json:"disableUpdateNotifications"` // disable update notifications banner for admin users
-	DeleteWithoutConfirming    bool                `json:"deleteWithoutConfirming"`    // delete files without confirmation
-	FileLoading                users.FileLoading   `json:"fileLoading"`                // upload and download settings
-	DisableOfficePreviewExt    string              `json:"disableOfficePreviewExt"`    // deprecated: use disablePreviewExt instead
-	DisableOnlyOfficeExt       string              `json:"disableOnlyOfficeExt"`       // list of file extensions to disable onlyoffice editor for
-	CustomTheme                string              `json:"customTheme"`                // Name of theme to use chosen from custom themes config.
-	ShowSelectMultiple         bool                `json:"showSelectMultiple"`         // show select multiple files on desktop
-	DebugOffice                bool                `json:"debugOffice"`                // debug onlyoffice editor
+	StickySidebar        bool                `json:"stickySidebar"`             // keep sidebar open when navigating
+	DarkMode             bool                `json:"darkMode"`                  // should dark mode be enabled
+	Locale               string              `json:"locale"`                    // language to use: eg. de, en, or fr
+	ViewMode             string              `json:"viewMode"`                  // view mode to use: eg. normal, list, grid, or compact
+	SingleClick          bool                `json:"singleClick"`               // open directory on single click, also enables middle click to open in new tab
+	ShowHidden           bool                `json:"showHidden"`                // show hidden files in the UI. On windows this includes files starting with a dot and windows hidden files
+	DateFormat           bool                `json:"dateFormat"`                // when false, the date is relative, when true, the date is an exact timestamp
+	GallerySize          int                 `json:"gallerySize"`               // 0-9 - the size of the gallery thumbnails
+	ThemeColor           string              `json:"themeColor"`                // theme color to use: eg. #ff0000, or var(--red), var(--purple), etc
+	QuickDownload        bool                `json:"quickDownload"`             // show icon to download in one click
+	DisableOnlyOfficeExt string              `json:"disableOnlyOfficeExt"`      // comma separated list of file extensions to disable onlyoffice preview for
+	LockPassword         bool                `json:"lockPassword"`              // disable the user from changing their password
+	DisableSettings      bool                `json:"disableSettings,omitempty"` // disable the user from viewing the settings page
+	Preview              users.Preview       `json:"preview"`
+	DefaultScopes        []users.SourceScope `json:"-"`
+	Permissions          users.Permissions   `json:"permissions"`
+	LoginMethod          string              `json:"loginMethod,omitempty"` // login method to use: eg. password, proxy, oidc
 }

backend/common/settings/styling.go

@@ -1,113 +0,0 @@
-package settings
-
-import (
-	"os"
-	"regexp"
-	"strings"
-
-	"github.com/gtsteffaniak/go-logger/logger"
-)
-
-// Strict hex color regex: #RGB, #RGBA, #RRGGBB, #RRGGBBAA
-var hexColorRE = regexp.MustCompile(`^#([0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$`)
-
-// All valid CSS named colors (W3C spec, lower-case)
-var cssNamedColors = map[string]struct{}{
-	"aliceblue": {}, "antiquewhite": {}, "aqua": {}, "aquamarine": {}, "azure": {},
-	"beige": {}, "bisque": {}, "black": {}, "blanchedalmond": {}, "blue": {}, "blueviolet": {},
-	"brown": {}, "burlywood": {}, "cadetblue": {}, "chartreuse": {}, "chocolate": {},
-	"coral": {}, "cornflowerblue": {}, "cornsilk": {}, "crimson": {}, "cyan": {},
-	"darkblue": {}, "darkcyan": {}, "darkgoldenrod": {}, "darkgray": {}, "darkgreen": {},
-	"darkgrey": {}, "darkkhaki": {}, "darkmagenta": {}, "darkolivegreen": {}, "darkorange": {},
-	"darkorchid": {}, "darkred": {}, "darksalmon": {}, "darkseagreen": {}, "darkslateblue": {},
-	"darkslategray": {}, "darkslategrey": {}, "darkturquoise": {}, "darkviolet": {}, "deeppink": {},
-	"deepskyblue": {}, "dimgray": {}, "dimgrey": {}, "dodgerblue": {}, "firebrick": {},
-	"floralwhite": {}, "forestgreen": {}, "fuchsia": {}, "gainsboro": {}, "ghostwhite": {},
-	"gold": {}, "goldenrod": {}, "gray": {}, "green": {}, "greenyellow": {}, "grey": {},
-	"honeydew": {}, "hotpink": {}, "indianred": {}, "indigo": {}, "ivory": {},
-	"khaki": {}, "lavender": {}, "lavenderblush": {}, "lawngreen": {}, "lemonchiffon": {},
-	"lightblue": {}, "lightcoral": {}, "lightcyan": {}, "lightgoldenrodyellow": {}, "lightgray": {},
-	"lightgreen": {}, "lightgrey": {}, "lightpink": {}, "lightsalmon": {}, "lightseagreen": {},
-	"lightskyblue": {}, "lightslategray": {}, "lightslategrey": {}, "lightsteelblue": {}, "lightyellow": {},
-	"lime": {}, "limegreen": {}, "linen": {}, "magenta": {}, "maroon": {}, "mediumaquamarine": {},
-	"mediumblue": {}, "mediumorchid": {}, "mediumpurple": {}, "mediumseagreen": {}, "mediumslateblue": {},
-	"mediumspringgreen": {}, "mediumturquoise": {}, "mediumvioletred": {}, "midnightblue": {}, "mintcream": {},
-	"mistyrose": {}, "moccasin": {}, "navajowhite": {}, "navy": {}, "oldlace": {},
-	"olive": {}, "olivedrab": {}, "orange": {}, "orangered": {}, "orchid": {},
-	"palegoldenrod": {}, "palegreen": {}, "paleturquoise": {}, "palevioletred": {}, "papayawhip": {},
-	"peachpuff": {}, "peru": {}, "pink": {}, "plum": {}, "powderblue": {},
-	"purple": {}, "rebeccapurple": {}, "red": {}, "rosybrown": {}, "royalblue": {},
-	"saddlebrown": {}, "salmon": {}, "sandybrown": {}, "seagreen": {}, "seashell": {},
-	"sienna": {}, "silver": {}, "skyblue": {}, "slateblue": {}, "slategray": {},
-	"slategrey": {}, "snow": {}, "springgreen": {}, "steelblue": {}, "tan": {},
-	"teal": {}, "thistle": {}, "tomato": {}, "turquoise": {}, "violet": {},
-	"wheat": {}, "white": {}, "whitesmoke": {}, "yellow": {}, "yellowgreen": {},
-	// And the special values:
-	"transparent": {}, "currentcolor": {},
-}
-
-func FallbackColor(val, defaultColor string) string {
-	val = strings.TrimSpace(val)
-	if val == "" {
-		return defaultColor
-	}
-	if hexColorRE.MatchString(val) {
-		return val
-	}
-	lc := strings.ToLower(val)
-	// CSS color functions
-	if strings.HasPrefix(lc, "rgb(") || strings.HasPrefix(lc, "rgba(") ||
-		strings.HasPrefix(lc, "hsl(") || strings.HasPrefix(lc, "hsla(") {
-		return val
-	}
-	// CSS variable
-	if strings.HasPrefix(lc, "var(") {
-		return val
-	}
-	// Named colors and special values
-	if _, ok := cssNamedColors[lc]; ok {
-		return val
-	}
-	// Log a warning if the color is invalid
-	logger.Warningf("Invalid CSS color value provided: '%s'. Falling back to default: '%s'", val, defaultColor)
-	return defaultColor
-}
-
-func addCustomTheme(name, description, cssFilePath string) {
-	// Store only file path in config (for YAML export)
-	Config.Frontend.Styling.CustomThemes[name] = CustomTheme{
-		Description: description,
-		CSS:         cssFilePath, // Store file path, not content
-	}
-
-	// Load CSS content for runtime use (frontend consumption)
-	cssContent := ""
-	if cssFilePath != "" {
-		cssContent = readCustomCSS(cssFilePath)
-	}
-	Config.Frontend.Styling.CustomThemeOptions[name] = CustomTheme{
-		Description: description,
-		CSS:         cssFilePath,
-		CssRaw:      cssContent, // Store loaded content
-	}
-}
-
-func readCustomCSS(path string) string {
-	if path == "" {
-		return ""
-	}
-	content, err := os.ReadFile(path)
-	if err != nil {
-		// Only log if the file exists but cannot be read (e.g., permission error)
-		if !os.IsNotExist(err) {
-			logger.Warningf("Could not read custom CSS file %s: %v", path, err)
-			return ""
-		}
-	}
-	if len(content) > 128*1024 {
-		logger.Warningf("Custom CSS file %s is too large (%d bytes), ignoring", path, len(content))
-		return ""
-	}
-	logger.Infof("Loaded custom CSS from: %s (%d bytes)", path, len(content))
-	return string(content)
-}

backend/common/utils/cache.go

@@ -1,16 +0,0 @@
-package utils
-
-import (
-	"time"
-
-	"github.com/gtsteffaniak/go-cache/cache"
-)
-
-var (
-	DiskUsageCache     = cache.NewCache(30*time.Second, 24*time.Hour)
-	RealPathCache      = cache.NewCache(48*time.Hour, 72*time.Hour)
-	SearchResultsCache = cache.NewCache(15*time.Second, 1*time.Hour)
-	OnlyOfficeCache    = cache.NewCache(48*time.Hour, 1*time.Hour)
-	JwtCache           = cache.NewCache(1*time.Hour, 72*time.Hour)
-	MediaCache         = cache.NewCache(24 * time.Hour) // subtitles get cached for 24 hours
-)

backend/common/utils/checkForUpdates.go

@@ -1,102 +0,0 @@
-package utils
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"strings"
-	"time"
-
-	"github.com/gtsteffaniak/filebrowser/backend/common/version"
-	"github.com/gtsteffaniak/go-logger/logger"
-	"golang.org/x/mod/semver"
-)
-
-var updateAvailableUrl = ""
-
-type Tag struct {
-	Name string `json:"name"`
-}
-
-type updateInfo struct {
-	LatestVersion  string
-	CurrentVersion string
-	ReleaseNotes   string
-	ReleaseUrl     string
-}
-
-func CheckForUpdates() (updateInfo, error) {
-	// --- Configuration ---
-	repoOwner := "gtsteffaniak"
-	repoName := "filebrowser"
-	currentVersion := version.Version
-	splitVersion := strings.Split(currentVersion, "-")
-	versionCategory := "stable"
-	if len(splitVersion) > 1 {
-		versionCategory = splitVersion[1]
-	}
-	githubApiUrl := fmt.Sprintf("https://api.github.com/repos/%s/%s/tags", repoOwner, repoName)
-	// Make the GET request
-	resp, err := http.Get(githubApiUrl)
-	if err != nil {
-		return updateInfo{}, err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		return updateInfo{}, fmt.Errorf("failed to fetch tags from GitHub API")
-	}
-	// Decode the JSON response
-	var tags []Tag
-	if err := json.NewDecoder(resp.Body).Decode(&tags); err != nil {
-		return updateInfo{}, err
-	}
-	// Find the latest beta version greater than the current one
-	var NewVersion string
-	for _, tag := range tags {
-		// Check if the version is valid, is a pre-release, and contains "beta"
-		if semver.IsValid(tag.Name) && strings.Contains(semver.Prerelease(tag.Name), versionCategory) {
-			// Check if this tag is greater than the current version
-			// and also greater than any other beta version we've found so far
-			if semver.Compare(tag.Name, currentVersion) > 0 {
-				if NewVersion == "" || semver.Compare(tag.Name, NewVersion) > 0 {
-					NewVersion = tag.Name
-				}
-			}
-		}
-	}
-	if NewVersion == "" {
-		// No newer version found, return empty updateInfo
-		return updateInfo{}, fmt.Errorf("no newer version found for %s", currentVersion)
-	}
-
-	updateAvailableUrl = fmt.Sprintf("https://github.com/%s/%s/releases/tag/%s", repoOwner, repoName, NewVersion)
-	return updateInfo{
-		LatestVersion:  NewVersion,
-		CurrentVersion: currentVersion,
-		ReleaseNotes:   updateAvailableUrl,
-		ReleaseUrl:     updateAvailableUrl,
-	}, nil
-}
-
-func GetUpdateAvailableUrl() string {
-	return updateAvailableUrl
-}
-
-// starts a background process to check for updates periodically.
-func StartCheckForUpdates() {
-	// Create a ticker that fires every 24 hours.
-	ticker := time.NewTicker(24 * time.Hour)
-	defer ticker.Stop()
-	// Start a loop that waits for the ticker to fire.
-	for range ticker.C {
-		_, err := CheckForUpdates()
-		if err != nil {
-			// In a real application, you might want more sophisticated logging.
-			logger.Debug("update check failed:", err)
-			continue // Don't stop the loop, just wait for the next tick.
-		}
-		// Update the global variable with the result of the check.
-		// This will be an empty string if no newer version was found.
-	}
-}

backend/common/utils/main.go

@@ -6,12 +6,14 @@ import (
 	"encoding/hex"
 	"fmt"
 	math "math/rand"
+	"os"
 	"path/filepath"
 	"reflect"
 	"runtime"
 	"strings"
 	"time"
 
+	"github.com/gtsteffaniak/filebrowser/backend/indexing/iteminfo"
 	"github.com/gtsteffaniak/go-logger/logger"
 )
 
@@ -115,16 +117,30 @@ func JoinPathAsUnix(parts ...string) string {
 	return joinedPath
 }
 
-func NonNilSlice[T any](in []T) []T {
-	if in == nil {
-		return []T{}
-	}
-	return in
-}
+// ResolveSymlinks resolves symlinks in the given path and returns
+// the final resolved path, whether it's a directory (considering bundle logic), and any error.
+func ResolveSymlinks(path string) (string, bool, error) {
+	for {
+		// Get the file info using os.Lstat to handle symlinks
+		info, err := os.Lstat(path)
+		if err != nil {
+			return path, false, fmt.Errorf("could not stat path: %s, %v", path, err)
+		}
 
-func Ternary[T any](cond bool, vtrue, vfalse T) T {
-	if cond {
-		return vtrue
+		// Check if the path is a symlink
+		if info.Mode()&os.ModeSymlink != 0 {
+			// Read the symlink target
+			target, err := os.Readlink(path)
+			if err != nil {
+				return path, false, fmt.Errorf("could not read symlink: %s, %v", path, err)
+			}
+
+			// Resolve the symlink's target relative to its directory
+			path = filepath.Join(filepath.Dir(path), target)
+		} else {
+			// Not a symlink, check with bundle-aware directory logic
+			isDir := iteminfo.IsDirectory(info)
+			return path, isDir, nil
+		}
 	}
-	return vfalse
 }

backend/common/utils/mocks.go

@@ -4,8 +4,35 @@ import (
 	"time"
 
 	"math/rand"
+
+	"github.com/gtsteffaniak/filebrowser/backend/indexing/iteminfo"
 )
 
+func CreateMockData(numDirs, numFilesPerDir int) iteminfo.FileInfo {
+	dir := iteminfo.FileInfo{}
+	dir.Path = "/here/is/your/mock/dir"
+	for i := 0; i < numDirs; i++ {
+		newFile := iteminfo.ItemInfo{
+			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",
+		}
+		dir.Folders = append(dir.Folders, newFile)
+	}
+	// Simulating files and directories with FileInfo
+	for j := 0; j < numFilesPerDir; j++ {
+		newFile := iteminfo.ItemInfo{
+			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",
+		}
+		dir.Files = append(dir.Files, newFile)
+	}
+	return dir
+}
+
 func GenerateRandomPath(levels int) string {
 	rand.New(rand.NewSource(time.Now().UnixNano()))
 	dirName := "srv"

backend/database/access/access_test.go

@@ -1,481 +0,0 @@
-package access_test
-
-import (
-	"path/filepath"
-	"testing"
-
-	"github.com/asdine/storm/v3"
-	"github.com/gtsteffaniak/filebrowser/backend/common/settings"
-	"github.com/gtsteffaniak/filebrowser/backend/database/access"
-	boltusers "github.com/gtsteffaniak/filebrowser/backend/database/storage/bolt"
-	"github.com/gtsteffaniak/filebrowser/backend/database/users"
-)
-
-func createTestStorage(t *testing.T) (*access.Storage, *users.Storage) {
-	dir := t.TempDir()
-	dbPath := filepath.Join(dir, "test.db")
-	db, err := storm.Open(dbPath)
-	if err != nil {
-		t.Fatalf("failed to open storm db: %v", err)
-	}
-	userStore := users.NewStorage(boltusers.NewUsersBackend(db))
-	return access.NewStorage(db, userStore), userStore
-}
-
-func createTestUser(t *testing.T, userStore *users.Storage, username string) {
-	u := &users.User{NonAdminEditable: users.NonAdminEditable{Password: "test"}, Username: username}
-	err := userStore.Save(u, false, false)
-	if err != nil {
-		t.Fatalf("failed to create user %s: %v", username, err)
-	}
-}
-
-func setupTestSources() {
-	// Setup default test sources with allow-by-default behavior
-	settings.Config.Server.SourceMap = map[string]settings.Source{
-		"mnt/storage": {
-			Path: "mnt/storage",
-			Name: "storage",
-			Config: settings.SourceConfig{
-				DenyByDefault: false,
-			},
-		},
-		"mnt/open": {
-			Path: "mnt/open",
-			Name: "open",
-			Config: settings.SourceConfig{
-				DenyByDefault: false,
-			},
-		},
-	}
-}
-
-func TestPermitted_UserBlacklist(t *testing.T) {
-	setupTestSources()
-	s, userStore := createTestStorage(t)
-	createTestUser(t, userStore, "alice")
-	createTestUser(t, userStore, "bob")
-	err := s.LoadFromDB()
-	if err != nil && err != storm.ErrNotFound {
-		t.Errorf("unexpected error loading from DB: %v", err)
-	}
-	if err := s.DenyUser("mnt/storage", "/secret", "alice"); err != nil {
-		t.Errorf("DenyUser failed: %v", err)
-	}
-	if s.Permitted("mnt/storage", "/secret", "alice") {
-		t.Error("alice should not be permitted (denied)")
-	}
-	if !s.Permitted("mnt/storage", "/secret", "bob") {
-		t.Error("bob should be permitted (not denied)")
-	}
-}
-
-func TestPermitted_UserWhitelist(t *testing.T) {
-	setupTestSources()
-	s, userStore := createTestStorage(t)
-	createTestUser(t, userStore, "alice")
-	createTestUser(t, userStore, "bob")
-	err := s.LoadFromDB()
-	if err != nil && err != storm.ErrNotFound {
-		t.Errorf("unexpected error loading from DB: %v", err)
-	}
-	if err := s.AllowUser("mnt/storage", "/vip", "bob"); err != nil {
-		t.Errorf("AllowUser failed: %v", err)
-	}
-	if !s.Permitted("mnt/storage", "/vip", "bob") {
-		t.Error("bob should be permitted (allowed)")
-	}
-	if !s.Permitted("mnt/storage", "/vip", "alice") {
-		t.Error("alice should be permitted (default allow behavior when DenyByDefault=false)")
-	}
-}
-
-func TestPermitted_GroupBlacklist(t *testing.T) {
-	setupTestSources()
-	s, userStore := createTestStorage(t)
-	createTestUser(t, userStore, "alice")
-	createTestUser(t, userStore, "bob")
-	err := s.LoadFromDB()
-	if err != nil && err != storm.ErrNotFound {
-		t.Errorf("unexpected error loading from DB: %v", err)
-	}
-	_ = s.AddUserToGroup("admins", "alice")
-	if err := s.DenyGroup("mnt/storage", "/admin", "admins"); err != nil {
-		t.Errorf("DenyGroup failed: %v", err)
-	}
-	if s.Permitted("mnt/storage", "/admin", "bob") == false {
-		t.Error("bob should be permitted (not in denied group)")
-	}
-	if s.Permitted("mnt/storage", "/admin", "alice") {
-		t.Error("alice should not be permitted (in denied group)")
-	}
-}
-
-func TestPermitted_GroupWhitelist(t *testing.T) {
-	setupTestSources()
-	s, userStore := createTestStorage(t)
-	createTestUser(t, userStore, "alice")
-	createTestUser(t, userStore, "bob")
-	err := s.LoadFromDB()
-	if err != nil && err != storm.ErrNotFound {
-		t.Errorf("unexpected error loading from DB: %v", err)
-	}
-	_ = s.AddUserToGroup("vip", "bob")
-	if err := s.AllowGroup("mnt/storage", "/vip", "vip"); err != nil {
-		t.Errorf("AllowGroup failed: %v", err)
-	}
-	if !s.Permitted("mnt/storage", "/vip", "bob") {
-		t.Error("bob should be permitted (in allowed group)")
-	}
-	if !s.Permitted("mnt/storage", "/vip", "alice") {
-		t.Error("alice should be permitted (default allow behavior when DenyByDefault=false)")
-	}
-}
-
-func TestPermitted_NoRule(t *testing.T) {
-	setupTestSources()
-	s, _ := createTestStorage(t)
-	err := s.LoadFromDB()
-	if err != nil && err != storm.ErrNotFound {
-		t.Errorf("unexpected error loading from DB: %v", err)
-	}
-	if !s.Permitted("mnt/storage", "/public", "anyone") {
-		t.Error("anyone should be permitted if no rule exists")
-	}
-}
-
-func TestPermitted_CombinedRules(t *testing.T) {
-	setupTestSources()
-	s, userStore := createTestStorage(t)
-	createTestUser(t, userStore, "alice")
-	createTestUser(t, userStore, "bob")
-	createTestUser(t, userStore, "carol")
-	createTestUser(t, userStore, "eve")
-	err := s.LoadFromDB()
-	if err != nil && err != storm.ErrNotFound {
-		t.Errorf("unexpected error loading from DB: %v", err)
-	}
-	err = s.AddUserToGroup("vip", "bob")
-	if err != nil {
-		t.Errorf("AddUserToGroup failed: %v", err)
-	}
-	err = s.AddUserToGroup("admins", "alice")
-	if err != nil {
-		t.Errorf("AddUserToGroup failed: %v", err)
-	}
-	if err := s.DenyUser("mnt/storage", "/combo", "eve"); err != nil {
-		t.Errorf("DenyUser failed: %v", err)
-	}
-	if err := s.AllowUser("mnt/storage", "/combo", "carol"); err != nil {
-		t.Errorf("AllowUser failed: %v", err)
-	}
-	if err := s.DenyGroup("mnt/storage", "/combo", "admins"); err != nil {
-		t.Errorf("DenyGroup failed: %v", err)
-	}
-	if err := s.AllowGroup("mnt/storage", "/combo", "vip"); err != nil {
-		t.Errorf("AllowGroup failed: %v", err)
-	}
-	if s.Permitted("mnt/storage", "/combo", "eve") {
-		t.Error("eve should not be permitted (user denied)")
-	}
-	if !s.Permitted("mnt/storage", "/combo", "carol") {
-		t.Error("carol should be permitted (user allowed)")
-	}
-	if s.Permitted("mnt/storage", "/combo", "alice") {
-		t.Error("alice should not be permitted (in group denied)")
-	}
-	if !s.Permitted("mnt/storage", "/combo", "bob") {
-		t.Error("bob should be permitted (in group allowed)")
-	}
-}
-
-func TestPermitted_DenyAll(t *testing.T) {
-	setupTestSources()
-	s, userStore := createTestStorage(t)
-	createTestUser(t, userStore, "alice")
-	createTestUser(t, userStore, "bob")
-	err := s.LoadFromDB()
-	if err != nil && err != storm.ErrNotFound {
-		t.Errorf("unexpected error loading from DB: %v", err)
-	}
-
-	// Test DenyAll
-	if err = s.DenyAll("mnt/storage", "/private"); err != nil {
-		t.Errorf("DenyAll failed: %v", err)
-	}
-	if s.Permitted("mnt/storage", "/private", "alice") {
-		t.Error("alice should not be permitted (deny all)")
-	}
-	if s.Permitted("mnt/storage", "/private", "bob") {
-		t.Error("bob should not be permitted (deny all)")
-	}
-
-	// Test that Allow rule overrides DenyAll
-	if err = s.AllowUser("mnt/storage", "/private", "alice"); err != nil {
-		t.Errorf("AllowUser failed: %v", err)
-	}
-	if !s.Permitted("mnt/storage", "/private", "alice") {
-		t.Error("alice should be permitted (allow overrides deny all)")
-	}
-
-	// Test removing DenyAll
-	removed, err := s.RemoveDenyAll("mnt/storage", "/private")
-	if err != nil {
-		t.Errorf("RemoveDenyAll failed: %v", err)
-	}
-	if !removed {
-		t.Error("RemoveDenyAll should have removed the rule")
-	}
-
-	// After removing DenyAll, alice should be permitted due to the Allow rule
-	if !s.Permitted("mnt/storage", "/private", "alice") {
-		t.Error("alice should be permitted after removing deny all")
-	}
-
-	// Bob should be permitted because DenyByDefault=false makes allow lists additive (not exclusive)
-	if !s.Permitted("mnt/storage", "/private", "bob") {
-		t.Error("bob should be permitted after removing deny all (DenyByDefault=false makes allow lists additive)")
-	}
-}
-
-func TestPermitted_DenyByDefault(t *testing.T) {
-	// Clear access cache to prevent test pollution
-	access.ClearCache()
-
-	// Create isolated storage for this test
-	s, userStore := createTestStorage(t)
-	createTestUser(t, userStore, "alice")
-	createTestUser(t, userStore, "bob")
-	err := s.LoadFromDB()
-	if err != nil && err != storm.ErrNotFound {
-		t.Errorf("unexpected error loading from DB: %v", err)
-	}
-
-	// Setup test configuration with DenyByDefault enabled for one source
-	originalSourceMap := settings.Config.Server.SourceMap
-	defer func() {
-		settings.Config.Server.SourceMap = originalSourceMap
-		access.ClearCache()
-	}()
-
-	settings.Config.Server.SourceMap = map[string]settings.Source{
-		"mnt/storage": {
-			Path: "mnt/storage",
-			Name: "storage",
-			Config: settings.SourceConfig{
-				DenyByDefault: true,
-			},
-		},
-		"mnt/open": {
-			Path: "mnt/open",
-			Name: "open",
-			Config: settings.SourceConfig{
-				DenyByDefault: false,
-			},
-		},
-	}
-
-	// Test DenyByDefault: When no rules exist, users should be denied
-	if s.Permitted("mnt/storage", "/private", "alice") {
-		t.Error("alice should not be permitted (DenyByDefault is true and no rules exist)")
-	}
-	if s.Permitted("mnt/storage", "/private", "bob") {
-		t.Error("bob should not be permitted (DenyByDefault is true and no rules exist)")
-	}
-
-	// Test that explicit allow rules override DenyByDefault
-	if err := s.AllowUser("mnt/storage", "/allowed", "alice"); err != nil {
-		t.Errorf("AllowUser failed: %v", err)
-	}
-	if !s.Permitted("mnt/storage", "/allowed", "alice") {
-		t.Error("alice should be permitted (explicit allow rule overrides DenyByDefault)")
-	}
-	if s.Permitted("mnt/storage", "/allowed", "bob") {
-		t.Error("bob should not be permitted (not in allow list and DenyByDefault is true)")
-	}
-
-	// Test that explicit deny rules work with DenyByDefault
-	if err := s.DenyUser("mnt/storage", "/denied", "alice"); err != nil {
-		t.Errorf("DenyUser failed: %v", err)
-	}
-	if s.Permitted("mnt/storage", "/denied", "alice") {
-		t.Error("alice should not be permitted (explicit deny rule)")
-	}
-	if s.Permitted("mnt/storage", "/denied", "bob") {
-		t.Error("bob should not be permitted (DenyByDefault is true)")
-	}
-
-	// Test that DenyByDefault doesn't affect sources where it's disabled
-	if !s.Permitted("mnt/open", "/public", "alice") {
-		t.Error("alice should be permitted in open source (DenyByDefault is false)")
-	}
-	if !s.Permitted("mnt/open", "/public", "bob") {
-		t.Error("bob should be permitted in open source (DenyByDefault is false)")
-	}
-
-	// Test recursive path checking with DenyByDefault
-	// Allow alice at parent path, should work for child paths too
-	if err := s.AllowUser("mnt/storage", "/parent", "alice"); err != nil {
-		t.Errorf("AllowUser failed: %v", err)
-	}
-	if !s.Permitted("mnt/storage", "/parent/child", "alice") {
-		t.Error("alice should be permitted for child path (inherits from parent allow rule)")
-	}
-	if s.Permitted("mnt/storage", "/parent/child", "bob") {
-		t.Error("bob should not be permitted for child path (DenyByDefault and not in allow list)")
-	}
-
-	// Test that group rules work with DenyByDefault
-	_ = s.AddUserToGroup("vip", "alice")
-	if err := s.AllowGroup("mnt/storage", "/vip", "vip"); err != nil {
-		t.Errorf("AllowGroup failed: %v", err)
-	}
-	if !s.Permitted("mnt/storage", "/vip", "alice") {
-		t.Error("alice should be permitted (in allowed group)")
-	}
-	if s.Permitted("mnt/storage", "/vip", "bob") {
-		t.Error("bob should not be permitted (not in allowed group and DenyByDefault is true)")
-	}
-}
-
-func TestPermitted_DenyByDefaultWithDenyAll(t *testing.T) {
-	// Clear access cache to prevent test pollution
-	access.ClearCache()
-
-	// Create isolated storage for this test
-	s, userStore := createTestStorage(t)
-	createTestUser(t, userStore, "alice")
-	createTestUser(t, userStore, "bob")
-	err := s.LoadFromDB()
-	if err != nil && err != storm.ErrNotFound {
-		t.Errorf("unexpected error loading from DB: %v", err)
-	}
-
-	// Setup test configuration with DenyByDefault enabled
-	originalSourceMap := settings.Config.Server.SourceMap
-	defer func() {
-		settings.Config.Server.SourceMap = originalSourceMap
-		access.ClearCache()
-	}()
-
-	settings.Config.Server.SourceMap = map[string]settings.Source{
-		"mnt/storage": {
-			Path: "mnt/storage",
-			Name: "storage",
-			Config: settings.SourceConfig{
-				DenyByDefault: true,
-			},
-		},
-	}
-
-	// Test that explicit DenyAll rule also works when DenyByDefault is enabled
-	if err = s.DenyAll("mnt/storage", "/restricted"); err != nil {
-		t.Errorf("DenyAll failed: %v", err)
-	}
-	if s.Permitted("mnt/storage", "/restricted", "alice") {
-		t.Error("alice should not be permitted (DenyAll rule)")
-	}
-	if s.Permitted("mnt/storage", "/restricted", "bob") {
-		t.Error("bob should not be permitted (DenyAll rule)")
-	}
-
-	// Test that Allow rule overrides DenyAll even with DenyByDefault
-	if err = s.AllowUser("mnt/storage", "/restricted", "alice"); err != nil {
-		t.Errorf("AllowUser failed: %v", err)
-	}
-	if !s.Permitted("mnt/storage", "/restricted", "alice") {
-		t.Error("alice should be permitted (allow overrides DenyAll)")
-	}
-
-	// Remove DenyAll and test that DenyByDefault takes effect
-	removed, err := s.RemoveDenyAll("mnt/storage", "/restricted")
-	if err != nil {
-		t.Errorf("RemoveDenyAll failed: %v", err)
-	}
-	if !removed {
-		t.Error("RemoveDenyAll should have removed the rule")
-	}
-
-	// After removing DenyAll, alice should be permitted due to Allow rule
-	if !s.Permitted("mnt/storage", "/restricted", "alice") {
-		t.Error("alice should be permitted after removing DenyAll (has allow rule)")
-	}
-	// Bob should not be permitted due to DenyByDefault
-	if s.Permitted("mnt/storage", "/restricted", "bob") {
-		t.Error("bob should not be permitted (DenyByDefault is true and no allow rule)")
-	}
-}
-
-func TestPermitted_DenyByDefault_AdminRootAccess(t *testing.T) {
-	// 1. Setup
-	access.ClearCache()
-	s, userStore := createTestStorage(t)
-	createTestUser(t, userStore, "admin")
-	createTestUser(t, userStore, "graham")
-	createTestUser(t, userStore, "bob")
-	err := s.LoadFromDB()
-	if err != nil && err != storm.ErrNotFound {
-		t.Errorf("unexpected error loading from DB: %v", err)
-	}
-
-	// 2. Configure source with DenyByDefault: true
-	originalSourceMap := settings.Config.Server.SourceMap
-	defer func() {
-		settings.Config.Server.SourceMap = originalSourceMap
-		access.ClearCache()
-	}()
-	settings.Config.Server.SourceMap = map[string]settings.Source{
-		"mnt/secure": {
-			Path: "mnt/secure",
-			Name: "secure",
-			Config: settings.SourceConfig{
-				DenyByDefault: true,
-			},
-		},
-	}
-
-	// 3. Set up access rules
-	if err := s.AllowUser("mnt/secure", "/", "admin"); err != nil {
-		t.Fatalf("AllowUser for admin failed: %v", err)
-	}
-	if err := s.AllowUser("mnt/secure", "/test", "graham"); err != nil {
-		t.Fatalf("AllowUser for graham failed: %v", err)
-	}
-
-	// 4. Assertions
-	// Admin checks
-	if !s.Permitted("mnt/secure", "/", "admin") {
-		t.Error("admin should be permitted for /")
-	}
-	if !s.Permitted("mnt/secure", "/test", "admin") {
-		t.Error("admin should be permitted for /test")
-	}
-	if !s.Permitted("mnt/secure", "/test/sub", "admin") {
-		t.Error("admin should be permitted for /test/sub (this is the bug)")
-	}
-
-	// Graham checks
-	if !s.Permitted("mnt/secure", "/test", "graham") {
-		t.Error("graham should be permitted for /test")
-	}
-	if !s.Permitted("mnt/secure", "/test/sub", "graham") {
-		t.Error("graham should be permitted for /test/sub")
-	}
-	if s.Permitted("mnt/secure", "/", "graham") {
-		t.Error("graham should NOT be permitted for /")
-	}
-	if s.Permitted("mnt/secure", "/anotherfolder", "graham") {
-		t.Error("graham should NOT be permitted for /anotherfolder")
-	}
-
-	// Bob checks (should have no access)
-	if s.Permitted("mnt/secure", "/", "bob") {
-		t.Error("bob should NOT be permitted for /")
-	}
-	if s.Permitted("mnt/secure", "/test", "bob") {
-		t.Error("bob should NOT be permitted for /test")
-	}
-	if s.Permitted("mnt/secure", "/test/sub", "bob") {
-		t.Error("bob should NOT be permitted for /test/sub")
-	}
-}

backend/database/crud/crud.go

@@ -1,34 +0,0 @@
-package crud
-
-// CrudBackend defines the basic CRUD operations for a type T.
-type CrudBackend[T any] interface {
-	GetByID(id any) (*T, error)
-	GetAll() ([]*T, error)
-	Save(obj *T) error
-	DeleteByID(id any) error
-}
-
-// Storage provides generic CRUD operations for any type T.
-type Storage[T any] struct {
-	backend CrudBackend[T]
-}
-
-func NewStorage[T any](backend CrudBackend[T]) *Storage[T] {
-	return &Storage[T]{backend: backend}
-}
-
-func (s *Storage[T]) Get(id any) (*T, error) {
-	return s.backend.GetByID(id)
-}
-
-func (s *Storage[T]) GetAll() ([]*T, error) {
-	return s.backend.GetAll()
-}
-
-func (s *Storage[T]) Save(obj *T) error {
-	return s.backend.Save(obj)
-}
-
-func (s *Storage[T]) Delete(id any) error {
-	return s.backend.DeleteByID(id)
-}

backend/database/share/share.go

@@ -1,38 +1,6 @@
 package share
 
-import "sync"
-
-type CommonShare struct {
-	//AllowEdit           bool   `json:"allowEdit,omitempty"`
-	AllowUpload             bool     `json:"allowUpload,omitempty"`
-	DisableFileViewer       bool     `json:"disableFileViewer,omitempty"`
-	DownloadsLimit          int      `json:"downloadsLimit,omitempty"`
-	ShareTheme              string   `json:"shareTheme,omitempty"`
-	DisableAnonymous        bool     `json:"disableAnonymous,omitempty"`
-	MaxBandwidth            int      `json:"maxBandwidth,omitempty"`
-	DisableThumbnails       bool     `json:"disableThumbnails,omitempty"`
-	KeepAfterExpiration     bool     `json:"keepAfterExpiration,omitempty"`
-	AllowedUsernames        []string `json:"allowedUsernames,omitempty"`
-	ThemeColor              string   `json:"themeColor,omitempty"`
-	Banner                  string   `json:"banner,omitempty"`
-	Title                   string   `json:"title,omitempty"`
-	Description             string   `json:"description,omitempty"`
-	Favicon                 string   `json:"favicon,omitempty"`
-	QuickDownload           bool     `json:"quickDownload,omitempty"`
-	HideNavButtons          bool     `json:"hideNavButtons,omitempty"`
-	DisableSidebar          bool     `json:"disableSidebar"`
-	ViewMode                string   `json:"viewMode,omitempty"`
-	Source                  string   `json:"source,omitempty"` // backend source is path to maintain between name changes
-	Path                    string   `json:"path,omitempty"`
-	DownloadURL             string   `json:"downloadURL,omitempty"`
-	DisableShareCard        bool     `json:"disableShareCard,omitempty"`
-	EnforceDarkLightMode    string   `json:"enforceDarkLightMode,omitempty"` // "dark" or "light"
-	EnableOnlyOffice        bool     `json:"enableOnlyOffice,omitempty"`
-	EnableOnlyOfficeEditing bool     `json:"enableOnlyOfficeEditing,omitempty"`
-}
 type CreateBody struct {
-	CommonShare
-	Hash     string `json:"hash,omitempty"`
 	Password string `json:"password"`
 	Expires  string `json:"expires"`
 	Unit     string `json:"unit"`
@@ -40,13 +8,12 @@ type CreateBody struct {
 
 // Link is the information needed to build a shareable link.
 type Link struct {
-	CommonShare
-	Mu           sync.Mutex `json:"-"`
-	Downloads    int        `json:"downloads"`
-	Hash         string     `json:"hash" storm:"id,index"`
-	UserID       uint       `json:"userID"`
-	Expire       int64      `json:"expire"`
-	PasswordHash string     `json:"password_hash,omitempty"`
+	Hash         string `json:"hash" storm:"id,index"`
+	Path         string `json:"path" storm:"index"`
+	Source       string `json:"source" storm:"index"`
+	UserID       uint   `json:"userID"`
+	Expire       int64  `json:"expire"`
+	PasswordHash string `json:"password_hash,omitempty"`
 	// Token is a random value that will only be set when PasswordHash is set. It is
 	// URL-Safe and is used to download links in password-protected shares via a
 	// query arg.

backend/database/share/storage.go

@@ -1,14 +1,9 @@
 package share
 
 import (
-	"strings"
-	"sync"
 	"time"
 
 	"github.com/gtsteffaniak/filebrowser/backend/common/errors"
-	"github.com/gtsteffaniak/filebrowser/backend/database/crud"
-	"github.com/gtsteffaniak/filebrowser/backend/database/users"
-	"github.com/gtsteffaniak/go-logger/logger"
 )
 
 // StorageBackend is the interface to implement for a share storage.
@@ -17,304 +12,109 @@ type StorageBackend interface {
 	FindByUserID(id uint) ([]*Link, error)
 	GetByHash(hash string) (*Link, error)
 	GetPermanent(path, source string, id uint) (*Link, error)
-	GetBySourcePath(path, source string) ([]*Link, error)
 	Gets(path, source string, id uint) ([]*Link, error)
 	Save(s *Link) error
 	Delete(hash string) error
 }
 
-// crudBackend implements crud.CrudBackend[Link] for share storage.
-type crudBackend struct {
+// Storage is a storage.
+type Storage struct {
 	back StorageBackend
 }
 
-func (c *crudBackend) GetByID(id any) (*Link, error) {
-	hash, ok := id.(string)
-	if !ok {
-		return nil, errors.ErrInvalidDataType
-	}
-	return c.back.GetByHash(hash)
-}
-
-func (c *crudBackend) GetAll() ([]*Link, error) {
-	return c.back.All()
-}
-
-func (c *crudBackend) Save(obj *Link) error {
-	return c.back.Save(obj)
-}
-
-func (c *crudBackend) DeleteByID(id any) error {
-	hash, ok := id.(string)
-	if !ok {
-		return errors.ErrInvalidDataType
-	}
-	return c.back.Delete(hash)
-}
-
-// Storage is a share storage using generics.
-type Storage struct {
-	Generic    *crud.Storage[Link]
-	back       StorageBackend
-	shareCache map[string]*Link
-	mu         sync.RWMutex
-	users      *users.Storage
-}
-
 // NewStorage creates a share links storage from a backend.
-func NewStorage(back StorageBackend, usersStore *users.Storage) *Storage {
-	return &Storage{
-		Generic:    crud.NewStorage[Link](&crudBackend{back: back}),
-		back:       back,
-		shareCache: make(map[string]*Link),
-		users:      usersStore,
-	}
+func NewStorage(back StorageBackend) *Storage {
+	return &Storage{back: back}
 }
 
-// All wraps StorageBackend.All and handles expiry.
+// All wraps a StorageBackend.All.
 func (s *Storage) All() ([]*Link, error) {
 	links, err := s.back.All()
-	if err != nil {
-		return nil, err
-	}
-	filtered, err := s.filterExpired(links)
+
 	if err != nil {
 		return nil, err
 	}
 
-	s.mu.Lock()
-	for i, l := range filtered {
-		if l == nil {
-			continue
-		}
-		if existing, ok := s.shareCache[l.Hash]; ok && existing != nil {
-			filtered[i] = existing
-		} else {
-			s.shareCache[l.Hash] = l
+	for i, link := range links {
+		if link.Expire != 0 && link.Expire <= time.Now().Unix() {
+			if err := s.Delete(link.Hash); err != nil {
+				return nil, err
+			}
+			links = append(links[:i], links[i+1:]...)
 		}
 	}
-	s.mu.Unlock()
-	return filtered, nil
+
+	return links, nil
 }
 
-// FindByUserID wraps StorageBackend.FindByUserID and handles expiry.
+// FindByUserID wraps a StorageBackend.FindByUserID.
 func (s *Storage) FindByUserID(id uint) ([]*Link, error) {
 	links, err := s.back.FindByUserID(id)
-	if err != nil {
-		return nil, err
-	}
-	filtered, err := s.filterExpired(links)
+
 	if err != nil {
 		return nil, err
 	}
 
-	s.mu.Lock()
-	for i, l := range filtered {
-		if l == nil {
-			continue
-		}
-		if existing, ok := s.shareCache[l.Hash]; ok && existing != nil {
-			filtered[i] = existing
-		} else {
-			s.shareCache[l.Hash] = l
+	for i, link := range links {
+		if link.Expire != 0 && link.Expire <= time.Now().Unix() {
+			if err := s.Delete(link.Hash); err != nil {
+				return nil, err
+			}
+			links = append(links[:i], links[i+1:]...)
 		}
 	}
-	s.mu.Unlock()
-	return filtered, nil
+
+	return links, nil
 }
 
-// GetByHash wraps StorageBackend.GetByHash and handles expiry.
+// GetByHash wraps a StorageBackend.GetByHash.
 func (s *Storage) GetByHash(hash string) (*Link, error) {
-	// return stable in-memory pointer if available
-	s.mu.RLock()
-	if link, ok := s.shareCache[hash]; ok && link != nil {
-		s.mu.RUnlock()
-		if link.Expire != 0 && link.Expire <= time.Now().Unix() {
-			_ = s.back.Delete(hash)
-			s.mu.Lock()
-			delete(s.shareCache, hash)
-			s.mu.Unlock()
-			return nil, errors.ErrNotExist
-		}
-		return link, nil
-	}
-	s.mu.RUnlock()
-
 	link, err := s.back.GetByHash(hash)
 	if err != nil {
 		return nil, err
 	}
+
 	if link.Expire != 0 && link.Expire <= time.Now().Unix() {
-		_ = s.back.Delete(hash)
+		if err := s.Delete(link.Hash); err != nil {
+			return nil, err
+		}
 		return nil, errors.ErrNotExist
 	}
-	s.mu.Lock()
 
-	s.shareCache[hash] = link
-	s.mu.Unlock()
 	return link, nil
 }
 
-// GetPermanent wraps StorageBackend.GetPermanent
+// GetPermanent wraps a StorageBackend.GetPermanent
 func (s *Storage) GetPermanent(path, source string, id uint) (*Link, error) {
-	l, err := s.back.GetPermanent(path, source, id)
-	if err == nil && l != nil {
-		s.mu.Lock()
-
-		s.shareCache[l.Hash] = l
-		s.mu.Unlock()
-	}
-	return l, err
+	return s.back.GetPermanent(path, source, id)
 }
 
-// Gets wraps StorageBackend.Gets and handles expiry.
+// Gets wraps a StorageBackend.Gets
 func (s *Storage) Gets(sourcePath, source string, id uint) ([]*Link, error) {
 	links, err := s.back.Gets(sourcePath, source, id)
+
 	if err != nil {
 		return nil, err
 	}
-	filtered, err := s.filterExpired(links)
-	if err != nil {
-		return nil, err
-	}
-	s.mu.Lock()
-	for i, l := range filtered {
-		if l == nil {
-			continue
-		}
-		if existing, ok := s.shareCache[l.Hash]; ok && existing != nil {
-			filtered[i] = existing
-		} else {
-			s.shareCache[l.Hash] = l
+
+	for i, link := range links {
+		if link.Expire != 0 && link.Expire <= time.Now().Unix() {
+			if err := s.Delete(link.Hash); err != nil {
+				return nil, err
+			}
+			links = append(links[:i], links[i+1:]...)
 		}
 	}
-	s.mu.Unlock()
-	return filtered, nil
+
+	return links, nil
 }
 
-// GetBySourcePath wraps StorageBackend.GetBySourcePath and handles expiry.
-func (s *Storage) GetBySourcePath(path, source string) ([]*Link, error) {
-	links, err := s.back.GetBySourcePath(path, source)
-	if err != nil {
-		return nil, err
-	}
-	filtered, err := s.filterExpired(links)
-	if err != nil {
-		return nil, err
-	}
-	s.mu.Lock()
-	for i, l := range filtered {
-		if l == nil {
-			continue
-		}
-		if existing, ok := s.shareCache[l.Hash]; ok && existing != nil {
-			filtered[i] = existing
-		} else {
-			s.shareCache[l.Hash] = l
-		}
-	}
-	s.mu.Unlock()
-	return filtered, nil
-}
-
-// UpdateShares updates all shares that exactly match oldSource and oldPath
-// to point to newSource and newPath. Returns the number of updated shares.
-func (s *Storage) UpdateShares(oldSource, oldPath, newSource, newPath string) (int, error) {
-	links, err := s.back.All()
-	if err != nil && err != errors.ErrNotExist {
-		logger.Error("failed to list shares", "error", err)
-		return 0, err
-	}
-	updated := 0
-	for _, l := range links {
-		if l == nil {
-			continue
-		}
-		if l.Source != oldSource {
-			continue
-		}
-		pos := strings.Index(l.Path, oldPath)
-		if pos < 0 {
-			continue
-		}
-		oldFullPath := l.Path
-		l.Source = newSource
-		l.Path = oldFullPath[:pos] + newPath + oldFullPath[pos+len(oldPath):]
-		if err := s.back.Save(l); err != nil {
-			logger.Error("failed to save updated share", "hash", l.Hash, "error", err)
-			return updated, err
-		}
-		s.mu.Lock()
-		if existing, ok := s.shareCache[l.Hash]; ok && existing != nil {
-			// update existing cached pointer fields
-			existing.Source = l.Source
-			existing.Path = l.Path
-		} else {
-			s.shareCache[l.Hash] = l
-		}
-		s.mu.Unlock()
-		logger.Info("share updated", "hash", l.Hash, "fromPath", oldFullPath, "toPath", l.Path)
-		updated++
-	}
-	if updated == 0 {
-		logger.Warning("no matching shares to update for provided source/path")
-	}
-	return updated, nil
-}
-
-// Save wraps StorageBackend.Save
+// Save wraps a StorageBackend.Save
 func (s *Storage) Save(l *Link) error {
-	if err := s.back.Save(l); err != nil {
-		return err
-	}
-	s.mu.Lock()
-	s.shareCache[l.Hash] = l
-	s.mu.Unlock()
-	return nil
+	return s.back.Save(l)
 }
 
-// Delete wraps StorageBackend.Delete
+// Delete wraps a StorageBackend.Delete
 func (s *Storage) Delete(hash string) error {
-	if err := s.back.Delete(hash); err != nil {
-		return err
-	}
-	s.mu.Lock()
-	delete(s.shareCache, hash)
-	s.mu.Unlock()
-	return nil
-}
-
-// Flush persists the current in-memory state of all shares to the backing store.
-// Call during graceful shutdown to ensure DB matches memory.
-func (s *Storage) Flush() error {
-	s.mu.RLock()
-	links := make([]*Link, 0, len(s.shareCache))
-	for _, l := range s.shareCache {
-		if l != nil {
-			links = append(links, l)
-		}
-	}
-	s.mu.RUnlock()
-	for _, l := range links {
-		if err := s.back.Save(l); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// filterExpired removes expired links and deletes them from storage.
-func (s *Storage) filterExpired(links []*Link) ([]*Link, error) {
-	var filtered []*Link
-	for _, link := range links {
-		if link.Expire != 0 && link.Expire <= time.Now().Unix() && !link.KeepAfterExpiration {
-			_ = s.back.Delete(link.Hash)
-			s.mu.Lock()
-			delete(s.shareCache, link.Hash)
-			s.mu.Unlock()
-			continue
-		}
-		filtered = append(filtered, link)
-	}
-	return filtered, nil
+	return s.back.Delete(hash)
 }

backend/database/storage/bolt/auth.go

@@ -17,6 +17,8 @@ func (s authBackend) Get(t string) (auth.Auther, error) {
 		auther = &auth.JSONAuth{}
 	case "proxy":
 		auther = &auth.ProxyAuth{}
+	case "hook":
+		auther = &auth.HookAuth{}
 	case "noauth":
 		auther = &auth.NoAuth{}
 	default:

backend/database/storage/bolt/bolt.go

@@ -5,33 +5,18 @@ import (
 
 	"github.com/gtsteffaniak/filebrowser/backend/auth"
 	"github.com/gtsteffaniak/filebrowser/backend/common/settings"
-	"github.com/gtsteffaniak/filebrowser/backend/database/access"
 	"github.com/gtsteffaniak/filebrowser/backend/database/share"
 	"github.com/gtsteffaniak/filebrowser/backend/database/users"
 )
 
-// Storage is a storage powered by a Backend which makes the necessary
-// verifications when fetching and saving data to ensure consistency.
-type BoltStore struct {
-	Users    *users.Storage
-	Share    *share.Storage
-	Auth     *auth.Storage
-	Settings *settings.Storage
-	Access   *access.Storage
-}
-
 // NewStorage creates a storage.Storage based on Bolt DB.
-func NewStorage(db *storm.DB) (*BoltStore, 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, err := auth.NewStorage(authBackend{db: db}, userStore)
 	if err != nil {
-		return nil, err
+		return nil, nil, nil, nil, err
 	}
-	return &BoltStore{
-		Users:    userStore,
-		Share:    share.NewStorage(shareBackend{db: db}, userStore),
-		Auth:     authStore,
-		Settings: settings.NewStorage(settingsBackend{db: db}),
-		Access:   access.NewStorage(db, userStore),
-	}, nil
+	return authStore, userStore, shareStore, settingsStore, nil
 }

backend/database/storage/bolt/share.go

@@ -52,16 +52,6 @@ func (s shareBackend) GetPermanent(path, source string, id uint) (*share.Link, e
 	return &v, nil
 }
 
-// GetBySourcePath returns all shares that exactly match Path and Source across users.
-func (s shareBackend) GetBySourcePath(path, source string) ([]*share.Link, error) {
-	var v []*share.Link
-	err := s.db.Select(q.Eq("Path", path), q.Eq("Source", source)).Find(&v)
-	if err == storm.ErrNotFound {
-		return nil, errors.ErrNotExist
-	}
-	return v, err
-}
-
 func (s shareBackend) Gets(path, sourcePath string, id uint) ([]*share.Link, error) {
 	var v []*share.Link
 	_ = s.db.Select(q.Eq("Path", path), q.Eq("Source", sourcePath), q.Eq("UserID", id)).Find(&v)
@@ -70,7 +60,7 @@ func (s shareBackend) Gets(path, sourcePath string, id uint) ([]*share.Link, err
 	// through and filter out expired share
 	for i := range v {
 		if v[i].Expire < time.Now().Unix() && v[i].Expire != 0 {
-			err = s.Delete(v[i].Hash)
+			err = s.Delete(v[i].PasswordHash)
 			if err != nil {
 				logger.Errorf("expired share could not be deleted: %v", err.Error())
 			}

backend/database/storage/bolt/users.go

@@ -21,11 +21,6 @@ type usersBackend struct {
 	db *storm.DB
 }
 
-// NewUsersBackend returns a users.StorageBackend backed by storm DB.
-func NewUsersBackend(db *storm.DB) users.StorageBackend {
-	return &usersBackend{db: db}
-}
-
 func (st usersBackend) GetBy(i interface{}) (user *users.User, err error) {
 	user = &users.User{}
 
@@ -131,14 +126,6 @@ func (st usersBackend) Update(user *users.User, actorIsAdmin bool, fields ...str
 
 		// Get the value to be stored
 		val := fieldValue.Interface()
-		if field == "OtpEnabled" {
-			otpEnabled, _ := val.(bool)
-			if otpEnabled {
-				continue
-			}
-			field = "TOTPSecret" // if otp is disabled, we also want to clear the TOTPSecret
-			val = ""             // clear the TOTPSecret
-		}
 		// Update the database
 		if err := st.db.UpdateField(existingUser, field, val); err != nil {
 			return fmt.Errorf("failed to update user field: %s, error: %v", field, err)
@@ -158,9 +145,6 @@ func (st usersBackend) Save(user *users.User, changePass, disableScopeChange boo
 	if user.LoginMethod == "" {
 		user.LoginMethod = users.LoginMethodPassword
 	}
-	if user.Username == "anonymous" {
-		return fmt.Errorf("username cannot be 'anonymous'")
-	}
 	logger.Debugf("Saving user [%s] changepass: %v", user.Username, changePass)
 	if user.LoginMethod == users.LoginMethodPassword && changePass {
 		err := checkPassword(user.Password)
@@ -242,11 +226,10 @@ func parseFields(user *users.User, fields []string, actorIsAdmin bool) ([]string
 			field := t.Field(i)
 			// which=all can't update password
 			switch strings.ToLower(field.Name) {
-			case "id", "username", "password", "apikeys", "totpenabled", "totpsecret", "totpnonce":
+			case "id", "username", "loginmethod", "password":
 				// Skip these fields
 				continue
 			}
-
 			fields = append(fields, field.Name)
 		}
 	}

backend/database/storage/bolt/utils.go

@@ -18,16 +18,3 @@ func get(db *storm.DB, name string, to interface{}) error {
 func Save(db *storm.DB, name string, from interface{}) error {
 	return db.Set("config", name, from)
 }
-
-func SaveAccessRules(db *storm.DB, name string, from interface{}) error {
-	return db.Set("access_rules", name, from)
-}
-
-func GetAccessRules(db *storm.DB, name string, to interface{}) error {
-	err := db.Get("access_rules", name, to)
-	if err == storm.ErrNotFound {
-		return errors.ErrNotExist
-	}
-
-	return err
-}

backend/database/storage/storage.go

@@ -7,16 +7,27 @@ import (
 	"strings"
 
 	storm "github.com/asdine/storm/v3"
+	"github.com/gtsteffaniak/filebrowser/backend/auth"
 	"github.com/gtsteffaniak/filebrowser/backend/common/settings"
 	"github.com/gtsteffaniak/filebrowser/backend/common/utils"
+	"github.com/gtsteffaniak/filebrowser/backend/database/share"
 	"github.com/gtsteffaniak/filebrowser/backend/database/storage/bolt"
 	"github.com/gtsteffaniak/filebrowser/backend/database/users"
 	"github.com/gtsteffaniak/go-logger/logger"
 )
 
-var userStore *users.Storage
+// 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.Storage
+	Share    *share.Storage
+	Auth     *auth.Storage
+	Settings *settings.Storage
+}
 
-func InitializeDb(path string) (*bolt.BoltStore, bool, error) {
+var store *Storage
+
+func InitializeDb(path string) (*Storage, bool, error) {
 	exists, err := dbExists(path)
 	if err != nil {
 		panic(err)
@@ -28,18 +39,20 @@ func InitializeDb(path string) (*bolt.BoltStore, bool, error) {
 		}
 		logger.Fatalf("could not open database: %v", err)
 	}
-	store, err := bolt.NewStorage(db)
+	authStore, userStore, shareStore, settingsStore, err := bolt.NewStorage(db)
 	if err != nil {
 		return nil, exists, err
 	}
-	// Load access rules from DB on startup
-	// ignoring errors because
-	_ = store.Access.LoadFromDB()
-	userStore = store.Users
 	err = bolt.Save(db, "version", 2)
 	if err != nil {
 		return nil, exists, err
 	}
+	store = &Storage{
+		Auth:     authStore,
+		Users:    userStore,
+		Share:    shareStore,
+		Settings: settingsStore,
+	}
 	if !exists {
 		quickSetup(store)
 	}
@@ -67,40 +80,33 @@ func dbExists(path string) (bool, error) {
 	return false, err
 }
 
-func quickSetup(store *bolt.BoltStore) {
+func quickSetup(store *Storage) {
 	settings.Config.Auth.Key = utils.GenerateKey()
 	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)
-	passwordAuth := settings.Config.Auth.Methods.PasswordAuth.Enabled
-	noAuth := settings.Config.Auth.Methods.NoAuth
-	if passwordAuth || noAuth {
-		user := &users.User{}
-		settings.ApplyUserDefaults(user)
-		user.Username = settings.Config.Auth.AdminUsername
-		if settings.Config.Auth.AdminPassword == "" {
-			settings.Config.Auth.AdminPassword = "admin"
-		}
-		user.Password = settings.Config.Auth.AdminPassword
-		user.Permissions.Admin = true
-		user.Scopes = []users.SourceScope{}
-		for _, val := range settings.Config.Server.Sources {
-			user.Scopes = append(user.Scopes, users.SourceScope{
-				Name:  val.Path, // backend name is path
-				Scope: "",
-			})
-		}
-		user.LockPassword = false
-		user.Permissions = settings.AdminPerms()
-		logger.Debugf("Creating user as admin: %v %v", user.Username, user.Password)
-		err = store.Users.Save(user, true, true)
-		utils.CheckErr("store.Users.Save", err)
+	user := &users.User{}
+	settings.ApplyUserDefaults(user)
+	user.Username = settings.Config.Auth.AdminUsername
+	user.Password = settings.Config.Auth.AdminPassword
+	user.Permissions.Admin = true
+	user.Scopes = []users.SourceScope{}
+	for _, val := range settings.Config.Server.Sources {
+		user.Scopes = append(user.Scopes, users.SourceScope{
+			Name:  val.Path, // backend name is path
+			Scope: "",
+		})
 	}
+	user.LockPassword = false
+	user.Permissions = settings.AdminPerms()
+	logger.Debugf("Creating user as admin: %v %v", user.Username, user.Password)
+	err = store.Users.Save(user, true, true)
+	utils.CheckErr("store.Users.Save", err)
 }
 
 // create new user
-func CreateUser(userInfo users.User) error {
+func CreateUser(userInfo users.User, asAdmin bool) error {
 	newUser := &userInfo
 	if userInfo.LoginMethod == "password" {
 		if userInfo.Password == "" {
@@ -113,13 +119,17 @@ func CreateUser(userInfo users.User) error {
 		}
 		userInfo.Password = hashpass
 	}
-	// must have username
+	// must have username or password to create
 	if userInfo.Username == "" {
 		return fmt.Errorf("username is required to create a user")
 	}
 	logger.Debugf("Creating user: %v %v", userInfo.Username, userInfo.Scopes)
+	settings.ApplyUserDefaults(newUser)
+	if asAdmin {
+		userInfo.Permissions = settings.AdminPerms()
+	}
 	// create new home directories
-	err := userStore.Save(newUser, true, false)
+	err := store.Users.Save(newUser, true, false)
 	if err != nil {
 		return err
 	}

backend/database/users/storage.go

@@ -5,7 +5,6 @@ import (
 	"time"
 
 	"github.com/gtsteffaniak/filebrowser/backend/common/errors"
-	"github.com/gtsteffaniak/filebrowser/backend/database/crud"
 )
 
 // StorageBackend is the interface to implement for a users storage.
@@ -30,43 +29,8 @@ type Store interface {
 	DeleteApiKey(username uint, name string) error
 }
 
-// crudBackend implements crud.CrudBackend[User] for users storage.
-type crudBackend struct {
-	back StorageBackend
-}
-
-func (c *crudBackend) GetByID(id any) (*User, error) {
-	switch v := id.(type) {
-	case string, uint:
-		return c.back.GetBy(v)
-	default:
-		return nil, errors.ErrInvalidDataType
-	}
-}
-
-func (c *crudBackend) GetAll() ([]*User, error) {
-	return c.back.Gets()
-}
-
-func (c *crudBackend) Save(obj *User) error {
-	// Use default values for changePass and disableScopeChange
-	return c.back.Save(obj, false, false)
-}
-
-func (c *crudBackend) DeleteByID(id any) error {
-	switch v := id.(type) {
-	case string:
-		return c.back.DeleteByUsername(v)
-	case uint:
-		return c.back.DeleteByID(v)
-	default:
-		return errors.ErrInvalidDataType
-	}
-}
-
-// Storage is a users storage using generics.
+// Storage is a users storage.
 type Storage struct {
-	Generic *crud.Storage[User]
 	back    StorageBackend
 	updated map[uint]int64
 	mux     sync.RWMutex
@@ -75,7 +39,6 @@ type Storage struct {
 // NewStorage creates a users storage from a backend.
 func NewStorage(back StorageBackend) *Storage {
 	return &Storage{
-		Generic: crud.NewStorage[User](&crudBackend{back: back}),
 		back:    back,
 		updated: map[uint]int64{},
 	}
@@ -161,8 +124,18 @@ func (s *Storage) Save(user *User, changePass, disableScopeChange bool) error {
 func (s *Storage) Delete(id interface{}) error {
 	switch id := id.(type) {
 	case string:
+		user, err := s.back.GetBy(id)
+		if err != nil {
+			return err
+		}
+		if user.ID == 1 {
+			return errors.ErrRootUserDeletion
+		}
 		return s.back.DeleteByUsername(id)
 	case uint:
+		if id == 1 {
+			return errors.ErrRootUserDeletion
+		}
 		return s.back.DeleteByID(id)
 	default:
 		return errors.ErrInvalidDataType

backend/database/users/users.go

@@ -41,15 +41,12 @@ type Sorting struct {
 }
 
 type Preview struct {
-	DisableHideSidebar bool `json:"disableHideSidebar"` // disable the hide sidebar preview for previews and editors
 	HighQuality        bool `json:"highQuality"`        // generate high quality preview images
 	Image              bool `json:"image"`              // show real image as icon instead of generic photo icon
 	Video              bool `json:"video"`              // show preview image for video files
 	MotionVideoPreview bool `json:"motionVideoPreview"` // show multiple frames for videos in preview when hovering
 	Office             bool `json:"office"`             // show preview image for office files
 	PopUp              bool `json:"popup"`              // show larger popup preview when hovering
-	AutoplayMedia      bool `json:"autoplayMedia"`      // autoplay media files in preview
-	DefaultMediaPlayer bool `json:"defaultMediaPlayer"` // disable html5 media player and use the default media player
 }
 
 // User describes a user.
@@ -78,38 +75,30 @@ type SourceScope struct {
 
 // json tags must match variable name with smaller case first letter
 type NonAdminEditable struct {
-	EditorQuickSave            bool        `json:"editorQuickSave"`         // show quick save button in editor
-	HideSidebarFileActions     bool        `json:"hideSidebarFileActions"`  // hide the file actions in the sidebar
-	DisableQuickToggles        bool        `json:"disableQuickToggles"`     // disable the quick toggles in the sidebar
-	DisableSearchOptions       bool        `json:"disableSearchOptions"`    // disable the search options in the search bar
-	DeleteWithoutConfirming    bool        `json:"deleteWithoutConfirming"` // delete files without confirmation
-	Preview                    Preview     `json:"preview"`
-	StickySidebar              bool        `json:"stickySidebar"` // keep sidebar open when navigating
-	DarkMode                   bool        `json:"darkMode"`      // should dark mode be enabled
-	Password                   string      `json:"password,omitempty"`
-	Locale                     string      `json:"locale"`      // language to use: eg. de, en, or fr
-	ViewMode                   string      `json:"viewMode"`    // view mode to use: eg. normal, list, grid, or compact
-	SingleClick                bool        `json:"singleClick"` // open directory on single click, also enables middle click to open in new tab
-	Sorting                    Sorting     `json:"sorting"`
-	ShowHidden                 bool        `json:"showHidden"`                 // show hidden files in the UI. On windows this includes files starting with a dot and windows hidden files
-	DateFormat                 bool        `json:"dateFormat"`                 // when false, the date is relative, when true, the date is an exact timestamp
-	GallerySize                int         `json:"gallerySize"`                // 0-9 - the size of the gallery thumbnails
-	ThemeColor                 string      `json:"themeColor"`                 // theme color to use: eg. #ff0000, or var(--red), var(--purple), etc
-	QuickDownload              bool        `json:"quickDownload"`              // show icon to download in one click
-	DisableUpdateNotifications bool        `json:"disableUpdateNotifications"` // disable update notifications
-	FileLoading                FileLoading `json:"fileLoading"`                // upload and download settings
-	DisableOfficePreviewExt    string      `json:"disableOfficePreviewExt"`    // deprecated
-	DisableOnlyOfficeExt       string      `json:"disableOnlyOfficeExt"`       // deprecated
-	DisablePreviewExt          string      `json:"disablePreviewExt"`          // space separated list of file extensions to disable preview for
-	DisableViewingExt          string      `json:"disableViewingExt"`          // space separated list of file extensions to disable viewing for
-	CustomTheme                string      `json:"customTheme"`                // Name of theme to use chosen from custom themes config.
-	ShowSelectMultiple         bool        `json:"showSelectMultiple"`         // show select multiple files on desktop
-	DebugOffice                bool        `json:"debugOffice"`                // debug onlyoffice editor
+	Preview              Preview `json:"preview"`
+	StickySidebar        bool    `json:"stickySidebar"` // keep sidebar open when navigating
+	DarkMode             bool    `json:"darkMode"`      // should dark mode be enabled
+	Password             string  `json:"password,omitempty"`
+	Locale               string  `json:"locale"`      // language to use: eg. de, en, or fr
+	ViewMode             string  `json:"viewMode"`    // view mode to use: eg. normal, list, grid, or compact
+	SingleClick          bool    `json:"singleClick"` // open directory on single click, also enables middle click to open in new tab
+	Sorting              Sorting `json:"sorting"`
+	ShowHidden           bool    `json:"showHidden"`           // show hidden files in the UI. On windows this includes files starting with a dot and windows hidden files
+	DateFormat           bool    `json:"dateFormat"`           // when false, the date is relative, when true, the date is an exact timestamp
+	GallerySize          int     `json:"gallerySize"`          // 0-9 - the size of the gallery thumbnails
+	ThemeColor           string  `json:"themeColor"`           // theme color to use: eg. #ff0000, or var(--red), var(--purple), etc
+	QuickDownload        bool    `json:"quickDownload"`        // show icon to download in one click
+	DisableOnlyOfficeExt string  `json:"disableOnlyOfficeExt"` // comma separated list of file extensions to disable onlyoffice preview for
 }
 
-type FileLoading struct {
-	MaxConcurrent int `json:"maxConcurrentUpload"`
-	ChunkSize     int `json:"uploadChunkSizeMb"`
+var PublicUser = User{
+	NonAdminEditable: NonAdminEditable{
+		Password: "publicUser", // temp user not registered
+		ViewMode: "normal",
+	},
+	Username:     "publicUser", // temp user not registered
+	LockPassword: true,
+	Permissions:  Permissions{},
 }
 
 func CleanUsername(s string) string {

backend/events/eventRouter.go

@@ -75,12 +75,7 @@ func Register(username string, sources []string) chan EventMessage {
 
 func Unregister(username string, ch chan EventMessage) {
 	userClientsMu.Lock()
-	defer userClientsMu.Unlock()
-	conns, ok := userClients[username]
-	if !ok {
-		// User already cleaned up by Shutdown, nothing to do.
-		return
-	}
+	conns := userClients[username]
 	for i, c := range conns {
 		if c == ch {
 			userClients[username] = append(conns[:i], conns[i+1:]...)
@@ -90,15 +85,18 @@ func Unregister(username string, ch chan EventMessage) {
 	if len(userClients[username]) == 0 {
 		delete(userClients, username)
 	}
+	userClientsMu.Unlock()
 
 	sourceClientsMu.Lock()
-	defer sourceClientsMu.Unlock()
 	for source, clients := range sourceClients {
 		delete(clients, ch)
 		if len(clients) == 0 {
 			delete(sourceClients, source)
 		}
 	}
+	sourceClientsMu.Unlock()
+
+	close(ch)
 }
 
 func SendToUsers(eventType, message string, users []string) {
@@ -140,24 +138,3 @@ func handleSourceUpdates() {
 		}
 	}
 }
-
-func Shutdown() {
-	userClientsMu.Lock()
-	defer userClientsMu.Unlock()
-	sourceClientsMu.Lock()
-	defer sourceClientsMu.Unlock()
-
-	for username, clientChannels := range userClients {
-		for _, ch := range clientChannels {
-			// Clean up source clients
-			for source, clients := range sourceClients {
-				delete(clients, ch)
-				if len(clients) == 0 {
-					delete(sourceClients, source)
-				}
-			}
-			close(ch)
-		}
-		delete(userClients, username)
-	}
-}

backend/ffmpeg/image.go

@@ -1,341 +0,0 @@
-package ffmpeg
-
-import (
-	"bytes"
-	"fmt"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strconv"
-	"strings"
-)
-
-// ImageService handles image operations with ffmpeg
-type ImageService struct {
-	ffmpegPath  string
-	ffprobePath string
-	debug       bool
-}
-
-// NewImageService creates a new image service instance
-func NewImageService(ffmpegPath, ffprobePath string, debug bool) *ImageService {
-	return &ImageService{
-		ffmpegPath:  ffmpegPath,
-		ffprobePath: ffprobePath,
-		debug:       debug,
-	}
-}
-
-// GetImageDimensions extracts the dimensions of an image file using ffprobe
-func (s *ImageService) GetImageDimensions(imagePath string) (width, height int, err error) {
-	fmt.Printf("🔍 IMAGE SERVICE: Getting dimensions for %s\n", filepath.Base(imagePath))
-	fmt.Printf("🔧 IMAGE SERVICE: Using ffprobe at: %s\n", s.ffprobePath)
-
-	// Get HEIC dimensions (fallback to individual stream dimensions for nowe re
-	probeCmd := exec.Command(
-		s.ffprobePath,
-		"-v", "error",
-		"-select_streams", "v:0",
-		"-show_entries", "stream=width,height",
-		"-of", "csv=p=0:s=x",
-		imagePath,
-	)
-
-	fmt.Printf("🚀 IMAGE SERVICE: Running command: %s %s\n", s.ffprobePath, strings.Join(probeCmd.Args[1:], " "))
-
-	var probeOut bytes.Buffer
-	var probeErr bytes.Buffer
-	probeCmd.Stdout = &probeOut
-	probeCmd.Stderr = &probeErr
-
-	if err = probeCmd.Run(); err != nil {
-		fmt.Printf("❌ IMAGE SERVICE: ffprobe failed with error: %v\n", err)
-		fmt.Printf("❌ IMAGE SERVICE: ffprobe stderr: %s\n", probeErr.String())
-		return 0, 0, fmt.Errorf("ffprobe command failed on image file '%s': %w", imagePath, err)
-	}
-
-	dimensions := strings.TrimSpace(probeOut.String())
-	fmt.Printf("📏 IMAGE SERVICE: Got raw dimensions string: '%s'\n", dimensions)
-
-	// Handle cases where ffprobe returns multiple lines or extra characters
-	// Take the first line and clean it up
-	lines := strings.Split(dimensions, "\n")
-	cleanDimensions := strings.TrimSpace(lines[0])
-
-	// Remove any trailing 'x' characters that might appear
-	cleanDimensions = strings.TrimSuffix(cleanDimensions, "x")
-
-	fmt.Printf("📏 IMAGE SERVICE: Cleaned dimensions string: '%s'\n", cleanDimensions)
-
-	parts := strings.Split(cleanDimensions, "x")
-	if len(parts) != 2 {
-		fmt.Printf("❌ IMAGE SERVICE: Invalid dimensions format after cleaning: %s\n", cleanDimensions)
-		return 0, 0, fmt.Errorf("invalid dimensions format: %s", cleanDimensions)
-	}
-
-	width, err = strconv.Atoi(parts[0])
-	if err != nil {
-		fmt.Printf("❌ IMAGE SERVICE: Invalid width: %s\n", parts[0])
-		return 0, 0, fmt.Errorf("invalid width: %w", err)
-	}
-
-	height, err = strconv.Atoi(parts[1])
-	if err != nil {
-		fmt.Printf("❌ IMAGE SERVICE: Invalid height: %s\n", parts[1])
-		return 0, 0, fmt.Errorf("invalid height: %w", err)
-	}
-
-	fmt.Printf("✅ IMAGE SERVICE: Parsed dimensions: %dx%d\n", width, height)
-	return width, height, nil
-}
-
-// ConvertHEICToJPEG converts a HEIC file to JPEG with specified dimensions and quality using proper tile extraction
-func (s *ImageService) ConvertHEICToJPEG(heicPath string, targetWidth, targetHeight int, quality string) ([]byte, error) {
-	fmt.Printf("🎯 IMAGE SERVICE: Converting HEIC %s to JPEG (%dx%d, quality %s) using proper tile extraction\n", filepath.Base(heicPath), targetWidth, targetHeight, quality)
-
-	// Create temporary directory for tile processing
-	outputDir := filepath.Dir(heicPath)
-	tempDir := filepath.Join(outputDir, fmt.Sprintf("heic_tiles_%d", os.Getpid()))
-	err := os.MkdirAll(tempDir, 0755)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create temp directory: %w", err)
-	}
-	defer func() {
-		fmt.Printf("🧹 IMAGE SERVICE: Cleaning up temporary directory: %s\n", tempDir)
-		os.RemoveAll(tempDir)
-	}()
-
-	// Step 1: Get grid info using trace output
-	fmt.Printf("📐 IMAGE SERVICE: Step 1 - Getting grid info from HEIC trace\n")
-
-	// Use ffprobe with trace level to get grid information
-	gridCmd := exec.Command(s.ffmpegPath, "-loglevel", "trace", "-i", heicPath, "-f", "null", "-")
-	var gridOut bytes.Buffer
-	var gridErr bytes.Buffer
-	gridCmd.Stdout = &gridOut
-	gridCmd.Stderr = &gridErr
-	_ = gridCmd.Run() // Don't check error, we're just extracting info
-
-	traceOutput := gridErr.String()
-	fmt.Printf("📊 IMAGE SERVICE: Got trace output: %d bytes\n", len(traceOutput))
-
-	// Parse grid dimensions from trace output
-	var gridCols, gridRows = 8, 6 // Default fallback
-	var val int
-
-	// Look for grid_row and grid_col in trace output
-	lines := strings.Split(traceOutput, "\n")
-	for _, line := range lines {
-		if strings.Contains(line, "grid_row") {
-			// Try to extract grid_row value
-			if parts := strings.Split(line, "grid_row"); len(parts) > 1 {
-				if matches := strings.Fields(parts[1]); len(matches) > 0 {
-					if val, err = strconv.Atoi(strings.Trim(matches[0], " :=")); err == nil {
-						gridRows = val + 1 // HEIC grid_row is 0-based
-						fmt.Printf("📐 IMAGE SERVICE: Parsed grid_row: %d (rows: %d)\n", val, gridRows)
-					}
-				}
-			}
-		}
-		if strings.Contains(line, "grid_col") {
-			// Try to extract grid_col value
-			if parts := strings.Split(line, "grid_col"); len(parts) > 1 {
-				if matches := strings.Fields(parts[1]); len(matches) > 0 {
-					if val, err = strconv.Atoi(strings.Trim(matches[0], " :=")); err == nil {
-						gridCols = val + 1 // HEIC grid_col is 0-based
-						fmt.Printf("📐 IMAGE SERVICE: Parsed grid_col: %d (cols: %d)\n", val, gridCols)
-					}
-				}
-			}
-		}
-	}
-
-	fmt.Printf("📊 IMAGE SERVICE: Using grid dimensions: %dx%d\n", gridCols, gridRows)
-
-	// Use FFmpeg's auto-orientation feature instead of forced rotation
-	fmt.Printf("🔄 IMAGE SERVICE: Using FFmpeg auto-orientation for proper image orientation\n")
-	orientationFilter := ",auto-orient=1"
-
-	// Step 2: Extract tile streams (skip stream 0 which is compatibility image)
-	fmt.Printf("🔧 IMAGE SERVICE: Step 2 - Extracting tile streams\n")
-
-	// Extract using the exact approach that works: ffmpeg -i input.heic -map 0 output_%d.png
-	// But we'll skip the first output (stream 0) since it's the compatibility image
-	tilesPattern := filepath.Join(tempDir, "output_%d.png")
-
-	extractCmd := exec.Command(
-		s.ffmpegPath,
-		"-i", heicPath,
-		"-map", "0", // Map all streams
-		"-y",
-		tilesPattern,
-	)
-
-	var extractOut bytes.Buffer
-	var extractErr bytes.Buffer
-	extractCmd.Stdout = &extractOut
-	extractCmd.Stderr = &extractErr
-
-	fmt.Printf("🚀 IMAGE SERVICE: Running tile extraction: %s %s\n", s.ffmpegPath, strings.Join(extractCmd.Args[1:], " "))
-
-	if err = extractCmd.Run(); err != nil {
-		fmt.Printf("❌ IMAGE SERVICE: Tile extraction failed: %v\n", err)
-		fmt.Printf("❌ IMAGE SERVICE: stderr: %s\n", extractErr.String())
-		return nil, fmt.Errorf("tile extraction failed: %w", err)
-	}
-
-	fmt.Printf("✅ IMAGE SERVICE: Tiles extracted successfully\n")
-
-	// Step 3: Filter tiles (skip output_0.png which is compatibility image)
-	fmt.Printf("🔧 IMAGE SERVICE: Step 3 - Filtering tiles\n")
-
-	files, err := filepath.Glob(filepath.Join(tempDir, "output_*.png"))
-	if err != nil || len(files) == 0 {
-		return nil, fmt.Errorf("no tiles extracted, found %d files", len(files))
-	}
-
-	fmt.Printf("📊 IMAGE SERVICE: Found %d extracted files\n", len(files))
-
-	// Create filtered tiles, skipping output_0.png (compatibility image)
-	// and rename them to sequential tile_001.png, tile_002.png, etc.
-	tileIndex := 1
-	expectedTiles := gridCols * gridRows
-
-	for i := 1; i <= len(files); i++ { // Start from 1 to skip output_0.png
-		sourceFile := filepath.Join(tempDir, fmt.Sprintf("output_%d.png", i))
-		var info os.FileInfo
-		if info, err = os.Stat(sourceFile); err == nil && info.Size() > 500 {
-			// This is a valid tile, rename it to sequential format
-			targetFile := filepath.Join(tempDir, fmt.Sprintf("tile_%03d.png", tileIndex))
-			if err = os.Rename(sourceFile, targetFile); err != nil {
-				fmt.Printf("⚠️ IMAGE SERVICE: Failed to rename %s: %v\n", filepath.Base(sourceFile), err)
-				continue
-			}
-			fmt.Printf("✅ IMAGE SERVICE: Valid tile %d: %s (%d bytes)\n", tileIndex, filepath.Base(targetFile), info.Size())
-			tileIndex++
-
-			// Stop if we have enough tiles
-			if tileIndex > expectedTiles {
-				break
-			}
-		} else {
-			fmt.Printf("⚠️ IMAGE SERVICE: Skipping invalid tile: output_%d.png\n", i)
-		}
-	}
-
-	actualTiles := tileIndex - 1
-	fmt.Printf("📊 IMAGE SERVICE: Using %d valid tiles (expected %d) with grid %dx%d\n", actualTiles, expectedTiles, gridCols, gridRows)
-
-	// Step 4: Merge tiles back into final image with proper quality and rotation
-	outputFile := filepath.Join(tempDir, "final_output.jpg")
-
-	// Build the video filter chain
-	inputPattern := filepath.Join(tempDir, "tile_%03d.png")
-
-	// Create filter chain: tile assembly + auto-orientation + proper scaling
-	var filterChain string
-
-	// For original size (targetWidth=0, targetHeight=0), don't scale
-	if targetWidth == 0 && targetHeight == 0 {
-		// This is original size - no scaling, maximum quality
-		// Use padding=0:margin=0 to eliminate black borders between tiles
-		filterChain = fmt.Sprintf("tile=%dx%d:nb_frames=%d:padding=0:margin=0%s",
-			gridCols, gridRows, actualTiles, orientationFilter)
-		fmt.Printf("🎯 IMAGE SERVICE: Using ORIGINAL size - no scaling, auto-orientation applied\n")
-	} else {
-		// This is a resize request - apply scaling with proper aspect handling
-		filterChain = fmt.Sprintf("tile=%dx%d:nb_frames=%d:padding=0:margin=0%s,scale=%d:%d:force_original_aspect_ratio=decrease:eval=frame",
-			gridCols, gridRows, actualTiles, orientationFilter, targetWidth, targetHeight)
-		fmt.Printf("🔽 IMAGE SERVICE: Scaling to %dx%d with auto-orientation applied\n", targetWidth, targetHeight)
-	}
-
-	fmt.Printf("🎨 IMAGE SERVICE: Using filter chain: %s\n", filterChain)
-
-	mergeCmd := exec.Command(
-		s.ffmpegPath,
-		"-i", inputPattern,
-		"-vf", filterChain,
-		"-frames:v", "1",
-		"-q:v", quality, // Use the quality setting passed in
-		"-pix_fmt", "yuvj420p", // Use full-range YUV for better JPEG compatibility
-		"-y",
-		outputFile,
-	)
-
-	var mergeOut bytes.Buffer
-	var mergeErr bytes.Buffer
-	mergeCmd.Stdout = &mergeOut
-	mergeCmd.Stderr = &mergeErr
-
-	fmt.Printf("🚀 IMAGE SERVICE: Running tile merge: %s %s\n", s.ffmpegPath, strings.Join(mergeCmd.Args[1:], " "))
-
-	if err = mergeCmd.Run(); err != nil {
-		fmt.Printf("❌ IMAGE SERVICE: Tile merge failed: %v\n", err)
-		fmt.Printf("❌ IMAGE SERVICE: stderr: %s\n", mergeErr.String())
-		return nil, fmt.Errorf("tile merge failed: %w", err)
-	}
-
-	fmt.Printf("✅ IMAGE SERVICE: Tiles merged successfully\n")
-
-	fmt.Printf("📖 IMAGE SERVICE: Reading final merged JPEG file: %s\n", outputFile)
-	jpegBytes, err := os.ReadFile(outputFile)
-	if err != nil {
-		fmt.Printf("❌ IMAGE SERVICE: Failed to read merged JPEG: %v\n", err)
-		return nil, fmt.Errorf("failed to read merged JPEG: %w", err)
-	}
-
-	fmt.Printf("✅ IMAGE SERVICE: Successfully read %d bytes from merged JPEG\n", len(jpegBytes))
-	return jpegBytes, nil
-}
-
-// ConvertImageToFormat converts any supported image format to another format
-func (s *ImageService) ConvertImageToFormat(inputPath, outputFormat string, targetWidth, targetHeight int, quality string) ([]byte, error) {
-	// Create temporary output file
-	outputDir := filepath.Dir(inputPath)
-	ext := ".jpg"
-	if outputFormat == "png" {
-		ext = ".png"
-	}
-	outputFile := filepath.Join(outputDir, fmt.Sprintf("converted_%d_%d%s", targetWidth, targetHeight, ext))
-	defer os.Remove(outputFile) // Clean up
-
-	// Build FFmpeg command
-	args := []string{
-		"-i", inputPath,
-	}
-
-	// Add scaling and auto-orientation
-	if targetWidth > 0 && targetHeight > 0 {
-		scaleFilter := fmt.Sprintf("scale=%d:%d:force_original_aspect_ratio=decrease,auto-orient=1", targetWidth, targetHeight)
-		args = append(args, "-vf", scaleFilter)
-	} else {
-		args = append(args, "-vf", "auto-orient=1")
-	}
-
-	// Add quality settings
-	if quality != "" {
-		args = append(args, "-q:v", quality)
-	}
-
-	// Add output file and overwrite flag
-	args = append(args, "-y", outputFile)
-
-	cmd := exec.Command(s.ffmpegPath, args...)
-
-	if s.debug {
-		cmd.Stdout = os.Stdout
-		cmd.Stderr = os.Stderr
-	}
-
-	if err := cmd.Run(); err != nil {
-		return nil, fmt.Errorf("ffmpeg image conversion failed on file '%s': %w", inputPath, err)
-	}
-
-	// Read the converted file
-	convertedBytes, err := os.ReadFile(outputFile)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read converted image: %w", err)
-	}
-
-	return convertedBytes, nil
-}

backend/ffmpeg/subtitles.go

@@ -1,289 +0,0 @@
-package ffmpeg
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/gtsteffaniak/filebrowser/backend/common/utils"
-	"github.com/gtsteffaniak/go-logger/logger"
-)
-
-// SubtitleTrack represents a subtitle track (embedded or external file)
-type SubtitleTrack struct {
-	Name     string `json:"name"`               // filename for external, or descriptive name for embedded
-	Language string `json:"language,omitempty"` // language code
-	Title    string `json:"title,omitempty"`    // title/description
-	Index    *int   `json:"index,omitempty"`    // stream index for embedded subtitles (nil for external)
-	Codec    string `json:"codec,omitempty"`    // codec name for embedded subtitles
-	Content  string `json:"content,omitempty"`  // subtitle content
-	IsFile   bool   `json:"isFile"`             // true for external files, false for embedded streams
-}
-
-// FFProbeOutput represents the JSON output from ffprobe
-type FFProbeOutput struct {
-	Streams []struct {
-		Index       int               `json:"index"`
-		CodecType   string            `json:"codec_type"`
-		CodecName   string            `json:"codec_name"`
-		Tags        map[string]string `json:"tags,omitempty"`
-		Disposition map[string]int    `json:"disposition,omitempty"`
-	} `json:"streams"`
-}
-
-// DetectAllSubtitles finds both embedded and external subtitle tracks
-func DetectAllSubtitles(videoPath string, parentDir string, modtime time.Time) []SubtitleTrack {
-	key := "all_subtitles:" + videoPath + ":" + modtime.Format(time.RFC3339)
-
-	// Check cache first
-	if cached, ok := utils.MediaCache.Get(key).([]SubtitleTrack); ok {
-		return cached
-	}
-
-	var allSubtitles []SubtitleTrack
-
-	// First, get embedded subtitles
-	embeddedSubs := detectEmbeddedSubtitles(videoPath)
-	allSubtitles = append(allSubtitles, embeddedSubs...)
-
-	// Then, get external subtitle files
-	externalSubs := detectExternalSubtitles(videoPath, parentDir)
-	allSubtitles = append(allSubtitles, externalSubs...)
-
-	// Cache the complete list
-	utils.MediaCache.Set(key, allSubtitles)
-
-	return allSubtitles
-}
-
-// detectEmbeddedSubtitles uses ffprobe to find embedded subtitle tracks
-func detectEmbeddedSubtitles(realPath string) []SubtitleTrack {
-	cmd := exec.Command("ffprobe",
-		"-v", "quiet",
-		"-print_format", "json",
-		"-show_streams",
-		"-select_streams", "s",
-		realPath)
-
-	output, err := cmd.Output()
-	if err != nil {
-		logger.Debug("ffprobe failed for file: " + realPath + ", error: " + err.Error())
-		return nil
-	}
-
-	var probeOutput FFProbeOutput
-	if err := json.Unmarshal(output, &probeOutput); err != nil {
-		logger.Debug("failed to parse ffprobe output for file: " + realPath)
-		return nil
-	}
-
-	var subtitles []SubtitleTrack
-	for _, stream := range probeOutput.Streams {
-		if stream.CodecType == "subtitle" {
-			track := SubtitleTrack{
-				Index:  &stream.Index,
-				Codec:  stream.CodecName,
-				IsFile: false, // This is an embedded subtitle
-			}
-
-			// Extract language and title from tags
-			if stream.Tags != nil {
-				if lang, ok := stream.Tags["language"]; ok {
-					track.Language = lang
-				}
-				if title, ok := stream.Tags["title"]; ok {
-					track.Title = title
-				}
-			}
-
-			// Generate a descriptive name
-			if track.Title != "" {
-				track.Name = track.Title
-			} else if track.Language != "" {
-				track.Name = "Embedded (" + track.Language + ")"
-			} else {
-				track.Name = "Embedded Subtitle " + strconv.Itoa(stream.Index)
-			}
-
-			subtitles = append(subtitles, track)
-		}
-	}
-	return subtitles
-}
-
-// detectExternalSubtitles finds external subtitle files in the same directory
-func detectExternalSubtitles(videoPath string, parentDir string) []SubtitleTrack {
-	var subtitles []SubtitleTrack
-
-	// Get the base name of the video (without extension)
-	videoBaseName := strings.TrimSuffix(filepath.Base(videoPath), filepath.Ext(videoPath))
-
-	// Common subtitle extensions
-	subtitleExts := []string{".srt", ".vtt", ".lrc", ".sbv", ".ass", ".ssa", ".sub", ".smi"}
-
-	// Look for subtitle files with matching base name
-	for _, ext := range subtitleExts {
-		subtitlePath := filepath.Join(parentDir, videoBaseName+ext)
-		if _, err := os.Stat(subtitlePath); err == nil {
-			// File exists
-			track := SubtitleTrack{
-				Name:   filepath.Base(subtitlePath),
-				IsFile: true, // This is an external file
-			}
-
-			// Try to infer language from filename patterns like "video.en.srt"
-			parts := strings.Split(videoBaseName, ".")
-			if len(parts) > 1 {
-				// Check if the last part before extension looks like a language code
-				lastPart := parts[len(parts)-1]
-				if len(lastPart) == 2 || len(lastPart) == 3 {
-					track.Language = lastPart
-				}
-			}
-
-			subtitles = append(subtitles, track)
-		}
-	}
-
-	return subtitles
-}
-
-// ExtractSubtitleContent extracts subtitle content without service management
-func ExtractSubtitleContent(videoPath string, streamIndex int) (string, error) {
-	cmd := exec.Command("ffmpeg",
-		"-i", videoPath,
-		"-map", fmt.Sprintf("0:%d", streamIndex),
-		"-c:s", "webvtt",
-		"-f", "webvtt",
-		"-") // output to stdout
-
-	output, err := cmd.Output()
-	if err != nil {
-		return "", fmt.Errorf("subtitle extraction failed: %v", err)
-	}
-
-	return string(output), nil
-}
-
-// LoadAndConvertSubtitleFile loads a subtitle file and converts it to WebVTT format
-func LoadAndConvertSubtitleFile(subtitlePath string) (string, error) {
-	ext := strings.ToLower(filepath.Ext(subtitlePath))
-
-	if ext == ".vtt" {
-		// Already WebVTT, just read it
-		content, err := os.ReadFile(subtitlePath)
-		if err != nil {
-			return "", err
-		}
-		return string(content), nil
-	}
-
-	if ext == ".srt" {
-		// Convert SRT to WebVTT using ffmpeg
-		cmd := exec.Command("ffmpeg",
-			"-i", subtitlePath,
-			"-c:s", "webvtt",
-			"-f", "webvtt",
-			"-") // output to stdout
-
-		output, err := cmd.Output()
-		if err != nil {
-			return "", fmt.Errorf("failed to convert SRT to WebVTT: %v", err)
-		}
-		return string(output), nil
-	}
-
-	// For other formats, try to read as plain text and hope for the best
-	// This is a fallback - ideally you'd want format-specific converters
-	content, err := os.ReadFile(subtitlePath)
-	if err != nil {
-		return "", err
-	}
-
-	// Basic conversion wrapper for non-VTT formats
-	vttHeader := "WEBVTT\n\n"
-	return vttHeader + string(content), nil
-}
-
-// ExtractSingleSubtitle extracts content for a specific subtitle track by array index
-func ExtractSingleSubtitle(videoPath string, parentDir string, trackIndex int, modtime time.Time) (SubtitleTrack, error) {
-	// Get all subtitle tracks
-	allTracks := DetectAllSubtitles(videoPath, parentDir, modtime)
-
-	if trackIndex >= len(allTracks) {
-		return SubtitleTrack{}, fmt.Errorf("subtitle track %d not found (only %d tracks available)", trackIndex, len(allTracks))
-	}
-
-	track := allTracks[trackIndex]
-
-	// Load content based on type
-	if track.IsFile {
-		// Load external subtitle file
-		subtitlePath := filepath.Join(parentDir, track.Name)
-		content, err := LoadAndConvertSubtitleFile(subtitlePath)
-		if err != nil {
-			return SubtitleTrack{}, fmt.Errorf("failed to load external subtitle: %v", err)
-		}
-		track.Content = content
-	} else {
-		// Extract embedded subtitle content
-		if track.Index == nil {
-			return SubtitleTrack{}, fmt.Errorf("embedded subtitle track has no stream index")
-		}
-		content, err := ExtractSubtitleContent(videoPath, *track.Index)
-		if err != nil {
-			return SubtitleTrack{}, fmt.Errorf("failed to extract embedded subtitle: %v", err)
-		}
-		track.Content = content
-	}
-
-	return track, nil
-}
-
-// LoadAllSubtitleContent loads the actual content for all detected subtitle tracks
-func LoadAllSubtitleContent(videoPath string, subtitles []SubtitleTrack, modtime time.Time) error {
-	for idx := range subtitles {
-		subtitle := &subtitles[idx]
-
-		// Check if content is already cached
-		contentKey := fmt.Sprintf("subtitle_content:%s:%d:%s", videoPath, idx, modtime.Format(time.RFC3339))
-		if cached, ok := utils.MediaCache.Get(contentKey).(string); ok {
-			subtitle.Content = cached
-			continue
-		}
-
-		var content string
-		var err error
-
-		if subtitle.IsFile {
-			// Load external subtitle file content and convert to WebVTT
-			subtitlePath := filepath.Join(filepath.Dir(videoPath), subtitle.Name)
-			content, err = LoadAndConvertSubtitleFile(subtitlePath)
-			if err != nil {
-				logger.Debug("failed to read/convert subtitle file " + subtitlePath + ": " + err.Error())
-				continue
-			}
-		} else {
-			// Load embedded subtitle content
-			if subtitle.Index == nil {
-				logger.Debug("embedded subtitle has no stream index")
-				continue
-			}
-			content, err = ExtractSubtitleContent(videoPath, *subtitle.Index)
-			if err != nil {
-				logger.Debug("failed to extract embedded subtitle: " + err.Error())
-				continue
-			}
-		}
-
-		subtitle.Content = content
-		// Cache the content for future requests
-		utils.MediaCache.Set(contentKey, content)
-	}
-	return nil
-}

backend/ffmpeg/video.go

@@ -1,147 +0,0 @@
-package ffmpeg
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"os"
-	"os/exec"
-	"strconv"
-	"strings"
-
-	"github.com/gtsteffaniak/go-logger/logger"
-)
-
-// VideoService handles video preview operations with ffmpeg
-type VideoService struct {
-	ffmpegPath  string
-	ffprobePath string
-	debug       bool
-	semaphore   chan struct{}
-}
-
-// NewVideoService creates a new video service instance
-func NewVideoService(ffmpegPath, ffprobePath string, maxConcurrent int, debug bool) *VideoService {
-	return &VideoService{
-		ffmpegPath:  ffmpegPath,
-		ffprobePath: ffprobePath,
-		debug:       debug,
-		semaphore:   make(chan struct{}, maxConcurrent),
-	}
-}
-
-func (s *VideoService) acquire(ctx context.Context) error {
-	select {
-	case s.semaphore <- struct{}{}:
-		return nil
-	case <-ctx.Done():
-		return ctx.Err()
-	}
-}
-
-func (s *VideoService) release() {
-	<-s.semaphore
-}
-
-// GenerateVideoPreview generates a single preview image from a video using ffmpeg.
-// videoPath: path to the input video file.
-// outputPath: path where the generated preview image will be saved (e.g., "/tmp/preview.jpg").
-// seekTime: how many seconds into the video to seek before capturing the frame.
-func (s *VideoService) GenerateVideoPreview(videoPath, outputPath string, percentageSeek int) ([]byte, error) {
-	if err := s.acquire(context.Background()); err != nil {
-		return nil, err
-	}
-	defer s.release()
-
-	// Step 1: Get video duration from the container format
-	probeCmd := exec.Command(
-		s.ffprobePath,
-		"-v", "error",
-		// Use format=duration for better compatibility
-		"-show_entries", "format=duration",
-		"-of", "default=noprint_wrappers=1:nokey=1",
-		videoPath,
-	)
-
-	var probeOut bytes.Buffer
-	probeCmd.Stdout = &probeOut
-	if s.debug {
-		probeCmd.Stderr = os.Stderr
-	}
-	if err := probeCmd.Run(); err != nil {
-		logger.Errorf("ffprobe command failed on file '%v' : %v", videoPath, err)
-		return nil, fmt.Errorf("ffprobe failed: %w", err)
-	}
-
-	durationStr := strings.TrimSpace(probeOut.String())
-	if durationStr == "" || durationStr == "N/A" {
-		logger.Errorf("could not determine video duration for file '%v' using duration info '%v'", videoPath, durationStr)
-		return nil, fmt.Errorf("could not determine video duration")
-	}
-
-	durationFloat, err := strconv.ParseFloat(durationStr, 64)
-	if err != nil {
-		// The original error you saw would be caught here if "N/A" was still the output
-		return nil, fmt.Errorf("invalid duration: %v", err)
-	}
-
-	if durationFloat <= 0 {
-		return nil, fmt.Errorf("video duration must be positive")
-	}
-
-	// Step 2: Get the duration of the video in whole seconds
-	duration := int(durationFloat)
-
-	// Step 3: Calculate seek time based on percentageSeek (percentage value)
-	seekSeconds := duration * percentageSeek / 100
-
-	// Step 4: Convert seekSeconds to string for ffmpeg command
-	seekTime := strconv.Itoa(seekSeconds)
-
-	// Step 5: Extract frame at seek time
-	cmd := exec.Command(
-		s.ffmpegPath,
-		"-ss", seekTime,
-		"-i", videoPath,
-		"-frames:v", "1",
-		"-q:v", "10",
-		"-y", // overwrite output
-		outputPath,
-	)
-
-	if s.debug {
-		cmd.Stdout = os.Stdout
-		cmd.Stderr = os.Stderr
-	}
-	err = cmd.Run()
-	if err != nil {
-		return nil, fmt.Errorf("ffmpeg command failed on file '%v' : %w", videoPath, err)
-	}
-	return os.ReadFile(outputPath)
-}
-
-// GetVideoDuration extracts the duration of a video file using ffprobe
-func GetVideoDuration(ffprobePath string, videoPath string) (float64, error) {
-	cmd := exec.Command(ffprobePath,
-		"-v", "error",
-		"-show_entries", "format=duration",
-		"-of", "default=noprint_wrappers=1:nokey=1",
-		videoPath)
-
-	output, err := cmd.Output()
-	if err != nil {
-		return 0, fmt.Errorf("ffprobe failed: %w", err)
-	}
-
-	durationStr := strings.TrimSpace(string(output))
-	if durationStr == "" || durationStr == "N/A" {
-		return 0, fmt.Errorf("could not determine video duration")
-	}
-
-	duration, err := strconv.ParseFloat(durationStr, 64)
-	if err != nil {
-		return 0, fmt.Errorf("invalid duration: %v", err)
-	}
-
-	return duration, nil
-}

backend/go.mod

@@ -1,122 +1,91 @@
 module github.com/gtsteffaniak/filebrowser/backend
 
-go 1.25.0
+go 1.24.2
 
 require (
-	github.com/adrium/goheif v0.0.0-20230113233934-ca402e77a786
 	github.com/asdine/storm/v3 v3.2.1
-	github.com/coreos/go-oidc/v3 v3.15.0
+	github.com/coreos/go-oidc/v3 v3.14.1
+	github.com/disintegration/imaging v1.6.2
 	github.com/dsoprea/go-exif/v3 v3.0.1
-	github.com/gen2brain/go-fitz v1.24.15
-	github.com/go-playground/validator/v10 v10.27.0
-	github.com/goccy/go-yaml v1.18.0
+	github.com/go-playground/validator/v10 v10.26.0
+	github.com/goccy/go-yaml v1.17.1
 	github.com/golang-jwt/jwt/v4 v4.5.2
 	github.com/google/go-cmp v0.7.0
 	github.com/gtsteffaniak/go-cache v0.0.0-20250521142451-edc77dfcb063
 	github.com/gtsteffaniak/go-logger v0.1.2
-	github.com/kovidgoyal/imaging v1.6.4
 	github.com/pquerna/otp v1.5.0
-	github.com/spf13/afero v1.15.0
-	github.com/stretchr/testify v1.11.1
+	github.com/shirou/gopsutil/v3 v3.24.5
+	github.com/spf13/afero v1.14.0
+	github.com/stretchr/testify v1.10.0
 	github.com/swaggo/http-swagger v1.3.4
-	github.com/swaggo/swag v1.16.6
-	golang.org/x/crypto v0.42.0
-	golang.org/x/image v0.31.0
-	golang.org/x/mod v0.28.0
-	golang.org/x/oauth2 v0.31.0
-	golang.org/x/sys v0.36.0
-	golang.org/x/time v0.13.0
+	github.com/swaggo/swag v1.16.4
+	golang.org/x/crypto v0.38.0
+	golang.org/x/image v0.27.0
+	golang.org/x/oauth2 v0.30.0
+	golang.org/x/sys v0.33.0
 	gopkg.in/yaml.v3 v3.0.1
 )
 
 require (
 	4d63.com/gocheckcompilerdirectives v1.3.0 // indirect
 	4d63.com/gochecknoglobals v0.2.2 // indirect
-	codeberg.org/chavacava/garif v0.2.0 // indirect
-	dario.cat/mergo v1.0.2 // indirect
-	dev.gaijin.team/go/exhaustruct/v4 v4.0.0 // indirect
-	dev.gaijin.team/go/golib v0.6.0 // indirect
-	github.com/4meepo/tagalign v1.4.3 // indirect
-	github.com/Abirdcfly/dupword v0.1.6 // indirect
-	github.com/AlwxSin/noinlineerr v1.0.5 // indirect
-	github.com/Antonboom/errname v1.1.0 // indirect
-	github.com/Antonboom/nilnil v1.1.0 // indirect
-	github.com/Antonboom/testifylint v1.6.1 // indirect
-	github.com/BurntSushi/toml v1.5.0 // indirect
+	github.com/4meepo/tagalign v1.4.2 // indirect
+	github.com/Abirdcfly/dupword v0.1.3 // indirect
+	github.com/Antonboom/errname v1.0.0 // indirect
+	github.com/Antonboom/nilnil v1.0.1 // indirect
+	github.com/Antonboom/testifylint v1.5.2 // indirect
+	github.com/BurntSushi/toml v1.4.1-0.20240526193622-a339e1f7089c // indirect
+	github.com/Crocmagnon/fatcontext v0.7.1 // indirect
 	github.com/Djarvur/go-err113 v0.0.0-20210108212216-aea10b59be24 // indirect
+	github.com/GaijinEntertainment/go-exhaustruct/v3 v3.3.1 // indirect
 	github.com/KyleBanks/depth v1.2.1 // indirect
-	github.com/Masterminds/semver/v3 v3.3.1 // indirect
+	github.com/Masterminds/semver/v3 v3.3.0 // indirect
 	github.com/OpenPeeDeeP/depguard/v2 v2.2.1 // indirect
-	github.com/air-verse/air v1.63.0 // indirect
-	github.com/alecthomas/chroma/v2 v2.20.0 // indirect
 	github.com/alecthomas/go-check-sumtype v0.3.1 // indirect
-	github.com/alexkohler/nakedret/v2 v2.0.6 // indirect
+	github.com/alexkohler/nakedret/v2 v2.0.5 // indirect
 	github.com/alexkohler/prealloc v1.0.0 // indirect
-	github.com/alfatraining/structtag v1.0.0 // indirect
 	github.com/alingse/asasalint v0.0.11 // indirect
-	github.com/alingse/nilnesserr v0.2.0 // indirect
-	github.com/ashanbrown/forbidigo/v2 v2.1.0 // indirect
-	github.com/ashanbrown/makezero/v2 v2.0.1 // indirect
-	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
+	github.com/alingse/nilnesserr v0.1.2 // indirect
+	github.com/ashanbrown/forbidigo v1.6.0 // indirect
+	github.com/ashanbrown/makezero v1.2.0 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
-	github.com/bep/godartsass/v2 v2.5.0 // indirect
-	github.com/bep/golibsass v1.2.0 // indirect
 	github.com/bkielbasa/cyclop v1.2.3 // indirect
 	github.com/blizzy78/varnamelen v0.8.0 // indirect
-	github.com/bombsimon/wsl/v4 v4.7.0 // indirect
-	github.com/bombsimon/wsl/v5 v5.1.1 // indirect
-	github.com/boombuler/barcode v1.1.0 // indirect
-	github.com/breml/bidichk v0.3.3 // indirect
-	github.com/breml/errchkjson v0.4.1 // indirect
-	github.com/butuzov/ireturn v0.4.0 // indirect
+	github.com/bombsimon/wsl/v4 v4.5.0 // indirect
+	github.com/boombuler/barcode v1.0.2 // indirect
+	github.com/breml/bidichk v0.3.2 // indirect
+	github.com/breml/errchkjson v0.4.0 // indirect
+	github.com/butuzov/ireturn v0.3.1 // indirect
 	github.com/butuzov/mirror v1.3.0 // indirect
-	github.com/catenacyber/perfsprint v0.9.1 // indirect
-	github.com/ccojocar/zxcvbn-go v1.0.4 // indirect
+	github.com/catenacyber/perfsprint v0.8.2 // indirect
+	github.com/ccojocar/zxcvbn-go v1.0.2 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/charithe/durationcheck v0.0.10 // indirect
-	github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc // indirect
-	github.com/charmbracelet/lipgloss v1.1.0 // indirect
-	github.com/charmbracelet/x/ansi v0.8.0 // indirect
-	github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd // indirect
-	github.com/charmbracelet/x/term v0.2.1 // indirect
-	github.com/ckaznocha/intrange v0.3.1 // indirect
+	github.com/chavacava/garif v0.1.0 // indirect
+	github.com/ckaznocha/intrange v0.3.0 // indirect
 	github.com/cpuguy83/go-md2man/v2 v2.0.6 // indirect
-	github.com/creack/pty v1.1.24 // indirect
 	github.com/curioswitch/go-reassign v0.3.0 // indirect
-	github.com/daixiang0/gci v0.13.7 // indirect
-	github.com/dave/dst v0.27.3 // indirect
+	github.com/daixiang0/gci v0.13.5 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/denis-tingaikin/go-header v0.5.0 // indirect
-	github.com/dlclark/regexp2 v1.11.5 // 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/ebitengine/purego v0.8.4 // indirect
 	github.com/ettle/strcase v0.2.0 // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fatih/structtag v1.2.0 // indirect
-	github.com/firefart/nonamedreturns v1.0.6 // indirect
-	github.com/fsnotify/fsnotify v1.9.0 // indirect
+	github.com/firefart/nonamedreturns v1.0.5 // indirect
+	github.com/fsnotify/fsnotify v1.5.4 // indirect
 	github.com/fzipp/gocyclo v0.6.0 // indirect
-	github.com/gabriel-vasile/mimetype v1.4.10 // indirect
-	github.com/ghostiam/protogetter v0.3.15 // indirect
-	github.com/go-critic/go-critic v0.13.0 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.9 // indirect
+	github.com/ghostiam/protogetter v0.3.9 // indirect
+	github.com/go-critic/go-critic v0.12.0 // indirect
 	github.com/go-errors/errors v1.5.1 // indirect
-	github.com/go-jose/go-jose/v4 v4.1.2 // indirect
-	github.com/go-openapi/jsonpointer v0.22.0 // indirect
-	github.com/go-openapi/jsonreference v0.21.1 // indirect
+	github.com/go-jose/go-jose/v4 v4.1.0 // indirect
+	github.com/go-ole/go-ole v1.3.0 // indirect
+	github.com/go-openapi/jsonpointer v0.21.1 // 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.24.1 // indirect
-	github.com/go-openapi/swag/cmdutils v0.24.0 // indirect
-	github.com/go-openapi/swag/conv v0.24.0 // indirect
-	github.com/go-openapi/swag/fileutils v0.24.0 // indirect
-	github.com/go-openapi/swag/jsonname v0.24.0 // indirect
-	github.com/go-openapi/swag/jsonutils v0.24.0 // indirect
-	github.com/go-openapi/swag/loading v0.24.0 // indirect
-	github.com/go-openapi/swag/mangling v0.24.0 // indirect
-	github.com/go-openapi/swag/netutils v0.24.0 // indirect
-	github.com/go-openapi/swag/stringutils v0.24.0 // indirect
-	github.com/go-openapi/swag/typeutils v0.24.0 // indirect
-	github.com/go-openapi/swag/yamlutils v0.24.0 // indirect
+	github.com/go-openapi/swag v0.23.1 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
 	github.com/go-playground/universal-translator v0.18.1 // indirect
 	github.com/go-toolsmith/astcast v1.1.0 // indirect
@@ -126,23 +95,20 @@ require (
 	github.com/go-toolsmith/astp v1.1.0 // indirect
 	github.com/go-toolsmith/strparse v1.1.0 // indirect
 	github.com/go-toolsmith/typep v1.1.0 // indirect
-	github.com/go-viper/mapstructure/v2 v2.4.0 // indirect
+	github.com/go-viper/mapstructure/v2 v2.2.1 // indirect
 	github.com/go-xmlfmt/xmlfmt v1.1.3 // indirect
 	github.com/gobwas/glob v0.2.3 // indirect
 	github.com/gofrs/flock v0.12.1 // indirect
-	github.com/gohugoio/hugo v0.149.1 // indirect
-	github.com/golang/geo v0.0.0-20250909101022-21d0664d86be // indirect
+	github.com/golang/geo v0.0.0-20250516193853-92f93c4cb289 // indirect
 	github.com/golang/protobuf v1.5.3 // indirect
 	github.com/golangci/dupl v0.0.0-20250308024227-f665c8d69b32 // indirect
 	github.com/golangci/go-printf-func-name v0.1.0 // indirect
 	github.com/golangci/gofmt v0.0.0-20250106114630-d62b90e6713d // indirect
-	github.com/golangci/golangci-lint/v2 v2.4.0 // indirect
-	github.com/golangci/golines v0.0.0-20250217134842-442fd0091d95 // indirect
-	github.com/golangci/misspell v0.7.0 // indirect
-	github.com/golangci/plugin-module-register v0.1.2 // indirect
+	github.com/golangci/golangci-lint v1.64.8 // indirect
+	github.com/golangci/misspell v0.6.0 // indirect
+	github.com/golangci/plugin-module-register v0.1.1 // indirect
 	github.com/golangci/revgrep v0.8.0 // indirect
-	github.com/golangci/swaggoswag v0.0.0-20250504205917-77f2aca3143e // indirect
-	github.com/golangci/unconvert v0.0.0-20250410112200-a129a6e6413e // indirect
+	github.com/golangci/unconvert v0.0.0-20240309020433-c5143eacb3ed // indirect
 	github.com/gordonklaus/ineffassign v0.1.0 // indirect
 	github.com/gostaticanalysis/analysisutil v0.7.1 // indirect
 	github.com/gostaticanalysis/comment v1.5.0 // indirect
@@ -154,31 +120,27 @@ require (
 	github.com/hashicorp/hcl v1.0.0 // indirect
 	github.com/hexops/gotextdiff v1.0.3 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
-	github.com/jgautheron/goconst v1.8.2 // indirect
+	github.com/jgautheron/goconst v1.7.1 // indirect
 	github.com/jingyugao/rowserrcheck v1.1.1 // indirect
-	github.com/jjti/go-spancheck v0.6.5 // indirect
+	github.com/jjti/go-spancheck v0.6.4 // indirect
 	github.com/josharian/intern v1.0.0 // indirect
 	github.com/julz/importas v0.2.0 // indirect
-	github.com/jupiterrider/ffi v0.5.1 // indirect
 	github.com/karamaru-alpha/copyloopvar v1.2.1 // indirect
 	github.com/kisielk/errcheck v1.9.0 // indirect
 	github.com/kkHAIKE/contextcheck v1.1.6 // indirect
 	github.com/kulti/thelper v0.6.3 // indirect
-	github.com/kunwardeep/paralleltest v1.0.14 // indirect
+	github.com/kunwardeep/paralleltest v1.0.10 // indirect
 	github.com/lasiar/canonicalheader v1.1.2 // indirect
-	github.com/ldez/exptostd v0.4.4 // indirect
-	github.com/ldez/gomoddirectives v0.7.0 // indirect
-	github.com/ldez/grignotin v0.10.0 // indirect
+	github.com/ldez/exptostd v0.4.2 // indirect
+	github.com/ldez/gomoddirectives v0.6.1 // indirect
+	github.com/ldez/grignotin v0.9.0 // indirect
 	github.com/ldez/tagliatelle v0.7.1 // indirect
-	github.com/ldez/usetesting v0.5.0 // indirect
+	github.com/ldez/usetesting v0.4.2 // indirect
 	github.com/leodido/go-urn v1.4.0 // indirect
 	github.com/leonklingele/grouper v1.1.2 // indirect
-	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
-	github.com/macabu/inamedparam v0.2.0 // indirect
+	github.com/macabu/inamedparam v0.1.3 // indirect
 	github.com/magiconair/properties v1.8.6 // indirect
 	github.com/mailru/easyjson v0.9.0 // indirect
-	github.com/manuelarte/embeddedstructfieldcheck v0.3.0 // indirect
-	github.com/manuelarte/funcorder v0.5.0 // indirect
 	github.com/maratori/testableexamples v1.0.0 // indirect
 	github.com/maratori/testpackage v1.1.1 // indirect
 	github.com/matoous/godox v1.1.0 // indirect
@@ -186,24 +148,25 @@ require (
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect
-	github.com/mgechev/revive v1.11.0 // indirect
+	github.com/mgechev/revive v1.7.0 // indirect
 	github.com/mitchellh/go-homedir v1.1.0 // indirect
-	github.com/mitchellh/mapstructure v1.5.1-0.20231216201459-8508981c8b6c // indirect
+	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/moricho/tparallel v0.3.2 // indirect
-	github.com/muesli/termenv v0.16.0 // indirect
 	github.com/nakabonne/nestif v0.3.1 // indirect
 	github.com/nishanths/exhaustive v0.12.0 // indirect
 	github.com/nishanths/predeclared v0.2.2 // indirect
-	github.com/nunnatsa/ginkgolinter v0.20.0 // indirect
+	github.com/nunnatsa/ginkgolinter v0.19.1 // indirect
+	github.com/olekukonko/tablewriter v0.0.5 // indirect
 	github.com/pelletier/go-toml v1.9.5 // indirect
-	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.3 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/polyfloyd/go-errorlint v1.8.0 // indirect
+	github.com/polyfloyd/go-errorlint v1.7.1 // indirect
+	github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect
 	github.com/prometheus/client_golang v1.12.1 // indirect
 	github.com/prometheus/client_model v0.2.0 // indirect
 	github.com/prometheus/common v0.32.1 // indirect
 	github.com/prometheus/procfs v0.7.3 // indirect
-	github.com/quasilyte/go-ruleguard v0.4.4 // indirect
+	github.com/quasilyte/go-ruleguard v0.4.3-0.20240823090925-0fe6f58b47b1 // indirect
 	github.com/quasilyte/go-ruleguard/dsl v0.3.22 // indirect
 	github.com/quasilyte/gogrep v0.5.0 // indirect
 	github.com/quasilyte/regex/syntax v0.0.0-20210819130434-b3f0c404a727 // indirect
@@ -212,22 +175,22 @@ require (
 	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/rogpeppe/go-internal v1.14.1 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
-	github.com/rwcarlsen/goexif v0.0.0-20190401172101-9e8deecbddbd // indirect
-	github.com/ryancurrah/gomodguard v1.4.1 // indirect
+	github.com/ryancurrah/gomodguard v1.3.5 // indirect
 	github.com/ryanrolds/sqlclosecheck v0.5.1 // indirect
 	github.com/sanposhiho/wastedassign/v2 v2.1.0 // indirect
-	github.com/santhosh-tekuri/jsonschema/v6 v6.0.2 // indirect
+	github.com/santhosh-tekuri/jsonschema/v6 v6.0.1 // indirect
 	github.com/sashamelentyev/interfacebloat v1.1.0 // indirect
-	github.com/sashamelentyev/usestdlibvars v1.29.0 // indirect
-	github.com/securego/gosec/v2 v2.22.7 // indirect
+	github.com/sashamelentyev/usestdlibvars v1.28.0 // indirect
+	github.com/securego/gosec/v2 v2.22.2 // indirect
 	github.com/sirupsen/logrus v1.9.3 // indirect
 	github.com/sivchari/containedctx v1.0.3 // indirect
-	github.com/sonatard/noctx v0.4.0 // indirect
+	github.com/sivchari/tenv v1.12.1 // indirect
+	github.com/sonatard/noctx v0.1.0 // indirect
 	github.com/sourcegraph/go-diff v0.7.0 // indirect
-	github.com/spf13/cast v1.9.2 // indirect
+	github.com/spf13/cast v1.5.0 // indirect
 	github.com/spf13/cobra v1.9.1 // indirect
 	github.com/spf13/jwalterweatherman v1.1.0 // indirect
-	github.com/spf13/pflag v1.0.7 // indirect
+	github.com/spf13/pflag v1.0.6 // indirect
 	github.com/spf13/viper v1.12.0 // indirect
 	github.com/ssgreg/nlreturn/v2 v2.2.1 // indirect
 	github.com/stbenjam/no-sprintf-host-port v0.2.0 // indirect
@@ -235,47 +198,45 @@ require (
 	github.com/subosito/gotenv v1.4.1 // indirect
 	github.com/swaggo/files v1.0.1 // indirect
 	github.com/tdakkota/asciicheck v0.4.1 // indirect
-	github.com/tdewolff/parse/v2 v2.8.3 // indirect
-	github.com/tetafro/godot v1.5.1 // indirect
-	github.com/timakin/bodyclose v0.0.0-20241222091800-1db5c5ca4d67 // indirect
-	github.com/timonwong/loggercheck v0.11.0 // indirect
-	github.com/tomarrell/wrapcheck/v2 v2.11.0 // indirect
+	github.com/tetafro/godot v1.5.0 // indirect
+	github.com/timakin/bodyclose v0.0.0-20241017074812-ed6a65f985e3 // indirect
+	github.com/timonwong/loggercheck v0.10.1 // indirect
+	github.com/tomarrell/wrapcheck/v2 v2.10.0 // indirect
 	github.com/tommy-muehle/go-mnd/v2 v2.5.1 // indirect
 	github.com/ultraware/funlen v0.2.0 // indirect
 	github.com/ultraware/whitespace v0.2.0 // indirect
 	github.com/urfave/cli/v2 v2.3.0 // indirect
 	github.com/uudashr/gocognit v1.2.0 // indirect
-	github.com/uudashr/iface v1.4.1 // indirect
-	github.com/xen0n/gosmopolitan v1.3.0 // indirect
-	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
+	github.com/uudashr/iface v1.3.1 // indirect
+	github.com/xen0n/gosmopolitan v1.2.2 // indirect
 	github.com/yagipy/maintidx v1.0.0 // indirect
 	github.com/yeya24/promlinter v0.3.0 // indirect
 	github.com/ykadowak/zerologlint v0.1.5 // indirect
+	github.com/yusufpapurcu/wmi v1.2.4 // indirect
 	gitlab.com/bosi/decorder v0.4.2 // indirect
-	go-simpler.org/musttag v0.13.1 // indirect
-	go-simpler.org/sloglint v0.11.1 // indirect
-	go.augendre.info/arangolint v0.2.0 // indirect
-	go.augendre.info/fatcontext v0.8.0 // indirect
-	go.etcd.io/bbolt v1.4.3 // indirect
+	go-simpler.org/musttag v0.13.0 // indirect
+	go-simpler.org/sloglint v0.9.0 // indirect
+	go.etcd.io/bbolt v1.4.0 // indirect
+	go.uber.org/atomic v1.7.0 // indirect
 	go.uber.org/automaxprocs v1.6.0 // indirect
-	go.uber.org/multierr v1.10.0 // indirect
-	go.uber.org/zap v1.27.0 // indirect
-	golang.org/x/exp/typeparams v0.0.0-20250620022241-b7579e27df2b // indirect
-	golang.org/x/net v0.44.0 // indirect
-	golang.org/x/sync v0.17.0 // indirect
-	golang.org/x/text v0.29.0 // indirect
-	golang.org/x/tools v0.36.0 // indirect
-	google.golang.org/protobuf v1.36.8 // indirect
+	go.uber.org/multierr v1.6.0 // indirect
+	go.uber.org/zap v1.24.0 // indirect
+	golang.org/x/exp/typeparams v0.0.0-20250210185358-939b2ce775ac // indirect
+	golang.org/x/mod v0.24.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
+	golang.org/x/sync v0.14.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
+	golang.org/x/tools v0.33.0 // indirect
+	google.golang.org/protobuf v1.36.5 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	honnef.co/go/tools v0.6.1 // indirect
-	mvdan.cc/gofumpt v0.8.0 // indirect
-	mvdan.cc/unparam v0.0.0-20250301125049-0df0534333a4 // indirect
+	mvdan.cc/gofumpt v0.7.0 // indirect
+	mvdan.cc/unparam v0.0.0-20240528143540-8a5130ca722f // indirect
 	sigs.k8s.io/yaml v1.3.0 // indirect
 )
 
 tool (
-	github.com/air-verse/air
-	github.com/golangci/golangci-lint/v2/cmd/golangci-lint
+	github.com/golangci/golangci-lint/cmd/golangci-lint
 	github.com/swaggo/swag/cmd/swag
 )

backend/http/access.go

@@ -1,267 +0,0 @@
-package http
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/http"
-
-	"github.com/gtsteffaniak/filebrowser/backend/indexing"
-	"github.com/gtsteffaniak/go-logger/logger"
-)
-
-type GroupListResponse struct {
-	Groups []string `json:"groups"`
-}
-
-// accessGetHandler lists all access rules or retrieves a specific rule.
-// @Summary List access rules
-// @Description Lists access rules. Can be filtered by source, path, user, or group. Can also be grouped by user or group.
-// @Tags Access
-// @Accept json
-// @Produce json
-// @Param source query string false "Source name (e.g. 'default')"
-// @Param path query string false "Index path (e.g. /secret)"
-// @Param user query string false "Username to filter rules for"
-// @Param group query string false "Group name to filter rules for"
-// @Success 200 {object} object "Varies based on query. Can be access.FrontendAccessRule (when source and path specified), []access.PrincipalRule, map[string][]access.PrincipalRule, or map[string]access.FrontendAccessRule"
-// @Failure 400 {object} map[string]string "Bad request"
-// @Failure 500 {object} map[string]string "Internal server error"
-// @Router /api/access [get]
-func accessGetHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
-	sourceName := r.URL.Query().Get("source")
-	indexPath := r.URL.Query().Get("path")
-	user := r.URL.Query().Get("user")
-	group := r.URL.Query().Get("group")
-
-	var sourcePath string
-	if sourceName != "" {
-		index := indexing.GetIndex(sourceName)
-		if index == nil {
-			return http.StatusBadRequest, fmt.Errorf("source not found: %s", sourceName)
-		}
-		sourcePath = index.Path
-	}
-
-	// Return rules based on input parameters
-	if user != "" {
-		rules := store.Access.GetRulesForUser(sourcePath, user)
-		return renderJSON(w, r, rules)
-	}
-	if group != "" {
-		rules := store.Access.GetRulesForGroup(sourcePath, group)
-		return renderJSON(w, r, rules)
-	}
-
-	if sourceName == "" {
-		return http.StatusBadRequest, fmt.Errorf("source parameter is required for this query")
-	}
-
-	if indexPath != "" {
-		rule, _ := store.Access.GetFrontendRules(sourcePath, indexPath)
-		return renderJSON(w, r, rule)
-	}
-
-	// List all rules for the source by default
-	all, err := store.Access.GetAllRules(sourcePath)
-	if err != nil {
-		logger.Errorf("failed to retrieve access rules: %v", err)
-		return http.StatusInternalServerError, fmt.Errorf("failed to retrieve access rules: %w", err)
-	}
-	return renderJSON(w, r, all)
-}
-
-// accessPostHandler adds or updates an access rule.
-// @Summary Add or update access rule
-// @Description Add or update an access rule for a sourcePath and indexPath.
-// @Tags Access
-// @Accept json
-// @Produce json
-// @Param source query string true "Source path prefix (e.g. mnt/storage)"
-// @Param path query string true "Index path (e.g. /secret)"
-// @Param body body object{allow=bool,ruleCategory=string,value=string} true "Rule details: allow (true/false), ruleCategory (user/group), value (username or groupname)"
-// @Success 200 {object} map[string]string "Rule added or updated"
-// @Failure 400 {object} map[string]string "Bad request"
-// @Failure 500 {object} map[string]string "Internal server error"
-// @Router /api/access [post]
-func accessPostHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
-	sourceName := r.URL.Query().Get("source")
-	indexPath := r.URL.Query().Get("path")
-	index := indexing.GetIndex(sourceName)
-	if index == nil {
-		return http.StatusBadRequest, fmt.Errorf("source not found: %s", sourceName)
-	}
-	var body struct {
-		Allow        bool   `json:"allow"`
-		RuleCategory string `json:"ruleCategory"`
-		Value        string `json:"value"`
-	}
-	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-		return http.StatusBadRequest, fmt.Errorf("invalid request body: %w", err)
-	}
-
-	if indexPath == "" || body.RuleCategory == "" || (body.RuleCategory != "all" && body.Value == "") {
-		return http.StatusBadRequest, fmt.Errorf("path, ruleCategory, and value are required, unless ruleCategory is 'all'")
-	}
-	var err error
-	if body.Allow {
-		switch body.RuleCategory {
-		case "user":
-			err = store.Access.AllowUser(index.Path, indexPath, body.Value)
-		case "group":
-			err = store.Access.AllowGroup(index.Path, indexPath, body.Value)
-		default:
-			return http.StatusBadRequest, fmt.Errorf("invalid ruleCategory: must be 'user' or 'group'")
-		}
-	} else {
-		switch body.RuleCategory {
-		case "user":
-			err = store.Access.DenyUser(index.Path, indexPath, body.Value)
-		case "group":
-			err = store.Access.DenyGroup(index.Path, indexPath, body.Value)
-		case "all":
-			err = store.Access.DenyAll(index.Path, indexPath)
-		default:
-			return http.StatusBadRequest, fmt.Errorf("invalid ruleCategory: must be 'user', 'group', or 'all'")
-		}
-	}
-	if err != nil {
-		logger.Errorf("failed to add or update rule: %v", err)
-		return http.StatusInternalServerError, fmt.Errorf("failed to add or update rule: %w", err)
-	}
-	return renderJSON(w, r, map[string]string{"message": "rule added or updated"})
-}
-
-// accessDeleteHandler deletes a single user or group from a rule.
-// @Summary Delete access rule entry
-// @Description Delete a user or group from an allow or deny list for a sourcePath and indexPath.
-// @Tags Access
-// @Accept json
-// @Produce json
-// @Param source query string true "Source path prefix (e.g. mnt/storage)"
-// @Param path query string true "Index path (e.g. /secret)"
-// @Param ruleType query string true "Rule type (allow or deny)"
-// @Param ruleCategory query string true "Rule category (user or group)"
-// @Param value query string true "Username or groupname to remove"
-// @Success 200 {object} map[string]string "Rule entry deleted"
-// @Failure 404 {object} map[string]string "Not found"
-// @Failure 400 {object} map[string]string "Bad request"
-// @Failure 500 {object} map[string]string "Internal server error"
-// @Router /api/access [delete]
-func accessDeleteHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
-	sourceName := r.URL.Query().Get("source")
-	indexPath := r.URL.Query().Get("path")
-	index := indexing.GetIndex(sourceName)
-	if index == nil {
-		return 500, fmt.Errorf("source not found: %s", sourceName)
-	}
-
-	ruleType := r.URL.Query().Get("ruleType")
-	ruleCategory := r.URL.Query().Get("ruleCategory")
-	value := r.URL.Query().Get("value")
-	allow := ruleType == "allow"
-
-	if indexPath == "" || ruleCategory == "" || (ruleCategory != "all" && value == "") {
-		return http.StatusBadRequest, fmt.Errorf("path, ruleCategory, and value are required, unless ruleCategory is 'all'")
-	}
-
-	var found bool
-	var err error
-	if allow {
-		switch ruleCategory {
-		case "user":
-			found, err = store.Access.RemoveAllowUser(index.Path, indexPath, value)
-		case "group":
-			found, err = store.Access.RemoveAllowGroup(index.Path, indexPath, value)
-		}
-	} else {
-		switch ruleCategory {
-		case "user":
-			found, err = store.Access.RemoveDenyUser(index.Path, indexPath, value)
-		case "group":
-			found, err = store.Access.RemoveDenyGroup(index.Path, indexPath, value)
-		case "all":
-			found, err = store.Access.RemoveDenyAll(index.Path, indexPath)
-		}
-	}
-	if !found {
-		if err != nil {
-			logger.Errorf("failed to remove rule entry: %v", err)
-		}
-		return http.StatusNotFound, fmt.Errorf("entry not found in rule")
-	}
-
-	return renderJSON(w, r, map[string]string{"message": "rule entry deleted"})
-}
-
-// groupGetHandler retrieves all groups or groups for a specific user.
-// @Summary Get all groups or groups for a user
-// @Description Returns a list of all groups or the groups for a specific user.
-// @Tags Access
-// @Accept json
-// @Produce json
-// @Param user query string false "User name"
-// @Success 200 {object} GroupListResponse "Object containing a list of groups"
-// @Failure 403 {object} map[string]string "Forbidden"
-// @Router /api/access/groups [get]
-func groupGetHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
-	if !d.user.Permissions.Admin {
-		return http.StatusForbidden, nil
-	}
-	user := r.URL.Query().Get("user")
-	if user != "" {
-		groups := store.Access.GetUserGroups(user)
-		return renderJSON(w, r, &GroupListResponse{Groups: groups})
-	}
-	groups := store.Access.GetAllGroups()
-	return renderJSON(w, r, &GroupListResponse{Groups: groups})
-}
-
-// groupPostHandler adds a user to a group.
-// @Summary Add a user to a group
-// @Description Adds a user to a group.
-// @Tags Access
-// @Accept json
-// @Produce json
-// @Param group query string true "Group name"
-// @Param user query string true "User name"
-// @Success 200 "User added to group successfully"
-// @Failure 403 {object} map[string]string "Forbidden"
-// @Failure 500 {object} map[string]string "Internal Server Error"
-// @Router /api/access/group [post]
-func groupPostHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
-	if !d.user.Permissions.Admin {
-		return http.StatusForbidden, nil
-	}
-	group := r.URL.Query().Get("group")
-	user := r.URL.Query().Get("user")
-	err := store.Access.AddUserToGroup(group, user)
-	if err != nil {
-		return http.StatusInternalServerError, err
-	}
-	return http.StatusOK, nil
-}
-
-// groupDeleteHandler removes a user from a group.
-// @Summary Remove a user from a group
-// @Description Removes a user from a group.
-// @Tags Access
-// @Accept json
-// @Produce json
-// @Param group query string true "Group name"
-// @Param user query string true "User name"
-// @Success 200 "User removed from group successfully"
-// @Failure 403 {object} map[string]string "Forbidden"
-// @Failure 500 {object} map[string]string "Internal Server Error"
-// @Router /api/access/group [delete]
-func groupDeleteHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
-	if !d.user.Permissions.Admin {
-		return http.StatusForbidden, nil
-	}
-	group := r.URL.Query().Get("group")
-	user := r.URL.Query().Get("user")
-	err := store.Access.RemoveUserFromGroup(group, user)
-	if err != nil {
-		return http.StatusInternalServerError, err
-	}
-	return http.StatusOK, nil
-}

backend/http/api.go

@@ -20,12 +20,12 @@ import (
 // @Param name query string true "Name of the API key"
 // @Param days query string true "Duration of the API key in days"
 // @Param permissions query string true "Permissions for the API key (comma-separated)"
-// @Success 200 {object} HttpResponse "Token created successfully, response contains json object with token key"
+// @Success 200 {object} HttpResponse "Token created successfully, resoponse contains json object with token key"
 // @Failure 400 {object} map[string]string "Bad request"
 // @Failure 404 {object} map[string]string "Not found"
 // @Failure 409 {object} map[string]string "Conflict"
 // @Failure 500 {object} map[string]string "Internal server error"
-// @Router /api/auth/token [put]
+// @Router /api/createApiKey [post]
 func createApiKeyHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
 	name := r.URL.Query().Get("name")
 	durationStr := r.URL.Query().Get("days")
@@ -85,7 +85,7 @@ func createApiKeyHandler(w http.ResponseWriter, r *http.Request, d *requestConte
 // @Success 200 {object} HttpResponse "API key deleted successfully"
 // @Failure 404 {object} map[string]string "Not found"
 // @Failure 500 {object} map[string]string "Internal server error"
-// @Router /api/auth/token [delete]
+// @Router /api/deleteApiKey [delete]
 func deleteApiKeyHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
 	name := r.URL.Query().Get("name")
 	if !d.user.Permissions.Api {
@@ -127,7 +127,7 @@ type AuthTokenMin struct {
 // @Success 200 {object} AuthTokenMin "List of API keys or specific key details"
 // @Failure 404 {object} map[string]string "Not found"
 // @Failure 500 {object} map[string]string "Internal server error"
-// @Router /api/auth/tokens [get]
+// @Router /api/listApiKeys [get]
 func listApiKeysHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
 	key := r.URL.Query().Get("name")
 	if !d.user.Permissions.Api {

backend/http/auth.go

@@ -13,7 +13,6 @@ import (
 	"github.com/golang-jwt/jwt/v4/request"
 	"golang.org/x/crypto/bcrypt"
 
-	"github.com/gtsteffaniak/filebrowser/backend/auth"
 	"github.com/gtsteffaniak/filebrowser/backend/common/errors"
 	"github.com/gtsteffaniak/filebrowser/backend/common/settings"
 	"github.com/gtsteffaniak/filebrowser/backend/common/utils"
@@ -51,6 +50,7 @@ func extractToken(r *http.Request) (string, error) {
 	// Check for Authorization header
 	authHeader := r.Header.Get("Authorization")
 	if authHeader != "" {
+
 		hasToken = true
 		// Split the header to get "Bearer {token}"
 		parts := strings.Split(authHeader, " ")
@@ -76,12 +76,10 @@ func setupProxyUser(r *http.Request, data *requestContext, proxyUser string) (*u
 			return nil, err
 		}
 		if config.Auth.Methods.ProxyAuth.CreateUser {
-			user := users.User{
+			err = storage.CreateUser(users.User{
 				LoginMethod: users.LoginMethodProxy,
 				Username:    proxyUser,
-			}
-			settings.ApplyUserDefaults(&user)
-			err = storage.CreateUser(user)
+			}, false)
 			if err != nil {
 				return nil, err
 			}
@@ -94,7 +92,14 @@ func setupProxyUser(r *http.Request, data *requestContext, proxyUser string) (*u
 		}
 	}
 	if data.user.LoginMethod != users.LoginMethodProxy {
-		return nil, errors.ErrWrongLoginMethod
+		logger.Warningf("user %s is not allowed to login with proxy authentication, bypassing and updating login method", data.user.Username)
+		data.user.LoginMethod = users.LoginMethodProxy
+		// Perform the user update
+		err := store.Users.Update(data.user, true, "LoginMethod")
+		if err != nil {
+			logger.Debug(err.Error())
+		}
+		//return nil, fmt.Errorf("user %s is not allowed to login with proxy authentication", proxyUser)
 	}
 	return data.user, nil
 }
@@ -119,44 +124,28 @@ func loginHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (in
 	return printToken(w, r, d.user) // Pass the data object
 }
 
-// logoutHandler handles user logout
+// logoutHandler handles user logout, specifically used for OIDC.
 // @Summary User Logout
-// @Description Returns a logout URL for the frontend to redirect to.
+// @Description logs a user out of the application.
 // @Tags Auth
-// @Produce json
-// @Param auth query string false "JWT token"
-// @Success 200 {object} map[string]string "{"logoutUrl": "http://..."}"
-// @Router /api/auth/logout [post]
+// @Success 302 {string} string "Redirect to redirect URL if configured in oidc config."
+// @Router /api/auth/logout [get]
 func logoutHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
-	defer auth.RevokeAPIKey(d.token)
-	logoutUrl := fmt.Sprintf("%vlogin", config.Server.BaseURL) // Default fallback
-	if d.user.LoginMethod == users.LoginMethodProxy {
-		proxyRedirectUrl := config.Auth.Methods.ProxyAuth.LogoutRedirectUrl
-		if proxyRedirectUrl != "" {
-			logoutUrl = proxyRedirectUrl
-		}
-	} else if d.user.LoginMethod == users.LoginMethodOidc {
-		oidcRedirectUrl := config.Auth.Methods.OidcAuth.LogoutRedirectUrl
-		if oidcRedirectUrl != "" {
-			logoutUrl = oidcRedirectUrl
-		}
+	origin := r.Header.Get("Origin")
+	if origin == "" {
+		origin = fmt.Sprintf("%s://%s", getScheme(r), r.Host)
 	}
-	if logoutUrl == "" {
-		logger.Debug("no logout url found, using default")
-		logoutUrl = fmt.Sprintf("%vlogin", config.Server.BaseURL)
-	}
-	response := map[string]string{
-		"logoutUrl": logoutUrl,
+	logoutUrl := fmt.Sprintf("%s/login", origin)
+
+	oidcCfg := settings.Config.Auth.Methods.OidcAuth
+	if oidcCfg.Enabled && oidcCfg.LogoutRedirectUrl != "" {
+		logoutUrl = oidcCfg.LogoutRedirectUrl
+		http.Redirect(w, r, logoutUrl, http.StatusFound)
+		return 302, nil
 	}
 
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(http.StatusOK)
-	err := json.NewEncoder(w).Encode(response)
-	if err != nil {
-		return http.StatusInternalServerError, err
-	}
-
-	return http.StatusOK, nil
+	http.Redirect(w, r, logoutUrl, http.StatusFound)
+	return 302, nil
 }
 
 type signupBody struct {
@@ -196,8 +185,7 @@ func signupHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (i
 		},
 		LoginMethod: users.LoginMethodPassword,
 	}
-	user.Permissions = settings.Config.UserDefaults.Permissions
-	err = storage.CreateUser(user)
+	err = storage.CreateUser(user, false)
 	if err != nil {
 		logger.Debug(err.Error())
 		w.WriteHeader(http.StatusConflict)

backend/http/httpEvents.go

@@ -71,11 +71,7 @@ func sseHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int,
 				return http.StatusInternalServerError, fmt.Errorf("error sending broadcast: %v, user: %s", err, username)
 			}
 
-		case msg, ok := <-sendChan:
-			if !ok {
-				logger.Debugf("SSE channel closed for user: %s, SessionId: %s", username, sessionId)
-				return http.StatusOK, nil
-			}
+		case msg := <-sendChan:
 			if err := msgr.sendEvent(msg.EventType, msg.Message); err != nil {
 				return http.StatusInternalServerError, fmt.Errorf("error sending targeted message: %v, user: %s", err, username)
 			}

backend/http/httpJobs.go

@@ -8,17 +8,6 @@ import (
 	"github.com/gtsteffaniak/go-logger/logger"
 )
 
-// getJobsHandler returns job info for the user.
-// @Summary Get jobs info
-// @Description Returns job info for the user.
-// @Tags Jobs
-// @Accept json
-// @Produce json
-// @Param action path string true "Job action"
-// @Param target path string true "Job target"
-// @Success 200 {object} map[string]indexing.ReducedIndex "Job info"
-// @Failure 500 {object} map[string]string "Internal server error"
-// @Router /api/jobs/{action}/{target} [get]
 func getJobsHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
 	sources := settings.GetSources(d.user)
 	reducedIndexes := map[string]indexing.ReducedIndex{}

backend/http/httpRouter.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"crypto/tls"
 	"embed"
-	"encoding/json"
 	"fmt"
 	"io/fs"
 	"net/http"
@@ -14,8 +13,7 @@ import (
 
 	"github.com/gtsteffaniak/filebrowser/backend/common/settings"
 	"github.com/gtsteffaniak/filebrowser/backend/common/version"
-	"github.com/gtsteffaniak/filebrowser/backend/database/storage/bolt"
-	"github.com/gtsteffaniak/filebrowser/backend/events"
+	"github.com/gtsteffaniak/filebrowser/backend/database/storage"
 	"github.com/gtsteffaniak/go-logger/logger"
 	// http-swagger middleware
 )
@@ -25,6 +23,9 @@ import (
 //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
@@ -36,26 +37,15 @@ func (d dirFS) Open(name string) (fs.File, error) {
 }
 
 var (
-	store   *bolt.BoltStore
+	store   *storage.Storage
 	config  *settings.Settings
 	assetFs fs.FS
 )
 
-func StartHttp(ctx context.Context, storage *bolt.BoltStore, shutdownComplete chan struct{}) {
+func StartHttp(ctx context.Context, storage *storage.Storage, shutdownComplete chan struct{}) {
 	store = storage
 	config = &settings.Config
-
-	// Dev mode enables development features like template hot-reloading
-	devMode := os.Getenv("FILEBROWSER_DEVMODE") == "true"
-	_, err := os.Stat("http/dist")
-	// In dev mode, always use filesystem assets. Otherwise, check if http/dist exists
-	var embeddedFS bool
-	if devMode {
-		embeddedFS = false
-	} else {
-		embeddedFS = os.IsNotExist(err)
-	}
-
+	var err error
 	// --- START: ADD THIS DECRYPTION LOGIC ---
 	if embeddedFS {
 		// Embedded mode: Serve files from the embedded assets
@@ -67,27 +57,13 @@ func StartHttp(ctx context.Context, storage *bolt.BoltStore, shutdownComplete ch
 		assetFs = dirFS{Dir: http.Dir("http/dist")}
 	}
 
-	// In development mode, we want to reload the templates on each request.
-	// In production (embedded), we parse them once.
-	templates := template.New("").Funcs(template.FuncMap{
-		"marshal": func(v interface{}) (string, error) {
-			a, err := json.Marshal(v)
-			return string(a), err
-		},
-	})
-	if !devMode {
-		templates = template.Must(templates.ParseFS(assetFs, "public/index.html"))
-	}
 	templateRenderer = &TemplateRenderer{
-		templates: templates,
-		devMode:   devMode,
+		templates: template.Must(template.ParseFS(assetFs, "public/index.html")),
 	}
 
 	router := http.NewServeMux()
 	// API group routing
 	api := http.NewServeMux()
-	// Public group routing (new structure)
-	publicRoutes := http.NewServeMux()
 
 	// User routes
 	api.HandleFunc("GET /users", withUser(userGetHandler))
@@ -97,7 +73,7 @@ func StartHttp(ctx context.Context, storage *bolt.BoltStore, shutdownComplete ch
 
 	// Auth routes
 	api.HandleFunc("POST /auth/login", userWithoutOTP(loginHandler))
-	api.HandleFunc("POST /auth/logout", withUser(logoutHandler))
+	api.HandleFunc("GET /auth/logout", withoutUser(logoutHandler))
 	api.HandleFunc("POST /auth/signup", withoutUser(signupHandler))
 	api.HandleFunc("POST /auth/otp/generate", userWithoutOTP(generateOTPHandler))
 	api.HandleFunc("POST /auth/otp/verify", userWithoutOTP(verifyOTPHandler))
@@ -117,83 +93,52 @@ func StartHttp(ctx context.Context, storage *bolt.BoltStore, shutdownComplete ch
 	api.HandleFunc("PATCH /resources", withUser(resourcePatchHandler))
 	api.HandleFunc("GET /raw", withUser(rawHandler))
 	api.HandleFunc("GET /preview", withUser(previewHandler))
-	api.HandleFunc("GET /media/subtitles", withUser(subtitlesHandler))
 	if version.Version == "testing" || version.Version == "untracked" {
 		api.HandleFunc("GET /inspectIndex", inspectIndex)
 		api.HandleFunc("GET /mockData", mockData)
 	}
-	// Access routes
-	api.HandleFunc("GET /access", withAdmin(accessGetHandler))
-	api.HandleFunc("POST /access", withAdmin(accessPostHandler))
-	api.HandleFunc("DELETE /access", withAdmin(accessDeleteHandler))
-	api.HandleFunc("GET /access/groups", withAdmin(groupGetHandler))
-	api.HandleFunc("POST /access/group", withAdmin(groupPostHandler))
-	api.HandleFunc("DELETE /access/group", withAdmin(groupDeleteHandler))
 
-	// Share management routes (require permission)
+	// Share routes
 	api.HandleFunc("GET /shares", withPermShare(shareListHandler))
-	api.HandleFunc("GET /share/direct", withPermShare(shareDirectDownloadHandler))
 	api.HandleFunc("GET /share", withPermShare(shareGetHandler))
 	api.HandleFunc("POST /share", withPermShare(sharePostHandler))
 	api.HandleFunc("DELETE /share", withPermShare(shareDeleteHandler))
 
-	// Create API sub-router for public API endpoints
-	publicAPI := http.NewServeMux()
-	// NEW PUBLIC ROUTES - All publicly accessible endpoints
-	// Public API routes (hash-based authentication)
-	publicAPI.HandleFunc("GET /raw", withHashFile(publicRawHandler))
-	publicAPI.HandleFunc("GET /preview", withHashFile(publicPreviewHandler))
-	publicAPI.HandleFunc("GET /resources", withHashFile(publicShareHandler))
-	publicAPI.HandleFunc("GET /users", withUser(userGetHandler))
-	publicAPI.HandleFunc("POST /onlyoffice/callback", withHashFile(onlyofficeCallbackHandler))
-	publicAPI.HandleFunc("GET /onlyoffice/config", withHashFile(onlyofficeClientConfigGetHandler))
+	// Public routes
+	api.HandleFunc("GET /public/publicUser", publicUserGetHandler)
+	api.HandleFunc("GET /public/dl", withHashFile(publicRawHandler))
+	api.HandleFunc("GET /public/share", withHashFile(publicShareHandler))
+	api.HandleFunc("GET /public/preview", withHashFile(publicPreviewHandler))
 
 	// Settings routes
 	api.HandleFunc("GET /settings", withAdmin(settingsGetHandler))
-	api.HandleFunc("GET /settings/config", withAdmin(settingsConfigHandler))
 
 	// Events routes
 	api.HandleFunc("GET /events", withUser(func(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
 		d.ctx = ctx // Pass the parent context to ensure proper shutdown
 		return sseHandler(w, r, d)
 	}))
+
 	// Job routes
 	api.HandleFunc("GET /jobs/{action}/{target}", withUser(getJobsHandler))
 
 	api.HandleFunc("GET /onlyoffice/config", withUser(onlyofficeClientConfigGetHandler))
 	api.HandleFunc("POST /onlyoffice/callback", withUser(onlyofficeCallbackHandler))
+	api.HandleFunc("GET /onlyoffice/getToken", withUser(onlyofficeGetTokenHandler))
 
 	api.HandleFunc("GET /search", withUser(searchHandler))
-	// Mount the public API sub-router
-	publicRoutes.Handle("/api/", http.StripPrefix("/api", publicAPI))
-
-	// Mount the route groups
 	apiPath := config.Server.BaseURL + "api"
-	publicPath := config.Server.BaseURL + "public"
 	router.Handle(apiPath+"/", http.StripPrefix(apiPath, api))
-	router.Handle(publicPath+"/", http.StripPrefix(publicPath, publicRoutes))
-
-	// Frontend share route redirect (DEPRECATED - maintain for backwards compatibility)
-	router.HandleFunc(fmt.Sprintf("GET %vshare/", config.Server.BaseURL), withOrWithoutUser(redirectToShare))
-
-	// New frontend share route handler - handle share page and any subpaths
-	publicRoutes.HandleFunc("GET /share/", withOrWithoutUser(indexHandler))
 
 	// Static and index file handlers
-	staticPrefix := config.Server.BaseURL + "static/"
-	router.Handle(staticPrefix, http.StripPrefix(staticPrefix, http.HandlerFunc(staticFilesHandler)))
-	publicRoutes.Handle("GET /static/", http.StripPrefix("/static/", http.HandlerFunc(staticFilesHandler)))
+	router.HandleFunc(fmt.Sprintf("GET %vstatic/", config.Server.BaseURL), staticFilesHandler)
+	router.HandleFunc(config.Server.BaseURL, indexHandler)
 
-	router.HandleFunc(config.Server.BaseURL, withOrWithoutUser(indexHandler))
+	// health
 	router.HandleFunc(fmt.Sprintf("GET %vhealth", config.Server.BaseURL), healthHandler)
-	router.Handle(fmt.Sprintf("%vswagger/", config.Server.BaseURL), withUser(swaggerHandler))
 
-	// redirect to baseUrl if not root
-	if config.Server.BaseURL != "/" {
-		router.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
-			http.Redirect(w, r, config.Server.BaseURL, http.StatusMovedPermanently)
-		})
-	}
+	// Swagger
+	router.Handle(fmt.Sprintf("%vswagger/", config.Server.BaseURL), withUser(swaggerHandler))
 
 	var scheme string
 	port := ""
@@ -256,23 +201,6 @@ func StartHttp(ctx context.Context, storage *bolt.BoltStore, shutdownComplete ch
 	<-ctx.Done()
 	logger.Info("Shutting down HTTP server...")
 
-	// Close all SSE sessions
-	events.Shutdown()
-
-	// Persist in-memory state before shutting down the HTTP server
-	if store != nil {
-		if store.Share != nil {
-			if err := store.Share.Flush(); err != nil {
-				logger.Errorf("Failed to flush share storage: %v", err)
-			}
-		}
-		if store.Access != nil {
-			if err := store.Access.Flush(); err != nil {
-				logger.Errorf("Failed to flush access storage: %v", err)
-			}
-		}
-	}
-
 	// Graceful shutdown with a timeout - 30 seconds, in case downloads are happening
 	shutdownCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()

backend/http/media.go

@@ -1,83 +0,0 @@
-package http
-
-import (
-	"bytes"
-	"fmt"
-	"net/http"
-	"net/url"
-	"path/filepath"
-	"strconv"
-	"time"
-
-	"github.com/gtsteffaniak/filebrowser/backend/common/settings"
-	"github.com/gtsteffaniak/filebrowser/backend/ffmpeg"
-	"github.com/gtsteffaniak/filebrowser/backend/indexing"
-)
-
-// subtitlesHandler handles subtitle extraction requests
-// @Summary Extract embedded subtitles
-// @Description Extracts embedded subtitle content from video files by stream index and returns raw WebVTT content
-// @Tags Subtitles
-// @Accept json
-// @Produce text/vtt
-// @Param path query string true "Index path to the video file"
-// @Param source query string true "Source name for the desired source"
-// @Param index query int false "Stream index for embedded subtitle extraction, defaults to 0"
-// @Success 200 {string} string "Raw WebVTT subtitle content"
-// @Failure 400 {object} map[string]string "Bad request"
-// @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/media/subtitles [get]
-func subtitlesHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
-	encodedPath := r.URL.Query().Get("path")
-	source := r.URL.Query().Get("source")
-	indexParam := r.URL.Query().Get("index")
-
-	if indexParam == "" {
-		indexParam = "0" // default to first subtitle stream
-	}
-
-	path, err := url.QueryUnescape(encodedPath)
-	if err != nil {
-		return http.StatusBadRequest, fmt.Errorf("invalid path encoding: %v", err)
-	}
-	source, err = url.QueryUnescape(source)
-	if err != nil {
-		return http.StatusBadRequest, fmt.Errorf("invalid source encoding: %v", err)
-	}
-
-	userscope, err := settings.GetScopeFromSourceName(d.user.Scopes, source)
-	if err != nil {
-		return http.StatusForbidden, err
-	}
-
-	idx := indexing.GetIndex(source)
-	if idx == nil {
-		return http.StatusNotFound, fmt.Errorf("source %s not found", source)
-	}
-	realPath, _, err := idx.GetRealPath(userscope, path)
-	if err != nil {
-		return http.StatusNotFound, fmt.Errorf("file not found: %v", err)
-	}
-	metadata, exists := idx.GetMetadataInfo(userscope, true)
-	if !exists {
-		return http.StatusNotFound, fmt.Errorf("file not found: %v", err)
-	}
-
-	index, err := strconv.Atoi(indexParam)
-	if err != nil {
-		return http.StatusBadRequest, fmt.Errorf("invalid index parameter: %v", err)
-	}
-	parentDir := filepath.Dir(realPath)
-	subtitle, err := ffmpeg.ExtractSingleSubtitle(realPath, parentDir, index, metadata.ModTime)
-	if err != nil {
-		return http.StatusInternalServerError, fmt.Errorf("failed to extract subtitle: %v", err)
-	}
-	w.Header().Set("Content-Type", "text/vtt; charset=utf-8")
-	w.Header().Set("Content-Disposition", "inline")
-	w.Header().Set("Cache-Control", "private")
-	http.ServeContent(w, r, fmt.Sprintf("%s-%d.vtt", subtitle.Name, index),
-		time.Now(), bytes.NewReader([]byte(subtitle.Content)))
-	return http.StatusOK, nil
-}

backend/http/middleware.go

@@ -6,8 +6,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
-	"runtime"
-	"slices"
 	"strings"
 	"time"
 
@@ -15,8 +13,6 @@ import (
 	"github.com/gtsteffaniak/filebrowser/backend/adapters/fs/files"
 	"github.com/gtsteffaniak/filebrowser/backend/auth"
 	"github.com/gtsteffaniak/filebrowser/backend/common/errors"
-	"github.com/gtsteffaniak/filebrowser/backend/common/settings"
-	"github.com/gtsteffaniak/filebrowser/backend/common/utils"
 	"github.com/gtsteffaniak/filebrowser/backend/database/share"
 	"github.com/gtsteffaniak/filebrowser/backend/database/users"
 	"github.com/gtsteffaniak/filebrowser/backend/indexing/iteminfo"
@@ -24,13 +20,13 @@ import (
 )
 
 type requestContext struct {
-	user         *users.User
-	fileInfo     iteminfo.ExtendedFileInfo
-	token        string
-	share        *share.Link
-	shareValid   bool
-	ctx          context.Context
-	MaxBandwidth int
+	user     *users.User
+	raw      interface{}
+	fileInfo iteminfo.ExtendedFileInfo
+	path     string
+	token    string
+	share    *share.Link
+	ctx      context.Context
 }
 
 type HttpResponse struct {
@@ -46,22 +42,15 @@ type handleFunc func(w http.ResponseWriter, r *http.Request, data *requestContex
 
 // Middleware to handle file requests by hash and pass it to the handler
 func withHashFileHelper(fn handleFunc) handleFunc {
-	return withOrWithoutUserHelper(func(w http.ResponseWriter, r *http.Request, data *requestContext) (int, error) {
-		hash := r.URL.Query().Get("hash")
+	return func(w http.ResponseWriter, r *http.Request, data *requestContext) (int, error) {
 		path := r.URL.Query().Get("path")
+		hash := r.URL.Query().Get("hash")
+		// Retrieve the user (using the public user by default)
+		data.user = &users.PublicUser
 		// Get the file link by hash
 		link, err := store.Share.GetByHash(hash)
 		if err != nil {
-			data.share = &share.Link{}
-			return http.StatusNotFound, fmt.Errorf("share hash not found")
-		}
-		if link.DisableAnonymous && data.user.Username == "anonymous" {
-			return http.StatusForbidden, fmt.Errorf("share is not available to anonymous users")
-		}
-		if len(link.AllowedUsernames) > 0 {
-			if !slices.Contains(link.AllowedUsernames, data.user.Username) {
-				return http.StatusForbidden, fmt.Errorf("share is not available to this user")
-			}
+			return http.StatusNotFound, fmt.Errorf("share not found")
 		}
 		data.share = link
 		// Authenticate the share request if needed
@@ -72,46 +61,32 @@ func withHashFileHelper(fn handleFunc) handleFunc {
 				return status, fmt.Errorf("could not authenticate share request")
 			}
 		}
+		data.path = strings.TrimSuffix(link.Path, "/") + "/" + strings.TrimPrefix(path, "/")
+		if path == "" || path == "/" {
+			data.path = link.Path
+		}
+
 		source, ok := config.Server.SourceMap[link.Source]
 		if !ok {
 			return http.StatusNotFound, fmt.Errorf("source not found")
 		}
-		if source.Config.Private {
-			return http.StatusForbidden, fmt.Errorf("the target source is private")
-		}
 		// Get file information with options
-		getContent := r.URL.Query().Get("content") == "true"
-		if link.DisableFileViewer || link.Downloads >= link.DownloadsLimit {
-			getContent = false
-		}
 		file, err := FileInfoFasterFunc(iteminfo.FileOptions{
-			Path:    utils.JoinPathAsUnix(link.Path, path),
-			Source:  link.Source,
-			Modify:  false,
-			Expand:  true,
-			Content: getContent,
+			Path:   data.path,
+			Source: source.Name,
+			Modify: false,
+			Expand: true,
 		})
+		file.Token = link.Token
 		if err != nil {
-			logger.Errorf("error fetching file info for share. hash=%v path=%v error=%v", hash, path, err)
+			logger.Errorf("error fetching file info for share. hash=%v path=%v error=%v", hash, data.path, err)
 			return errToStatus(err), fmt.Errorf("error fetching share from server")
 		}
-		file.Token = link.Token
-		file.Source = ""
-		file.Hash = link.Hash
-		if !link.EnableOnlyOffice || !link.DisableFileViewer {
-			file.OnlyOfficeId = ""
-		}
-		if getContent && file.Content != "" {
-			link.Mu.Lock()
-			link.Downloads++
-			link.Mu.Unlock()
-		}
-		file.Path = "/" + strings.TrimPrefix(strings.TrimPrefix(file.Path, link.Path), "/")
 		// Set the file info in the `data` object
-		data.fileInfo = *file
+		data.raw = file
 		// Call the next handler with the data
 		return fn(w, r, data)
-	})
+	}
 }
 
 // Middleware to ensure the user is an admin
@@ -125,82 +100,6 @@ func withAdminHelper(fn handleFunc) handleFunc {
 	})
 }
 
-// withOrWithoutUserHelper is a middleware that tries to authenticate a user.
-// If authentication is successful, the user is added to the request context.
-// If authentication fails, the request continues without a user.
-func withOrWithoutUserHelper(fn handleFunc) handleFunc {
-	return func(w http.ResponseWriter, r *http.Request, data *requestContext) (int, error) {
-		var link *share.Link
-		var isShareRequest bool
-		var shareHash string
-
-		hash := r.URL.Query().Get("hash")
-		if hash != "" {
-			// Get the file link by hash
-			isShareRequest = true
-			shareHash = hash
-			link, _ = store.Share.GetByHash(hash)
-		} else {
-			prefix := config.Server.BaseURL + "public/share/"
-			reconstructed := config.Server.BaseURL + "public" + r.URL.Path
-			if strings.HasPrefix(reconstructed, prefix) {
-				remaining := strings.TrimPrefix(reconstructed, prefix)
-				if remaining != "" {
-					if idx := strings.IndexByte(remaining, '/'); idx >= 0 {
-						remaining = remaining[:idx]
-					}
-					if remaining != "" {
-						isShareRequest = true
-						shareHash = remaining
-						var err error
-						link, err = store.Share.GetByHash(remaining)
-						if err != nil {
-							logger.Debugf("error getting share by hash: %v", err)
-						}
-					}
-				}
-			}
-		}
-
-		// If this is a share request, always create a share context (even if invalid)
-		if isShareRequest {
-			if link != nil {
-				data.share = link
-				data.shareValid = true
-			} else {
-				// Create an empty share with just the hash for invalid shares
-				data.share = &share.Link{Hash: shareHash}
-				data.shareValid = false
-			}
-		}
-
-		// Try to authenticate user first
-		status, err := withUserHelper(nil)(w, r, data)
-		if err == nil && status < 400 {
-			if data.share != nil && data.shareValid {
-				if data.user != nil {
-					data.user.CustomTheme = data.share.ShareTheme
-				}
-			}
-			return fn(w, r, data)
-		}
-		// Only fall back to anonymous if authentication actually failed
-		if status == http.StatusUnauthorized || status == http.StatusForbidden {
-			data.user = &users.User{Username: "anonymous"}
-			settings.ApplyUserDefaults(data.user)
-			// If user authentication failed, call the handler without user context
-			// Clear any user data that might have been partially set
-			data.token = ""
-			if data.share != nil && data.shareValid {
-				data.user.CustomTheme = data.share.ShareTheme
-			}
-			// Call the handler function without user context
-			return fn(w, r, data)
-		}
-		return status, fmt.Errorf("could not authenticate request")
-	}
-}
-
 func withoutUserHelper(fn handleFunc) handleFunc {
 	return func(w http.ResponseWriter, r *http.Request, data *requestContext) (int, error) {
 		// This middleware is used when no user authentication is required
@@ -215,7 +114,7 @@ func userWithoutOTPhelper(fn handleFunc) handleFunc {
 		// This middleware is used when no user authentication is required
 		// Call the actual handler function with the updated context
 		username := r.URL.Query().Get("username")
-		password := r.Header.Get("X-Password")
+		password := r.URL.Query().Get("password")
 		proxyUser := r.Header.Get(config.Auth.Methods.ProxyAuth.Header)
 		if config.Auth.Methods.ProxyAuth.Enabled && proxyUser != "" {
 			user, err := setupProxyUser(r, &requestContext{}, proxyUser)
@@ -259,9 +158,6 @@ func withUserHelper(fn handleFunc) handleFunc {
 				logger.Errorf("no auth: %v", err)
 				return http.StatusInternalServerError, err
 			}
-			if fn == nil {
-				return http.StatusOK, nil
-			}
 			return fn(w, r, data)
 		}
 		proxyUser := r.Header.Get(config.Auth.Methods.ProxyAuth.Header)
@@ -272,9 +168,6 @@ func withUserHelper(fn handleFunc) handleFunc {
 			}
 			data.user = user
 			setUserInResponseWriter(w, data.user)
-			if fn == nil {
-				return http.StatusOK, nil
-			}
 			return fn(w, r, data)
 		}
 		keyFunc := func(token *jwt.Token) (interface{}, error) {
@@ -293,26 +186,23 @@ func withUserHelper(fn handleFunc) handleFunc {
 		if !token.Valid {
 			return http.StatusUnauthorized, fmt.Errorf("invalid token")
 		}
-		if auth.IsRevokedApiKey(data.token) || tk.Expires < time.Now().Unix() {
+		if auth.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
+		}
+
+		// Retrieve the user from the store and store it in the context
 		data.user, err = store.Users.Get(tk.BelongsTo)
 		if err != nil {
-			logger.Errorf("Failed to get user with ID %v: %v", tk.BelongsTo, err)
 			return http.StatusInternalServerError, err
 		}
+
 		setUserInResponseWriter(w, data.user)
-		if data.user.Username == "" {
-			return http.StatusForbidden, errors.ErrUnauthorized
-		}
-		// Call the handler function, passing in the context (or return OK if no handler)
-		if fn == nil {
-			return http.StatusOK, nil
-		}
+
+		// Call the handler function, passing in the context
 		return fn(w, r, data)
 	}
 }
@@ -395,10 +285,6 @@ func withUser(fn handleFunc) http.HandlerFunc {
 	return wrapHandler(withUserHelper(fn))
 }
 
-func withOrWithoutUser(fn handleFunc) http.HandlerFunc {
-	return wrapHandler(withOrWithoutUserHelper(fn))
-}
-
 func withoutUser(fn handleFunc) http.HandlerFunc {
 	return wrapHandler(withoutUserHelper(fn))
 }
@@ -459,80 +345,28 @@ func setUserInResponseWriter(w http.ResponseWriter, user *users.User) {
 // 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) {
-		// DEFER RECOVERY FUNCTION
-		defer func() {
-			if rcv := recover(); rcv != nil {
-				// Log detailed information about the panic
-				// Extract as much context as possible for logging
-				method := r.Method
-				url := r.URL.String()
-				remoteAddr := r.RemoteAddr
-				username := "unknown" // Default username
-
-				// Attempt to get username from ResponseWriterWrapper if it's set
-				if ww, ok := w.(*ResponseWriterWrapper); ok && ww.User != "" {
-					username = ww.User
-				}
-				// Or try to get it from request context if your other middleware populates it
-				// This depends on your context setup; example:
-				// if dataCtx, ok := r.Context().Value("requestData").(*requestContext); ok && dataCtx.user != nil {
-				// 	username = dataCtx.user.Username
-				// }
-
-				// Get Go-level stack trace
-				buf := make([]byte, 16384)     // Increased buffer size for potentially long CGo traces
-				n := runtime.Stack(buf, false) // false for current goroutine only
-				stackTrace := string(buf[:n])
-
-				logger.Errorf("PANIC RECOVERED: %v\nUser: %s\nMethod: %s\nURL: %s\nRemoteAddr: %s\nGo Stack Trace:\n%s",
-					rcv, username, method, url, remoteAddr, stackTrace)
-
-				// Attempt to send a 500 error response to the client
-				// This is a best-effort; the connection might be broken or process too unstable.
-				if ww, ok := w.(*ResponseWriterWrapper); ok { // Check if it's our wrapper
-					if !ww.wroteHeader { // Only write if headers haven't been sent
-						ww.Header().Set("Content-Type", "application/json; charset=utf-8")
-						ww.WriteHeader(http.StatusInternalServerError)
-					}
-				} else {
-					_, _ = renderJSON(w, r, &HttpResponse{
-						Status:  500,
-						Message: "A critical internal error occurred. Please try again later.",
-					})
-				}
-
-				// IMPORTANT: After a SIGSEGV from C code, the process might be unstable.
-				// Even if Go recovers, continuing to run the process is risky.
-				// Consider a strategy to gracefully shut down or signal an external supervisor
-				// to restart the process after logging. For now, this will allow other requests
-				// to proceed if the process doesn't die, but be wary.
-			}
-		}() // End of deferred recovery function
-
 		start := time.Now()
+
+		// Wrap the ResponseWriter to capture the status code.
 		wrappedWriter := &ResponseWriterWrapper{ResponseWriter: w, StatusCode: http.StatusOK}
 
-		// Call the next handler in the chain
+		// Call the next handler.
 		next.ServeHTTP(wrappedWriter, r)
 
-		// Existing logging logic for normal requests
+		// Capture the full URL path including the query parameters.
 		fullURL := r.URL.Path
 		if r.URL.RawQuery != "" {
 			fullURL += "?" + r.URL.RawQuery
 		}
 		truncUser := wrappedWriter.User
-		if truncUser == "" {
-			truncUser = "N/A" // Handle case where user might not be set (e.g., if panic occurred before user auth)
-		} else if len(truncUser) > 12 {
+		if len(truncUser) > 12 {
 			truncUser = truncUser[:10] + ".."
 		}
 		duration := time.Since(start)
-
-		// Use the StatusCode from wrappedWriter, which might have been set to 500 by the recover logic
 		logger.Api(wrappedWriter.StatusCode,
 			fmt.Sprintf("%-7s | %3d | %-15s | %-12s | %-12s | \"%s\"",
 				r.Method,
-				wrappedWriter.StatusCode,
+				wrappedWriter.StatusCode, // Captured status code
 				r.RemoteAddr,
 				truncUser,
 				fmt.Sprintf("%vms", duration.Milliseconds()),

backend/http/middleware_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/gtsteffaniak/filebrowser/backend/common/settings"
 	"github.com/gtsteffaniak/filebrowser/backend/common/utils"
 	"github.com/gtsteffaniak/filebrowser/backend/database/share"
+	"github.com/gtsteffaniak/filebrowser/backend/database/storage"
 	"github.com/gtsteffaniak/filebrowser/backend/database/storage/bolt"
 	"github.com/gtsteffaniak/filebrowser/backend/database/users"
 	"github.com/gtsteffaniak/filebrowser/backend/indexing/iteminfo"
@@ -22,10 +23,16 @@ func setupTestEnv(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	store, err = bolt.NewStorage(db)
+	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,
+	}
 	config = &settings.Config // mocked
 	config.Server.SourceMap = map[string]settings.Source{
 		"/srv": settings.Source{
@@ -43,8 +50,8 @@ func mockFileInfoFaster(t *testing.T) {
 	t.Cleanup(func() { FileInfoFasterFunc = originalFileInfoFaster })
 
 	// Mock the function to skip execution
-	FileInfoFasterFunc = func(opts iteminfo.FileOptions) (*iteminfo.ExtendedFileInfo, error) {
-		return &iteminfo.ExtendedFileInfo{
+	FileInfoFasterFunc = func(opts iteminfo.FileOptions) (iteminfo.ExtendedFileInfo, error) {
+		return iteminfo.ExtendedFileInfo{
 			FileInfo: iteminfo.FileInfo{
 				Path: opts.Path,
 				ItemInfo: iteminfo.ItemInfo{
@@ -150,26 +157,8 @@ func TestPublicShareHandlerAuthentication(t *testing.T) {
 		{
 			name: "Public share, no auth required",
 			share: &share.Link{
-				Hash: "public_hash",
-				CommonShare: share.CommonShare{
-					Source: "/srv",
-				},
-			},
-			expectedStatusCode: 0, // zero means 200 on helpers
-		},
-		{
-			name: "Private share, valid password when token exists",
-			share: &share.Link{
-				Hash:         "pw_and_token_hash",
-				UserID:       1,
-				PasswordHash: passwordBcrypt,
-				Token:        "some_random_token",
-				CommonShare: share.CommonShare{
-					Source: "/srv",
-				},
-			},
-			extraHeaders: map[string]string{
-				"X-SHARE-PASSWORD": "password",
+				Hash:   "public_hash",
+				Source: "/srv",
 			},
 			expectedStatusCode: 0, // zero means 200 on helpers
 		},
@@ -190,9 +179,7 @@ func TestPublicShareHandlerAuthentication(t *testing.T) {
 				UserID:       1,
 				PasswordHash: passwordBcrypt,
 				Token:        "123",
-				CommonShare: share.CommonShare{
-					Source: "/srv",
-				},
+				Source:       "/srv",
 			},
 			token:              "123",
 			expectedStatusCode: 0, // zero means 200 on helpers

backend/http/oidc.go

@@ -2,16 +2,12 @@ package http
 
 import (
 	"crypto/tls"
-	"encoding/json"
 	"fmt"
 	"net/http"
-	"net/url"
-	"slices"
 	"strings"
 	"time"
 
 	"github.com/coreos/go-oidc/v3/oidc"
-	"github.com/gtsteffaniak/filebrowser/backend/common/errors"
 	"github.com/gtsteffaniak/filebrowser/backend/common/settings"
 	"github.com/gtsteffaniak/filebrowser/backend/common/utils"
 	"github.com/gtsteffaniak/filebrowser/backend/database/storage"
@@ -22,108 +18,19 @@ import (
 
 // userInfo struct to hold user claims from either UserInfo or ID token
 type userInfo struct {
-	Name              string   `json:"name"`
-	PreferredUsername string   `json:"preferred_username"`
-	Username          string   `json:"username"`
-	Email             string   `json:"email"`
-	Sub               string   `json:"sub"`
-	Phone             string   `json:"phone_number"`
-	Groups            []string `json:"-"` // Handled manually by userInfoUnmarshaller
+	Name              string `json:"name"`
+	PreferredUsername string `json:"preferred_username"`
+	Email             string `json:"email"`
+	Sub               string `json:"sub"`
+	Phone             string `json:"phone_number"`
 }
 
-// userInfoUnmarshaller is a custom unmarshaller that handles configurable groups claim
-type userInfoUnmarshaller struct {
-	userInfo    *userInfo
-	groupsClaim string
-}
-
-// UnmarshalJSON implements the json.Unmarshaler interface
-func (u *userInfoUnmarshaller) UnmarshalJSON(data []byte) error {
-	// First, unmarshal the basic userInfo fields
-	if err := json.Unmarshal(data, u.userInfo); err != nil {
-		return err
-	}
-
-	// Parse the JSON to access the groups claim field
-	var rawData map[string]interface{}
-	if err := json.Unmarshal(data, &rawData); err != nil {
-		return err
-	}
-
-	// Look for the groups claim using the configured field name
-	if groupsValue, exists := rawData[u.groupsClaim]; exists {
-		switch v := groupsValue.(type) {
-		case []interface{}:
-			// It's already an array, convert to []string
-			groups := make([]string, len(v))
-			for i, group := range v {
-				if str, ok := group.(string); ok {
-					groups[i] = str
-				}
-			}
-			u.userInfo.Groups = groups
-		case string:
-			// It's a string, split by commas
-			if v != "" {
-				u.userInfo.Groups = strings.Split(v, ",")
-				// Trim whitespace from each group
-				for i, group := range u.userInfo.Groups {
-					u.userInfo.Groups[i] = strings.TrimSpace(group)
-				}
-			}
-		}
-	}
-
-	return nil
-}
-
-// oidcLoginHandler initiates OIDC login.
-// @Summary OIDC login
-// @Description Initiates OIDC login flow.
-// @Tags OIDC
-// @Accept json
-// @Produce json
-// @Success 302 {string} string "Redirect to OIDC provider"
-// @Router /api/auth/oidc/login [get]
-func oidcLoginHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
-	oidcCfg := settings.Config.Auth.Methods.OidcAuth
-	if !oidcCfg.Enabled {
-		return http.StatusForbidden, fmt.Errorf("oidc authentication is not enabled")
-	}
-
-	origin := r.Header.Get("Origin")
-	if origin == "" {
-		origin = fmt.Sprintf("%s://%s", getScheme(r), r.Host)
-	}
-	oauth2Config := &oauth2.Config{
-		ClientID:     oidcCfg.ClientID,
-		ClientSecret: oidcCfg.ClientSecret,
-		Endpoint:     oidcCfg.Provider.Endpoint(),
-		RedirectURL:  fmt.Sprintf("%s%sapi/auth/oidc/callback", origin, config.Server.BaseURL),
-		Scopes:       strings.Split(oidcCfg.Scopes, " "),
-	}
-
-	nonce := utils.InsecureRandomIdentifier(16)
-	fbRedirect := r.URL.Query().Get("redirect")
-	state := fmt.Sprintf("%s:%s", nonce, fbRedirect)
-	authURL := oauth2Config.AuthCodeURL(state)
-	http.Redirect(w, r, authURL, http.StatusFound)
-	return 0, nil
-}
-
-// oidcCallbackHandler handles OIDC callback.
-// @Summary OIDC callback
-// @Description Handles OIDC login callback.
-// @Tags OIDC
-// @Accept json
-// @Produce json
-// @Param code query string false "OIDC code"
-// @Param state query string false "OIDC state"
-// @Success 200 {object} map[string]string "OIDC callback result"
-// @Failure 400 {object} map[string]string "Bad request"
-// @Router /api/auth/oidc/callback [get]
+// oidcCallbackHandler handles the OIDC callback after the user authenticates with the provider.
+// It exchanges the authorization code for tokens, attempts to verify the ID token.
+// If ID token verification or essential claims extraction fails, it falls back to the UserInfo endpoint.
 func oidcCallbackHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
 	ctx := r.Context()
+
 	oidcCfg := settings.Config.Auth.Methods.OidcAuth
 	if oidcCfg.Provider == nil || oidcCfg.Verifier == nil {
 		// Ensure Provider and Verifier are initialized on application startup
@@ -150,7 +57,7 @@ func oidcCallbackHandler(w http.ResponseWriter, r *http.Request, d *requestConte
 	// and used in the initial /api/auth/oidc/login handler.
 	// Using r.Host here might be tricky if running behind a proxy.
 	// Consider using a fixed redirect URL from settings if possible.
-	redirectURL := fmt.Sprintf("%s://%s%sapi/auth/oidc/callback", getScheme(r), r.Host, config.Server.BaseURL)
+	redirectURL := fmt.Sprintf("%s://%s/api/auth/oidc/callback", getScheme(r), r.Host)
 
 	oauth2Config := &oauth2.Config{
 		ClientID:     oidcCfg.ClientID,
@@ -174,12 +81,6 @@ func oidcCallbackHandler(w http.ResponseWriter, r *http.Request, d *requestConte
 	claimsFromIDToken := false // Flag to track if we successfully got claims from ID token
 	loginUsername := ""        // Variable to hold the login username
 
-	// Create custom unmarshaller for userInfo
-	userInfoUnmarshaller := &userInfoUnmarshaller{
-		userInfo:    &userdata,
-		groupsClaim: oidcCfg.GroupsClaim,
-	}
-
 	// --- Attempt to process ID Token ---
 	if ok && rawIDToken != "" {
 		logger.Debug("ID token found in token response, attempting verification.")
@@ -188,19 +89,35 @@ func oidcCallbackHandler(w http.ResponseWriter, r *http.Request, d *requestConte
 		// This uses the verifier initialized with the provider's JWKS endpoint and client ID
 		idToken, err := oidcCfg.Verifier.Verify(ctx, rawIDToken)
 		if err != nil {
-			// this might not be necessary for certain providers like authentik
-			logger.Debugf("failed to verify ID token: %v. This might be expected, falling back to UserInfo endpoint.", err)
+			logger.Warningf("failed to verify ID token: %v. Falling back to UserInfo endpoint.", err)
 			// Verification failed, claimsFromIDToken remains false
 		} else {
-			// Decode the ID token claims using custom unmarshaller
+			var claims map[string]interface{}
+			// Decode the ID token claims into a map to handle arbitrary structure
 			// This is where the JWE unmarshalling error occurs if the token is encrypted
-			if err := idToken.Claims(userInfoUnmarshaller); err != nil {
+			if err := idToken.Claims(&claims); err != nil {
 				logger.Warningf("failed to decode ID token claims: %v. Falling back to UserInfo endpoint.", err)
 				// Claims decoding failed, claimsFromIDToken remains false
 			} else {
 				// Successfully verified and decoded ID token claims
-				logger.Debugf("ID Token verified and claims decoded: %+v", userdata)
+				logger.Debugf("ID Token verified and claims decoded: %+v", claims)
 
+				// Populate userdata from ID token claims
+				if name, ok := claims["name"].(string); ok {
+					userdata.Name = name
+				}
+				if preferredUsername, ok := claims["preferred_username"].(string); ok {
+					userdata.PreferredUsername = preferredUsername
+				}
+				if email, ok := claims["email"].(string); ok {
+					userdata.Email = email
+				}
+				if sub, ok := claims["sub"].(string); ok {
+					userdata.Sub = sub
+				}
+				if phone, ok := claims["phone_number"].(string); ok {
+					userdata.Phone = phone
+				}
 				// Decide if we rely on ID token claims or still need UserInfo
 				// Even if parsing succeeded, if essential claims are missing, use UserInfo
 				switch oidcCfg.UserIdentifier {
@@ -210,11 +127,6 @@ func oidcCallbackHandler(w http.ResponseWriter, r *http.Request, d *requestConte
 						loginUsername = userdata.Email
 					}
 				case "username":
-					if userdata.Username != "" {
-						claimsFromIDToken = true
-						loginUsername = userdata.Username
-					}
-				case "preferred_username":
 					if userdata.PreferredUsername != "" {
 						claimsFromIDToken = true
 						loginUsername = userdata.PreferredUsername
@@ -241,9 +153,9 @@ func oidcCallbackHandler(w http.ResponseWriter, r *http.Request, d *requestConte
 			logger.Errorf("failed to fetch user info from endpoint: %v", err)
 			return http.StatusInternalServerError, fmt.Errorf("failed to fetch user info from endpoint: %v", err)
 		}
-		// Decode the UserInfo response using custom unmarshaller
+		// Decode the UserInfo response directly into the userdata struct
 		// The UserInfo endpoint is expected to return standard JSON
-		if err := userInfoResp.Claims(userInfoUnmarshaller); err != nil {
+		if err := userInfoResp.Claims(&userdata); err != nil {
 			logger.Errorf("failed to decode user info from endpoint: %v", err)
 			return http.StatusInternalServerError, fmt.Errorf("failed to decode user info from endpoint: %v", err)
 		}
@@ -253,88 +165,89 @@ func oidcCallbackHandler(w http.ResponseWriter, r *http.Request, d *requestConte
 		case "email":
 			loginUsername = userdata.Email
 		case "username":
-			loginUsername = userdata.Username
-		case "preferred_username":
 			loginUsername = userdata.PreferredUsername
 		case "phone":
 			loginUsername = userdata.Phone
 		}
 	}
 	if loginUsername == "" {
-		logger.Errorf("No valid username found for identifier '%v' in ID token or UserInfo response.", oidcCfg.UserIdentifier)
+		logger.Error("No valid username found in ID token or UserInfo response.")
 		return http.StatusInternalServerError, fmt.Errorf("no valid username found in ID token or UserInfo response from claims")
 	}
-
 	// Proceed to log the user in with the OIDC data
 	// userdata struct now contains info from either verified ID token or UserInfo endpoint
-	return loginWithOidcUser(w, r, loginUsername, userdata.Groups)
+	return loginWithOidcUser(w, r, loginUsername)
+}
+
+// oidcLoginHandler redirects the user to the OIDC provider's authorization endpoint.
+// This function remains largely the same, but includes the 'fb_redirect' parameter
+// to redirect the user back to the original page after successful login.
+func oidcLoginHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
+	oidcCfg := settings.Config.Auth.Methods.OidcAuth
+	if !oidcCfg.Enabled {
+		return http.StatusForbidden, fmt.Errorf("oidc authentication is not enabled")
+	}
+
+	origin := r.Header.Get("Origin")
+	if origin == "" {
+		origin = fmt.Sprintf("%s://%s", getScheme(r), r.Host)
+	}
+
+	oauth2Config := &oauth2.Config{
+		ClientID:     oidcCfg.ClientID,
+		ClientSecret: oidcCfg.ClientSecret,
+		Endpoint:     oidcCfg.Provider.Endpoint(),
+		RedirectURL:  fmt.Sprintf("%s/api/auth/oidc/callback", origin),
+		Scopes:       strings.Split(oidcCfg.Scopes, " "),
+	}
+
+	nonce := utils.InsecureRandomIdentifier(16)
+	fbRedirect := r.URL.Query().Get("fb_redirect")
+	state := fmt.Sprintf("%s:%s", nonce, fbRedirect)
+
+	authURL := oauth2Config.AuthCodeURL(state)
+	http.Redirect(w, r, authURL, http.StatusFound)
+	return 0, nil
 }
 
 // loginWithOidcUser extracts the username from the user claims (userInfo)
 // based on the configured UserIdentifier and logs the user into the application.
 // It creates a new user if one doesn't exist.
-func loginWithOidcUser(w http.ResponseWriter, r *http.Request, username string, groups []string) (int, error) {
-	isAdmin := false // Default to non-admin user
-	if config.Auth.Methods.OidcAuth.AdminGroup != "" {
-		if slices.Contains(groups, config.Auth.Methods.OidcAuth.AdminGroup) {
-			isAdmin = true // User is in the admin group, grant admin privileges
-			logger.Debugf("User %s is in admin group %s, granting admin privileges.", username, config.Auth.Methods.OidcAuth.AdminGroup)
-		}
-	}
-	logger.Debugf("Successfully authenticated OIDC username: %s isAdmin: %v", username, isAdmin)
+func loginWithOidcUser(w http.ResponseWriter, r *http.Request, username string) (int, error) {
+	logger.Debugf("Successfully authenticated OIDC username: %s", username)
 	// Retrieve the user from the store and store it in the context
 	user, err := store.Users.Get(username)
 	if err != nil {
 		if err.Error() != "the resource does not exist" {
 			return http.StatusInternalServerError, err
 		}
-		if config.Auth.Methods.OidcAuth.CreateUser {
-			if config.Auth.Methods.OidcAuth.AdminGroup == "" {
-				isAdmin = config.UserDefaults.Permissions.Admin
-			}
-			user = &users.User{
-				Username:    username,
-				LoginMethod: users.LoginMethodOidc,
-			}
-			settings.ApplyUserDefaults(user)
-			if isAdmin {
-				user.Permissions.Admin = true
-			}
-			err = storage.CreateUser(*user)
-			if err != nil {
-				return http.StatusInternalServerError, err
-			}
-			user, err = store.Users.Get(username)
-			if err != nil {
-				return http.StatusInternalServerError, err
-			}
-		} else {
-			return http.StatusForbidden, fmt.Errorf("user %s does not exist and createUser is disabled. Your admin needs to create your user before you can access this application", username)
+
+		err = storage.CreateUser(users.User{
+			LoginMethod: users.LoginMethodOidc,
+			Username:    username,
+		}, false)
+		if err != nil {
+			return http.StatusInternalServerError, err
 		}
-	} else {
-		// update user admin perms
-		if isAdmin != user.Permissions.Admin && config.Auth.Methods.OidcAuth.AdminGroup != "" {
-			user.Permissions.Admin = isAdmin
-			err = store.Users.Update(user, true, "Permissions")
-			if err != nil {
-				logger.Warningf("failed to update oidc user %s admin permissions: %v", username, err)
-			}
+		user, err = store.Users.Get(username)
+		if err != nil {
+			return http.StatusInternalServerError, err
 		}
 	}
 	if user.LoginMethod != users.LoginMethodOidc {
-		return http.StatusForbidden, errors.ErrWrongLoginMethod
+		logger.Warningf("user %s is not allowed to login with oidc authentication, bypassing and updating login method", user.Username)
+		user.LoginMethod = users.LoginMethodOidc
+		err = store.Users.Update(user, true, "LoginMethod")
+		if err != nil {
+			logger.Debug(err.Error())
+		}
+		//return http.StatusForbidden, fmt.Errorf("user %s is not allowed to login with OIDC", username)
 	}
-
-	// Sync OIDC groups with access control system
-	if err = store.Access.SyncUserGroups(username, groups); err != nil {
-		logger.Warningf("failed to sync oidc user %s groups: %v", username, err)
-	}
-	// Generate a signed token for the user
-	signed, err2 := makeSignedTokenAPI(user, "WEB_TOKEN_"+utils.InsecureRandomIdentifier(4), time.Hour*time.Duration(config.Auth.TokenExpirationHours), user.Permissions)
-	if err2 != nil {
+	signed, err := makeSignedTokenAPI(user, "WEB_TOKEN_"+utils.InsecureRandomIdentifier(4), time.Hour*time.Duration(config.Auth.TokenExpirationHours), user.Permissions)
+	if err != nil {
 		// Handle potential errors during token generation
-		if strings.Contains(err2.Error(), "key already exists with same name") {
-			return http.StatusConflict, fmt.Errorf("token name conflict: %v", err2)
+		if strings.Contains(err.Error(), "key already exists with same name") {
+			return http.StatusConflict, fmt.Errorf("token name conflict: %v", err)
 		}
 		return http.StatusInternalServerError, fmt.Errorf("failed to generate authentication token for user %s: %v", username, err)
 	}
@@ -359,31 +272,20 @@ func loginWithOidcUser(w http.ResponseWriter, r *http.Request, username string,
 	// or to the root ("/") if no specific redirect was requested.
 	// The 'fb_redirect' parameter is extracted from the 'state' parameter for security.
 	state := r.URL.Query().Get("state")
-
-	fbRedirect := config.Server.BaseURL // Default redirect to the base URL
+	fbRedirect := "/" // Default redirect path
 	if state != "" {
+		// Assuming state is in the format "nonce:fb_redirect"
 		parts := strings.SplitN(state, ":", 2)
-
-		// 2. Validate the nonce
-		// receivedNonce := parts[0]
-		// if receivedNonce != nonceCookie.Value {
-		//    // Handle error: nonce mismatch (possible CSRF attack)
-		//    return http.StatusBadRequest, fmt.Errorf("invalid state nonce")
-		// }
-
-		if len(parts) == 2 && parts[1] != "" {
-			// 3. Prevent Open Redirect vulnerability
-			// Ensure the redirect is to a local path.
-			potentialRedirect, err := url.QueryUnescape(parts[1])
-			if err == nil && strings.HasPrefix(potentialRedirect, "/") {
-				fbRedirect = potentialRedirect
-			} else {
-				logger.Warningf("Blocked potentially malicious redirect to: %s", parts[1])
+		if len(parts) == 2 {
+			// TODO: Validate the nonce part against the stored nonce for CSRF protection
+			// For this example, we'll just extract the redirect part
+			extractedRedirect := parts[1]
+			if extractedRedirect != "" {
+				fbRedirect = extractedRedirect
 			}
 		}
 	}
 
-	// Clean up
 	http.Redirect(w, r, fbRedirect, http.StatusFound)
 
 	// Return 0 to indicate that the response has been handled by the redirect

backend/http/oidc_test.go

@@ -1,86 +0,0 @@
-package http
-
-import (
-	"encoding/json"
-	"reflect"
-	"testing"
-)
-
-func TestUserInfoUnmarshaller(t *testing.T) {
-	tests := []struct {
-		name        string
-		jsonData    string
-		groupsClaim string
-		expected    userInfo
-	}{
-		{
-			name:        "standard groups array",
-			jsonData:    `{"name":"John","email":"john@example.com","groups":["admin","users"]}`,
-			groupsClaim: "groups",
-			expected: userInfo{
-				Name:   "John",
-				Email:  "john@example.com",
-				Groups: []string{"admin", "users"},
-			},
-		},
-		{
-			name:        "custom groups claim name",
-			jsonData:    `{"name":"Jane","email":"jane@example.com","roles":["admin","users"]}`,
-			groupsClaim: "roles",
-			expected: userInfo{
-				Name:   "Jane",
-				Email:  "jane@example.com",
-				Groups: []string{"admin", "users"},
-			},
-		},
-		{
-			name:        "groups as comma-separated string",
-			jsonData:    `{"name":"Bob","email":"bob@example.com","groups":"admin, users, guests"}`,
-			groupsClaim: "groups",
-			expected: userInfo{
-				Name:   "Bob",
-				Email:  "bob@example.com",
-				Groups: []string{"admin", "users", "guests"},
-			},
-		},
-		{
-			name:        "no groups field",
-			jsonData:    `{"name":"Alice","email":"alice@example.com"}`,
-			groupsClaim: "groups",
-			expected: userInfo{
-				Name:   "Alice",
-				Email:  "alice@example.com",
-				Groups: nil,
-			},
-		},
-		{
-			name:        "empty groups array",
-			jsonData:    `{"name":"Charlie","email":"charlie@example.com","groups":[]}`,
-			groupsClaim: "groups",
-			expected: userInfo{
-				Name:   "Charlie",
-				Email:  "charlie@example.com",
-				Groups: []string{},
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			var userdata userInfo
-			unmarshaller := &userInfoUnmarshaller{
-				userInfo:    &userdata,
-				groupsClaim: tt.groupsClaim,
-			}
-
-			err := json.Unmarshal([]byte(tt.jsonData), unmarshaller)
-			if err != nil {
-				t.Fatalf("Failed to unmarshal: %v", err)
-			}
-
-			if !reflect.DeepEqual(userdata, tt.expected) {
-				t.Errorf("Expected %+v, got %+v", tt.expected, userdata)
-			}
-		})
-	}
-}

backend/http/onlyOffice.go

@@ -7,9 +7,9 @@ import (
 	"io"
 	"net/http"
 	"net/url"
-	"path/filepath"
 	"strconv"
 	"strings"
+	"time"
 
 	jwt "github.com/golang-jwt/jwt/v4"
 	"github.com/gtsteffaniak/filebrowser/backend/adapters/fs/files"
@@ -17,9 +17,12 @@ import (
 	"github.com/gtsteffaniak/filebrowser/backend/common/utils"
 	"github.com/gtsteffaniak/filebrowser/backend/indexing"
 	"github.com/gtsteffaniak/filebrowser/backend/indexing/iteminfo"
+	"github.com/gtsteffaniak/go-cache/cache"
 	"github.com/gtsteffaniak/go-logger/logger"
 )
 
+var OnlyOfficeCache = cache.NewCache(48 * time.Hour)
+
 const (
 	onlyOfficeStatusDocumentClosedWithChanges       = 2
 	onlyOfficeStatusDocumentClosedWithNoChanges     = 4
@@ -39,107 +42,61 @@ func onlyofficeClientConfigGetHandler(w http.ResponseWriter, r *http.Request, d
 	if settings.Config.Integrations.OnlyOffice.Url == "" {
 		return http.StatusInternalServerError, errors.New("only-office integration must be configured in settings")
 	}
-
-	// Extract clean parameters from request
-	source := r.URL.Query().Get("source")
-	path := r.URL.Query().Get("path")
-
-	// Validate required parameters
-	if (path == "" || source == "") && d.fileInfo.Hash == "" {
-		logger.Errorf("OnlyOffice callback missing required parameters: source=%s, path=%s", source, path)
-		return http.StatusBadRequest, errors.New("missing required parameters: path + source/hash are required")
-	}
-	themeMode := utils.Ternary(d.user.DarkMode, "dark", "light")
-	var sourceInfo settings.Source
-	var ok bool
-	if d.fileInfo.Hash != "" {
-		sourceInfo, ok = settings.Config.Server.SourceMap[source]
-		if !ok {
-			logger.Error("OnlyOffice: source not found")
-			return http.StatusInternalServerError, fmt.Errorf("source not found")
-		}
-	} else {
-		sourceInfo, ok = settings.Config.Server.NameToSource[source]
-		if !ok {
-			logger.Error("OnlyOffice: source not found")
-			return http.StatusInternalServerError, fmt.Errorf("source not found")
-		}
-	}
-	if d.fileInfo.Hash == "" {
-		// Build file info based on whether this is a share or regular request
-		// Regular user request - need to resolve scope
-		userScope, scopeErr := settings.GetScopeFromSourceName(d.user.Scopes, source)
-		if scopeErr != nil {
-			logger.Errorf("OnlyOffice: source %s not available for user %s: %v", source, d.user.Username, scopeErr)
-			return http.StatusForbidden, fmt.Errorf("source %s is not available", source)
-		}
-		indexPath := utils.JoinPathAsUnix(userScope, path)
-		logger.Debugf("OnlyOffice user request: resolved path=%s", indexPath)
-		fileInfo, err := files.FileInfoFaster(iteminfo.FileOptions{
-			Path:   indexPath,
-			Modify: d.user.Permissions.Modify,
-			Source: source,
-			Expand: false,
-		})
-		if err != nil {
-			logger.Errorf("OnlyOffice: failed to get file info for source=%s, path=%s: %v", source, indexPath, err)
-			return errToStatus(err), err
-		}
-		d.fileInfo = *fileInfo
-	} else {
-		source = sourceInfo.Name
-		// path is index path, so we build from share path
-		path = utils.JoinPathAsUnix(d.share.Path, path)
-		if d.share.EnforceDarkLightMode == "dark" {
-			themeMode = "dark"
-		}
-		if d.share.EnforceDarkLightMode == "light" {
-			themeMode = "light"
-		}
-
-	}
-
-	// Determine file type and editing permissions
-	fileType := strings.TrimPrefix(filepath.Ext(d.fileInfo.Name), ".")
-	canEdit := iteminfo.CanEditOnlyOffice(d.user.Permissions.Modify, fileType)
-	canEditMode := utils.Ternary(canEdit, "edit", "view")
-	if d.fileInfo.Hash != "" {
-		if d.share.EnableOnlyOfficeEditing {
-			canEditMode = "edit"
-		}
-	}
-	// For shares, we need to keep track of the original relative path for the callback URL
-	var callbackPath string
-	if d.fileInfo.Hash != "" {
-		// For shares, use the original path parameter (relative to share)
-		callbackPath = r.URL.Query().Get("path")
-	} else {
-		// For regular requests, use the processed path
-		callbackPath = path
-	}
-
-	// Generate document ID for OnlyOffice
-	documentId, err := getOnlyOfficeId(d.fileInfo.RealPath)
+	encodedUrl := r.URL.Query().Get("url")
+	// Decode the URL-encoded path
+	url, err := url.QueryUnescape(encodedUrl)
 	if err != nil {
-		logger.Errorf("OnlyOffice: failed to generate document ID for source=%s, path=%s: %v", source, path, err)
-		return http.StatusNotFound, fmt.Errorf("failed to generate document ID: %v", err)
+		return http.StatusBadRequest, fmt.Errorf("invalid path encoding: %v", err)
 	}
-
-	// Build download URL that OnlyOffice server will use
-	downloadURL := buildOnlyOfficeDownloadURL(source, callbackPath, d.fileInfo.Hash, d.token)
-
-	// Build callback URL for OnlyOffice to notify us of changes
-	callbackURL := buildOnlyOfficeCallbackURL(source, callbackPath, d.fileInfo.Hash, d.token)
-
-	// Build OnlyOffice client configuration
+	// get path from url
+	pathParts := strings.Split(url, "/api/raw?files=")
+	origPathParts := strings.Split(encodedUrl, "/api/raw?files=")
+	encodedPath := origPathParts[len(origPathParts)-1]
+	sourceFile := pathParts[len(pathParts)-1]
+	sourceSplit := strings.Split(sourceFile, "::")
+	if len(sourceSplit) != 2 {
+		return http.StatusBadRequest, fmt.Errorf("invalid url path %v", url)
+	}
+	source := sourceSplit[0]
+	path := sourceSplit[1]
+	urlFirst := pathParts[0]
+	if settings.Config.Server.InternalUrl != "" {
+		urlFirst = settings.Config.Server.InternalUrl
+		replacement := strings.Split(url, "/api/raw")[0]
+		url = strings.Replace(url, replacement, settings.Config.Server.InternalUrl, 1)
+	}
+	userscope, err := settings.GetScopeFromSourceName(d.user.Scopes, source)
+	if err != nil {
+		return http.StatusForbidden, err
+	}
+	fileInfo, err := files.FileInfoFaster(iteminfo.FileOptions{
+		Path:   utils.JoinPathAsUnix(userscope, path),
+		Modify: d.user.Permissions.Modify,
+		Source: source,
+		Expand: false,
+	})
+	if err != nil {
+		return errToStatus(err), err
+	}
+	id, err := getOnlyOfficeId(source, fileInfo.Path)
+	if err != nil {
+		return http.StatusNotFound, err
+	}
+	split := strings.Split(fileInfo.Name, ".")
+	fileType := split[len(split)-1]
+	theme := "light"
+	if d.user.DarkMode {
+		theme = "dark"
+	}
+	callbackURL := fmt.Sprintf("%v/api/onlyoffice/callback?path=%v&auth=%v", urlFirst, encodedPath, d.token)
 	clientConfig := map[string]interface{}{
 		"document": map[string]interface{}{
 			"fileType": fileType,
-			"key":      documentId,
-			"title":    d.fileInfo.Name,
-			"url":      downloadURL,
+			"key":      id,
+			"title":    fileInfo.Name,
+			"url":      url + "&auth=" + d.token,
 			"permissions": map[string]interface{}{
-				"edit":     canEditMode,
+				"edit":     d.user.Permissions.Modify,
 				"download": true,
 				"print":    true,
 			},
@@ -153,204 +110,96 @@ func onlyofficeClientConfigGetHandler(w http.ResponseWriter, r *http.Request, d
 			"customization": map[string]interface{}{
 				"autosave":  true,
 				"forcesave": true,
-				"uiTheme":   themeMode,
+				"uiTheme":   theme,
 			},
 			"lang": d.user.Locale,
-			"mode": canEditMode,
+			"mode": "edit",
 		},
 	}
-
-	// Sign configuration with JWT if secret is configured
 	if settings.Config.Integrations.OnlyOffice.Secret != "" {
 		token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims(clientConfig))
 		signature, err := token.SignedString([]byte(settings.Config.Integrations.OnlyOffice.Secret))
 		if err != nil {
-			logger.Errorf("OnlyOffice: failed to sign JWT: %v", err)
-			return http.StatusInternalServerError, fmt.Errorf("failed to sign configuration")
+			return http.StatusInternalServerError, fmt.Errorf("failed to sign JWT")
 		}
 		clientConfig["token"] = signature
 	}
-
 	return renderJSON(w, r, clientConfig)
 }
 
-// buildOnlyOfficeDownloadURL constructs the download URL that OnlyOffice server will use to fetch the file
-func buildOnlyOfficeDownloadURL(source, path, hash, token string) string {
-	// Determine base URL (internal URL takes priority for OnlyOffice server communication)
-	baseURL := settings.Config.Server.BaseURL
-	if settings.Config.Server.InternalUrl != "" {
-		baseURL = settings.Config.Server.InternalUrl + settings.Config.Server.BaseURL
-	}
-
-	var downloadURL string
-	if hash != "" {
-		// Share download URL - don't expose source name, just use the path relative to share
-		filesParam := url.QueryEscape(path)
-		downloadURL = fmt.Sprintf("%s/public/api/raw?files=%s&hash=%s&token=%s&auth=%s",
-			strings.TrimSuffix(baseURL, "/"), filesParam, hash, token, token)
-	} else {
-		// Regular download URL - include source for non-share requests
-		filesParam := url.QueryEscape(source + "::" + path)
-		downloadURL = fmt.Sprintf("%s/api/raw?files=%s&auth=%s",
-			strings.TrimSuffix(baseURL, "/"), filesParam, token)
-	}
-
-	return downloadURL
-}
-
-// buildOnlyOfficeCallbackURL constructs the callback URL that OnlyOffice server will use to notify us of changes
-func buildOnlyOfficeCallbackURL(source, path, hash, token string) string {
-	baseURL := settings.Config.Server.BaseURL
-	if settings.Config.Server.InternalUrl != "" {
-		baseURL = settings.Config.Server.InternalUrl + settings.Config.Server.BaseURL
-	}
-
-	var callbackURL string
-	if hash != "" {
-		// Share callback URL - use public API and don't expose source, use path relative to share
-		params := url.Values{}
-		params.Set("hash", hash)
-		params.Set("path", path) // This should be the path relative to the share, not the full filesystem path
-		params.Set("auth", token)
-
-		callbackURL = fmt.Sprintf("%s/public/api/onlyoffice/callback?%s",
-			strings.TrimSuffix(baseURL, "/"), params.Encode())
-	} else {
-		// Regular callback URL - include source for non-share requests
-		params := url.Values{}
-		params.Set("source", source)
-		params.Set("path", path)
-		params.Set("auth", token)
-
-		callbackURL = fmt.Sprintf("%s/api/onlyoffice/callback?%s",
-			strings.TrimSuffix(baseURL, "/"), params.Encode())
-	}
-
-	return callbackURL
-}
-
 func onlyofficeCallbackHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
-	// Parse OnlyOffice callback data
 	body, err := io.ReadAll(r.Body)
 	if err != nil {
-		logger.Errorf("OnlyOffice callback: failed to read request body: %v", err)
 		return http.StatusInternalServerError, err
 	}
-
 	var data OnlyOfficeCallback
 	err = json.Unmarshal(body, &data)
 	if err != nil {
-		logger.Errorf("OnlyOffice callback: failed to parse JSON: %v", err)
 		return http.StatusInternalServerError, err
 	}
 
-	// Extract clean parameters from query string
-	source := r.URL.Query().Get("source")
-	path := r.URL.Query().Get("path")
-
-	// Validate required parameters
-	if (path == "" || source == "") && d.fileInfo.Hash == "" {
-		logger.Errorf("OnlyOffice callback missing required parameters: source=%s, path=%s", source, path)
-		return http.StatusBadRequest, errors.New("missing required parameters: path + source/hash are required")
+	encodedPath := r.URL.Query().Get("path")
+	pathParts := strings.Split(encodedPath, "::")
+	if len(pathParts) < 2 {
+		return http.StatusBadRequest, fmt.Errorf("invalid path encoding: %v", err)
 	}
-	var sourceInfo settings.Source
-	var ok bool
-	if d.fileInfo.Hash != "" {
-		sourceInfo, ok = settings.Config.Server.SourceMap[source]
-		if !ok {
-			logger.Error("OnlyOffice: source not found")
-			return http.StatusInternalServerError, fmt.Errorf("source not found")
-		}
-	} else {
-		sourceInfo, ok = settings.Config.Server.NameToSource[source]
-		if !ok {
-			logger.Error("OnlyOffice: source not found")
-			return http.StatusInternalServerError, fmt.Errorf("source not found")
-		}
+	source := pathParts[0]
+	if source == "" {
+		source = settings.Config.Server.DefaultSource.Name
 	}
-
-	if d.fileInfo.Hash == "" {
-		// Regular user request - need to resolve scope
-		userScope, scopeErr := settings.GetScopeFromSourceName(d.user.Scopes, source)
-		if scopeErr != nil {
-			logger.Errorf("OnlyOffice callback: source %s not available for user %s: %v", source, d.user.Username, scopeErr)
-			return http.StatusForbidden, fmt.Errorf("source %s is not available", source)
-		}
-		path = utils.JoinPathAsUnix(userScope, path)
-	} else {
-		source = sourceInfo.Name
-		// path is index path, so we build from share path
-		path = utils.JoinPathAsUnix(d.share.Path, path)
+	// Decode the URL-encoded path
+	path, err := url.QueryUnescape(pathParts[1])
+	if err != nil {
+		return http.StatusBadRequest, fmt.Errorf("invalid path encoding: %v", err)
 	}
-	// Handle document closure - clean up document key cache
 	if data.Status == onlyOfficeStatusDocumentClosedWithChanges ||
 		data.Status == onlyOfficeStatusDocumentClosedWithNoChanges {
-		// Refer to OnlyOffice documentation:
+		// Refer to only-office documentation
 		// - https://api.onlyoffice.com/editors/coedit
 		// - https://api.onlyoffice.com/editors/callback
 		//
 		// When the document is fully closed by all editors,
-		// the document key should no longer be re-used.
-		logger.Debugf("OnlyOffice: document closed, cleaning up document ID for source=%s, path=%s", source, path)
+		// then the document key should no longer be re-used.
 		deleteOfficeId(source, path)
 	}
 
-	// Handle document save operations
 	if data.Status == onlyOfficeStatusDocumentClosedWithChanges ||
 		data.Status == onlyOfficeStatusForceSaveWhileDocumentStillOpen {
-
-		// Verify user has modify permissions
 		if !d.user.Permissions.Modify {
-			logger.Warningf("OnlyOffice callback: user %s lacks modify permissions for source=%s, path=%s",
-				d.user.Username, source, path)
 			return http.StatusForbidden, nil
 		}
 
-		// Download the updated document from OnlyOffice server
 		doc, err := http.Get(data.URL)
 		if err != nil {
-			logger.Errorf("OnlyOffice callback: failed to download updated document: %v", err)
 			return http.StatusInternalServerError, err
 		}
 		defer doc.Body.Close()
 
-		// Resolve file path for writing (same logic as in config handler)
-		var resolvedPath string
-		if d.fileInfo.Hash == "" {
-			// Regular user request - need to resolve scope
-			userScope, scopeErr := settings.GetScopeFromSourceName(d.user.Scopes, source)
-			if scopeErr != nil {
-				logger.Errorf("OnlyOffice callback: source %s not available for user %s: %v",
-					source, d.user.Username, scopeErr)
-				return http.StatusForbidden, fmt.Errorf("source %s is not available", source)
-			}
-			resolvedPath = utils.JoinPathAsUnix(userScope, path)
-		}
-
-		// Write the updated document
 		fileOpts := iteminfo.FileOptions{
-			Path:   resolvedPath,
+			Path:   path,
 			Source: source,
 		}
 		writeErr := files.WriteFile(fileOpts, doc.Body)
 		if writeErr != nil {
-			logger.Errorf("OnlyOffice callback: failed to write updated document: %v", writeErr)
 			return http.StatusInternalServerError, writeErr
 		}
-
 	}
 
-	// Return success response to OnlyOffice server
 	resp := map[string]int{
 		"error": 0,
 	}
 	return renderJSON(w, r, resp)
 }
 
-func getOnlyOfficeId(realpath string) (string, error) {
+func getOnlyOfficeId(source, path string) (string, error) {
+	idx := indexing.GetIndex(source)
+	if idx == nil {
+		return "", fmt.Errorf("source not found")
+	}
+	realpath, _, _ := idx.GetRealPath(path)
 	// error is intentionally ignored in order treat errors
 	// the same as a cache-miss
-	cachedDocumentKey, ok := utils.OnlyOfficeCache.Get(realpath).(string)
+	cachedDocumentKey, ok := OnlyOfficeCache.Get(realpath).(string)
 	if ok {
 		return cachedDocumentKey, nil
 	}
@@ -364,5 +213,31 @@ func deleteOfficeId(source, path string) {
 		return
 	}
 	realpath, _, _ := idx.GetRealPath(path)
-	utils.OnlyOfficeCache.Delete(realpath)
+	OnlyOfficeCache.Delete(realpath)
+}
+
+func onlyofficeGetTokenHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
+	// get config from body
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		return http.StatusInternalServerError, err
+	}
+	defer r.Body.Close()
+
+	var payload map[string]interface{}
+	// marshall to struct
+	err = json.Unmarshal(body, &payload)
+	if err != nil {
+		return http.StatusInternalServerError, err
+	}
+
+	if settings.Config.Integrations.OnlyOffice.Secret != "" {
+		token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims(payload))
+		ss, err := token.SignedString([]byte(settings.Config.Integrations.OnlyOffice.Secret))
+		if err != nil {
+			return 500, errors.New("could not generate a new jwt")
+		}
+		return renderJSON(w, r, map[string]string{"token": ss})
+	}
+	return 400, fmt.Errorf("bad request")
 }

backend/http/preview.go

@@ -46,11 +46,15 @@ func previewHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (
 	}
 	path := r.URL.Query().Get("path")
 	source := r.URL.Query().Get("source")
-	var err error
-	// decode url encoded source name
-	source, err = url.QueryUnescape(source)
-	if err != nil {
-		return http.StatusBadRequest, fmt.Errorf("invalid source encoding: %v", err)
+	if source == "" {
+		source = settings.Config.Server.DefaultSource.Name
+	} else {
+		var err error
+		// decode url encoded source name
+		source, err = url.QueryUnescape(source)
+		if err != nil {
+			return http.StatusBadRequest, fmt.Errorf("invalid source encoding: %v", err)
+		}
 	}
 	if path == "" {
 		return http.StatusBadRequest, fmt.Errorf("invalid request path")
@@ -60,17 +64,15 @@ func previewHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (
 		return http.StatusForbidden, err
 	}
 	fileInfo, err := files.FileInfoFaster(iteminfo.FileOptions{
-		Access:   store.Access,
-		Username: d.user.Username,
-		Path:     utils.JoinPathAsUnix(userscope, path),
-		Modify:   d.user.Permissions.Modify,
-		Source:   source,
-		Expand:   true,
+		Path:   utils.JoinPathAsUnix(userscope, path),
+		Modify: d.user.Permissions.Modify,
+		Source: source,
+		Expand: true,
 	})
 	if err != nil {
 		return errToStatus(err), err
 	}
-	d.fileInfo = *fileInfo
+	d.fileInfo = fileInfo
 	return previewHelperFunc(w, r, d)
 }
 
@@ -95,8 +97,8 @@ func rawFileHandler(w http.ResponseWriter, r *http.Request, file iteminfo.Extend
 
 func previewHelperFunc(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
 	previewSize := r.URL.Query().Get("size")
-	if !(previewSize == "large" || previewSize == "original") {
-		previewSize = "small"
+	if previewSize != "small" {
+		previewSize = "large"
 	}
 	if d.fileInfo.Type == "directory" {
 		return http.StatusBadRequest, fmt.Errorf("can't create preview for directory")
@@ -145,7 +147,6 @@ func previewHelperFunc(w http.ResponseWriter, r *http.Request, d *requestContext
 		return http.StatusInternalServerError, err
 	}
 	w.Header().Set("Cache-Control", "private")
-	w.Header().Set("Content-Type", "image/jpeg")
-	http.ServeContent(w, r, d.fileInfo.Name+"-preview.jpg", d.fileInfo.ModTime, bytes.NewReader(previewImg))
+	http.ServeContent(w, r, d.fileInfo.RealPath, d.fileInfo.ModTime, bytes.NewReader(previewImg))
 	return 0, nil
 }

backend/http/public.go

@@ -7,8 +7,11 @@ import (
 	"net/url"
 	"strings"
 
+	"github.com/gtsteffaniak/filebrowser/backend/adapters/fs/files"
 	"github.com/gtsteffaniak/filebrowser/backend/common/settings"
 	"github.com/gtsteffaniak/filebrowser/backend/common/utils"
+	"github.com/gtsteffaniak/filebrowser/backend/database/users"
+	"github.com/gtsteffaniak/filebrowser/backend/indexing/iteminfo"
 	"github.com/gtsteffaniak/go-logger/logger"
 
 	_ "github.com/gtsteffaniak/filebrowser/backend/swagger/docs"
@@ -20,7 +23,7 @@ import (
 // @Tags Resources
 // @Accept json
 // @Produce json
-// @Param files query string false "if specified, only the files in the list will be downloaded. eg. files=/file1||/folder/file2"
+// @Param files query string true "a list of files in the following format 'filename' and separated by '||' with additional items in the list. (required)"
 // @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' and 'tar.gz'. Default is 'zip'."
 // @Success 200 {file} file "Raw file or directory content, or archive for multiple files"
@@ -30,61 +33,47 @@ import (
 // @Failure 500 {object} map[string]string "Internal server error"
 // @Router /public/dl [get]
 func publicRawHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
-	if d.share.DownloadsLimit > 0 && d.share.Downloads >= d.share.DownloadsLimit {
-		return http.StatusForbidden, fmt.Errorf("share downloads limit reached")
-	}
-	d.share.Mu.Lock()
-	d.share.Downloads++
-	d.share.Mu.Unlock()
 	encodedFiles := r.URL.Query().Get("files")
-
-	// Decode the URL-encoded path - use PathUnescape to preserve + as literal character
-	f, err := url.PathUnescape(encodedFiles)
+	// Decode the URL-encoded path
+	f, err := url.QueryUnescape(encodedFiles)
 	if err != nil {
 		return http.StatusBadRequest, fmt.Errorf("invalid path encoding: %v", err)
 	}
 
-	// Get the actual source name from the share's source mapping
-	sourceInfo, ok := settings.Config.Server.SourceMap[d.share.Source]
+	fileInfo, ok := d.raw.(iteminfo.ExtendedFileInfo)
 	if !ok {
-		return http.StatusInternalServerError, fmt.Errorf("source not found for share")
+		logger.Error("public share handler: failed to assert type files.FileInfo")
+		return http.StatusInternalServerError, fmt.Errorf("failed to assert type files.FileInfo")
 	}
-	actualSourceName := sourceInfo.Name
-
 	fileList := []string{}
 	for _, file := range strings.Split(f, "||") {
-		// Check if file already contains source prefix (source::path format)
-		if strings.Contains(file, "::") {
-			splitFile := strings.SplitN(file, "::", 2)
-			if len(splitFile) == 2 {
-				source := splitFile[0]
-				path := splitFile[1]
-				// Join the share path with the requested path
-				filePath := utils.JoinPathAsUnix(d.share.Path, path)
-				fileList = append(fileList, source+"::"+filePath)
-			} else {
-				// Fallback: treat as plain path
-				filePath := utils.JoinPathAsUnix(d.share.Path, file)
-				fileList = append(fileList, actualSourceName+"::"+filePath)
-			}
-		} else {
-			// Plain path without source prefix - use the actual source name from share
-			filePath := utils.JoinPathAsUnix(d.share.Path, file)
-			fileList = append(fileList, actualSourceName+"::"+filePath)
-		}
+		fileList = append(fileList, fileInfo.Source+"::"+fileInfo.Path+file)
 	}
-
 	var status int
 	status, err = rawFilesHandler(w, r, d, fileList)
 	if err != nil {
-		logger.Errorf("public share handler: error processing filelist: '%v' with error %v", f, err)
+		logger.Errorf("public share handler: error processing filelist: %v", err)
 		return status, fmt.Errorf("error processing filelist: %v", f)
 	}
 	return status, nil
 }
 
 func publicShareHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
-	return renderJSON(w, r, d.fileInfo)
+	file, ok := d.raw.(iteminfo.ExtendedFileInfo)
+	if !ok {
+		return http.StatusInternalServerError, fmt.Errorf("failed to assert type iteminfo.FileInfo")
+	}
+	file.Path = strings.TrimPrefix(file.Path, d.share.Path)
+	return renderJSON(w, r, file)
+}
+
+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.
+	status, err := renderJSON(w, r, users.PublicUser)
+	if err != nil {
+		http.Error(w, http.StatusText(status), status)
+	}
 }
 
 // health godoc
@@ -120,10 +109,39 @@ func healthHandler(w http.ResponseWriter, r *http.Request) {
 // @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/public/preview [get]
+// @Router /api/preview [get]
 func publicPreviewHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
-	if config.Server.DisablePreviews || d.share.DisableThumbnails {
+	if config.Server.DisablePreviews {
 		return http.StatusNotImplemented, fmt.Errorf("preview is disabled")
 	}
+	path := r.URL.Query().Get("path")
+	source := r.URL.Query().Get("source")
+	if source == "" {
+		source = settings.Config.Server.DefaultSource.Name
+	} else {
+		var err error
+		// decode url encoded source name
+		source, err = url.QueryUnescape(source)
+		if err != nil {
+			return http.StatusBadRequest, fmt.Errorf("invalid source encoding: %v", err)
+		}
+	}
+	if path == "" {
+		return http.StatusBadRequest, fmt.Errorf("invalid request path")
+	}
+	fileInfo, err := files.FileInfoFaster(iteminfo.FileOptions{
+		Path:   utils.JoinPathAsUnix(d.share.Path, path),
+		Modify: d.user.Permissions.Modify,
+		Source: source,
+		Expand: true,
+	})
+	if err != nil {
+		logger.Debugf("public preview handler: error getting file info: %v", err)
+		return 400, fmt.Errorf("file not found")
+	}
+	if fileInfo.Type == "directory" {
+		return http.StatusBadRequest, fmt.Errorf("can't create preview for directory")
+	}
+	d.fileInfo = fileInfo
 	return previewHelperFunc(w, r, d)
 }

backend/http/raw.go

@@ -4,7 +4,6 @@ import (
 	"archive/tar"
 	"archive/zip"
 	"compress/gzip"
-	"context"
 	"errors"
 	"fmt"
 	"io"
@@ -14,49 +13,12 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/gtsteffaniak/filebrowser/backend/adapters/fs/files"
 	"github.com/gtsteffaniak/filebrowser/backend/common/settings"
 	"github.com/gtsteffaniak/filebrowser/backend/common/utils"
 	"github.com/gtsteffaniak/filebrowser/backend/indexing"
-	"github.com/gtsteffaniak/filebrowser/backend/indexing/iteminfo"
 	"github.com/gtsteffaniak/go-logger/logger"
-	"golang.org/x/time/rate"
 )
 
-// throttledReadSeeker is a wrapper around an io.ReadSeeker that throttles the reading speed.
-type throttledReadSeeker struct {
-	rs      io.ReadSeeker
-	limiter *rate.Limiter
-	ctx     context.Context
-}
-
-// newThrottledReadSeeker creates a new throttledReadSeeker.
-func newThrottledReadSeeker(rs io.ReadSeeker, limit rate.Limit, burst int, ctx context.Context) *throttledReadSeeker {
-	return &throttledReadSeeker{
-		rs:      rs,
-		limiter: rate.NewLimiter(limit, burst),
-		ctx:     ctx,
-	}
-}
-
-func (r *throttledReadSeeker) Read(p []byte) (n int, err error) {
-	n, err = r.rs.Read(p)
-	if n > 0 {
-		if waitErr := r.limiter.WaitN(r.ctx, n); waitErr != nil {
-			// The original error (like io.EOF) is potentially more important
-			// than the context error.
-			if err == nil {
-				err = waitErr
-			}
-		}
-	}
-	return
-}
-
-func (r *throttledReadSeeker) Seek(offset int64, whence int) (int64, error) {
-	return r.rs.Seek(offset, whence)
-}
-
 func setContentDisposition(w http.ResponseWriter, r *http.Request, fileName string) {
 	if r.URL.Query().Get("inline") == "true" {
 		w.Header().Set("Content-Disposition", "inline; filename*=utf-8''"+url.PathEscape(fileName))
@@ -82,7 +44,12 @@ func setContentDisposition(w http.ResponseWriter, r *http.Request, fileName stri
 // @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) {
-	files := r.URL.Query().Get("files")
+	encodedFiles := r.URL.Query().Get("files")
+	// Decode the URL-encoded path
+	files, err := url.QueryUnescape(encodedFiles)
+	if err != nil {
+		return http.StatusBadRequest, fmt.Errorf("invalid path encoding: %v", err)
+	}
 	fileList := strings.Split(files, "||")
 	return rawFilesHandler(w, r, d, fileList)
 }
@@ -94,33 +61,24 @@ func addFile(path string, d *requestContext, tarWriter *tar.Writer, zipWriter *z
 	}
 	source := splitFile[0]
 	path = splitFile[1]
-
 	var err error
-	if d.share == nil {
-		var userScope string
+	userScope := "/"
+	if d.user.Username != "publicUser" {
 		userScope, err = settings.GetScopeFromSourceName(d.user.Scopes, source)
-		if err != nil {
+		if d.share == nil && err != nil {
 			return fmt.Errorf("source %s is not available for user %s", source, d.user.Username)
 		}
-		path = utils.JoinPathAsUnix(userScope, path)
 	}
-	// For shares, the path is already correctly resolved by publicRawHandler
 
 	idx := indexing.GetIndex(source)
 	if idx == nil {
 		return fmt.Errorf("source %s is not available", source)
 	}
-	_, err = files.FileInfoFaster(iteminfo.FileOptions{
-		Access:   store.Access,
-		Username: d.user.Username,
-		Path:     path,
-		Source:   source,
-		Expand:   false,
-	})
+
+	realPath, _, err := idx.GetRealPath(userScope, path)
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to get real path for %s: %v", path, err)
 	}
-	realPath, _, _ := idx.GetRealPath(path)
 	info, err := os.Stat(realPath)
 	if err != nil {
 		return err
@@ -174,20 +132,15 @@ func addFile(path string, d *requestContext, tarWriter *tar.Writer, zipWriter *z
 			}
 			return addSingleFile(filePath, relPath, zipWriter, tarWriter)
 		})
-	} else {
-		// For a single file, use the base name as the archive path
-		return addSingleFile(realPath, baseName, zipWriter, tarWriter)
 	}
+
+	// For a single file, use the base name as the archive path
+	return addSingleFile(realPath, baseName, zipWriter, tarWriter)
 }
 
 func addSingleFile(realPath, archivePath string, zipWriter *zip.Writer, tarWriter *tar.Writer) error {
 	file, err := os.Open(realPath)
 	if err != nil {
-		// If we get "is a directory" error, this is likely a symlink to a directory
-		// that wasn't properly detected. Skip it gracefully.
-		if strings.Contains(err.Error(), "is a directory") {
-			return nil
-		}
 		return err
 	}
 	defer file.Close()
@@ -197,11 +150,6 @@ func addSingleFile(realPath, archivePath string, zipWriter *zip.Writer, tarWrite
 		return err
 	}
 
-	// Double-check if this is actually a directory (in case of symlinks)
-	if info.IsDir() {
-		return nil
-	}
-
 	if tarWriter != nil {
 		header, err := tar.FileInfoHeader(info, "")
 		if err != nil {
@@ -240,23 +188,20 @@ func rawFilesHandler(w http.ResponseWriter, r *http.Request, d *requestContext,
 
 	firstFileSource := splitFile[0]
 	firstFilePath := splitFile[1]
-	// decode url encoded source name
-	var err error
-	var userscope string
 	fileName := filepath.Base(firstFilePath)
-	if d.share == nil {
+	var err error
+	userscope := "/"
+	if d.user.Username != "publicUser" {
 		userscope, err = settings.GetScopeFromSourceName(d.user.Scopes, firstFileSource)
 		if err != nil {
 			return http.StatusForbidden, err
 		}
-		firstFilePath = utils.JoinPathAsUnix(userscope, firstFilePath)
 	}
-	// For shares, the path is already correctly resolved by publicRawHandler
 	idx := indexing.GetIndex(firstFileSource)
 	if idx == nil {
 		return http.StatusInternalServerError, fmt.Errorf("source %s is not available", firstFileSource)
 	}
-	realPath, isDir, err := idx.GetRealPath(firstFilePath)
+	realPath, isDir, err := idx.GetRealPath(userscope, firstFilePath)
 	if err != nil {
 		return http.StatusInternalServerError, err
 	}
@@ -291,15 +236,7 @@ func rawFilesHandler(w http.ResponseWriter, r *http.Request, d *requestContext,
 		}
 		// serve content allows for range requests.
 		// video scrubbing, etc.
-		var reader io.ReadSeeker = fd
-		if d.share != nil && d.share.MaxBandwidth > 0 {
-			// convert KB/s to B/s
-			limit := rate.Limit(d.share.MaxBandwidth * 1024)
-			// burst size can be the same as limit
-			burst := d.share.MaxBandwidth * 1024
-			reader = newThrottledReadSeeker(fd, limit, burst, r.Context())
-		}
-		http.ServeContent(w, r, fileName, fileInfo.ModTime(), reader)
+		http.ServeContent(w, r, fileName, fileInfo.ModTime(), fd)
 		return 200, nil
 	}
 
@@ -367,15 +304,7 @@ func rawFilesHandler(w http.ResponseWriter, r *http.Request, d *requestContext,
 	w.Header().Set("Content-Type", "application/octet-stream")
 
 	// Stream the file
-	var reader io.Reader = fd
-	if d.share != nil && d.share.MaxBandwidth > 0 {
-		// convert KB/s to B/s
-		limit := rate.Limit(d.share.MaxBandwidth * 1024)
-		// burst size can be the same as limit
-		burst := d.share.MaxBandwidth * 1024
-		reader = newThrottledReadSeeker(fd, limit, burst, r.Context())
-	}
-	_, err = io.Copy(w, reader)
+	_, err = io.Copy(w, fd)
 	os.Remove(archiveData) // Remove the file after streaming
 	if err != nil {
 		logger.Errorf("Failed to copy archive data to response: %v", err)
@@ -394,31 +323,26 @@ func computeArchiveSize(fileList []string, d *requestContext) (int64, error) {
 		}
 		source := splitFile[0]
 		path := splitFile[1]
-		var err error
 		idx := indexing.GetIndex(source)
 		if idx == nil {
 			return 0, fmt.Errorf("source %s is not available", source)
 		}
-		var userScope string
-		if d.share == nil {
+		var err error
+		userScope := "/"
+		if d.user.Username != "publicUser" {
 			userScope, err = settings.GetScopeFromSourceName(d.user.Scopes, source)
-			if err != nil {
+			if d.share == nil && err != nil {
 				return 0, fmt.Errorf("source %s is not available for user %s", source, d.user.Username)
 			}
-			path = utils.JoinPathAsUnix(userScope, path)
 		}
-		// For shares, the path is already correctly resolved by publicRawHandler
-		realPath, isDir, err := idx.GetRealPath(path)
+		realPath, isDir, err := idx.GetRealPath(userScope, path)
 		if err != nil {
 			return http.StatusInternalServerError, err
 		}
 		indexPath := idx.MakeIndexPath(realPath)
 		info, ok := idx.GetReducedMetadata(indexPath, isDir)
 		if !ok {
-			info, err = idx.GetFsDirInfo(indexPath)
-			if err != nil {
-				return 0, fmt.Errorf("failed to get file info for %s : %v", path, err)
-			}
+			return 0, fmt.Errorf("failed to get metadata info for %s", path)
 		}
 		estimatedSize += info.Size
 	}

backend/http/resource.go

@@ -2,10 +2,7 @@ package http
 
 import (
 	"context"
-	"crypto/md5"
-	"encoding/hex"
 	"fmt"
-	"io"
 	"net/http"
 	"net/url"
 	"os"
@@ -15,7 +12,6 @@ import (
 	"strings"
 
 	"github.com/gtsteffaniak/filebrowser/backend/adapters/fs/files"
-	"github.com/gtsteffaniak/filebrowser/backend/adapters/fs/fileutils"
 	"github.com/gtsteffaniak/filebrowser/backend/common/errors"
 	"github.com/gtsteffaniak/filebrowser/backend/common/settings"
 	"github.com/gtsteffaniak/filebrowser/backend/common/utils"
@@ -25,35 +21,6 @@ import (
 	"github.com/gtsteffaniak/go-logger/logger"
 )
 
-// validateMoveOperation checks if a move/rename operation is valid at the HTTP level
-// It prevents moving a directory into itself or its subdirectories
-func validateMoveOperation(src, dst string, isSrcDir bool) error {
-	// Clean and normalize paths
-	src = filepath.Clean(src)
-	dst = filepath.Clean(dst)
-
-	// If source is a directory, check if destination is within source
-	if isSrcDir {
-		// Get the parent directory of the destination
-		dstParent := filepath.Dir(dst)
-
-		// Check if destination parent is the source directory or a subdirectory of it
-		if strings.HasPrefix(dstParent+string(filepath.Separator), src+string(filepath.Separator)) || dstParent == src {
-			return fmt.Errorf("cannot move directory '%s' to a location within itself: '%s'", src, dst)
-		}
-	}
-
-	// Check if destination parent directory exists
-	dstParent := filepath.Dir(dst)
-	if dstParent != "." && dstParent != "/" {
-		if _, err := os.Stat(dstParent); os.IsNotExist(err) {
-			return fmt.Errorf("destination directory does not exist: '%s'", dstParent)
-		}
-	}
-
-	return nil
-}
-
 // resourceGetHandler retrieves information about a resource.
 // @Summary Get resource information
 // @Description Returns metadata and optionally file contents for a specified resource path.
@@ -61,7 +28,8 @@ func validateMoveOperation(src, dst string, isSrcDir bool) error {
 // @Accept json
 // @Produce json
 // @Param path query string true "Path to the resource"
-// @Param source query string true "Source name for the desired source, default is used if not provided"
+// @Param source query string false "Source name for the desired source, default is used if not provided"
+// @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} iteminfo.FileInfo "Resource metadata"
@@ -71,32 +39,32 @@ func validateMoveOperation(src, dst string, isSrcDir bool) error {
 func resourceGetHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
 	encodedPath := r.URL.Query().Get("path")
 	source := r.URL.Query().Get("source")
+	if source == "" {
+		source = config.Server.DefaultSource.Name
+	} else {
+		var err error
+		// decode url encoded source name
+		source, err = url.QueryUnescape(source)
+		if err != nil {
+			return http.StatusBadRequest, fmt.Errorf("invalid source encoding: %v", err)
+		}
+	}
 	// Decode the URL-encoded path
 	path, err := url.QueryUnescape(encodedPath)
 	if err != nil {
 		return http.StatusBadRequest, fmt.Errorf("invalid path encoding: %v", err)
 	}
-	source, err = url.QueryUnescape(source)
-	if err != nil {
-		return http.StatusBadRequest, fmt.Errorf("invalid source encoding: %v", err)
-	}
 	userscope, err := settings.GetScopeFromSourceName(d.user.Scopes, source)
 	if err != nil {
 		return http.StatusForbidden, err
 	}
 	scopePath := utils.JoinPathAsUnix(userscope, path)
-	getContent := r.URL.Query().Get("content") == "true"
-	if d.share != nil && d.share.DisableFileViewer {
-		getContent = false
-	}
 	fileInfo, err := files.FileInfoFaster(iteminfo.FileOptions{
-		Access:   store.Access,
-		Username: d.user.Username,
-		Path:     scopePath,
-		Modify:   d.user.Permissions.Modify,
-		Source:   source,
-		Expand:   true,
-		Content:  getContent,
+		Path:    scopePath,
+		Modify:  d.user.Permissions.Modify,
+		Source:  source,
+		Expand:  true,
+		Content: r.URL.Query().Get("content") == "true",
 	})
 	if err != nil {
 		return errToStatus(err), err
@@ -135,7 +103,8 @@ func resourceGetHandler(w http.ResponseWriter, r *http.Request, d *requestContex
 // @Accept json
 // @Produce json
 // @Param path query string true "Path to the resource"
-// @Param source query string true "Source name for the desired source, default is used if not provided"
+// @Param source query string false "Source name for the desired source, default is used if not provided"
+// @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"
@@ -145,11 +114,15 @@ func resourceDeleteHandler(w http.ResponseWriter, r *http.Request, d *requestCon
 	// TODO source := r.URL.Query().Get("source")
 	encodedPath := r.URL.Query().Get("path")
 	source := r.URL.Query().Get("source")
-	var err error
-	// decode url encoded source name
-	source, err = url.QueryUnescape(source)
-	if err != nil {
-		return http.StatusBadRequest, fmt.Errorf("invalid source encoding: %v", err)
+	if source == "" {
+		source = config.Server.DefaultSource.Name
+	} else {
+		var err error
+		// decode url encoded source name
+		source, err = url.QueryUnescape(source)
+		if err != nil {
+			return http.StatusBadRequest, fmt.Errorf("invalid source encoding: %v", err)
+		}
 	}
 	// Decode the URL-encoded path
 	path, err := url.QueryUnescape(encodedPath)
@@ -164,19 +137,17 @@ func resourceDeleteHandler(w http.ResponseWriter, r *http.Request, d *requestCon
 		return http.StatusForbidden, err
 	}
 	fileInfo, err := files.FileInfoFaster(iteminfo.FileOptions{
-		Access:   store.Access,
-		Username: d.user.Username,
-		Path:     utils.JoinPathAsUnix(userscope, path),
-		Source:   source,
-		Modify:   d.user.Permissions.Modify,
-		Expand:   false,
+		Path:   utils.JoinPathAsUnix(userscope, path),
+		Source: source,
+		Modify: d.user.Permissions.Modify,
+		Expand: false,
 	})
 	if err != nil {
 		return errToStatus(err), err
 	}
 
 	// delete thumbnails
-	preview.DelThumbs(r.Context(), *fileInfo)
+	preview.DelThumbs(r.Context(), fileInfo)
 
 	err = files.DeleteFiles(source, fileInfo.RealPath, filepath.Dir(fileInfo.RealPath))
 	if err != nil {
@@ -192,8 +163,8 @@ func resourceDeleteHandler(w http.ResponseWriter, r *http.Request, d *requestCon
 // @Tags Resources
 // @Accept json
 // @Produce json
-// @Param path query string true "url encoded destination path where to place the files inside the destination source, a directory must end in / to create a directory"
-// @Param source query string true "Name for the desired filebrowser destination source name, default is used if not provided"
+// @Param path query string true "Destination path where to place the files inside the destination source, a directory must end in / to create a directory"
+// @Param source query string false "Name for the desired filebrowser destination source name, 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"
@@ -204,136 +175,37 @@ func resourceDeleteHandler(w http.ResponseWriter, r *http.Request, d *requestCon
 func resourcePostHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
 	path := r.URL.Query().Get("path")
 	source := r.URL.Query().Get("source")
-	var err error
-	// decode url encoded source name
-	source, err = url.QueryUnescape(source)
-	if err != nil {
-		logger.Debugf("invalid source encoding: %v", err)
-		return http.StatusBadRequest, fmt.Errorf("invalid source encoding: %v", err)
-	}
-	path, err = url.QueryUnescape(path)
-	if err != nil {
-		logger.Debugf("invalid path encoding: %v", err)
-		return http.StatusBadRequest, fmt.Errorf("invalid path encoding: %v", err)
+	if source == "" {
+		source = config.Server.DefaultSource.Name
+	} else {
+		var err error
+		// decode url encoded source name
+		source, err = url.QueryUnescape(source)
+		if err != nil {
+			return http.StatusBadRequest, fmt.Errorf("invalid source encoding: %v", err)
+		}
 	}
 	if !d.user.Permissions.Modify {
-		logger.Debugf("user is not allowed to create or modify")
 		return http.StatusForbidden, fmt.Errorf("user is not allowed to create or modify")
 	}
 	userscope, err := settings.GetScopeFromSourceName(d.user.Scopes, source)
 	if err != nil {
-		logger.Debugf("error getting scope from source name: %v", err)
 		return http.StatusForbidden, err
 	}
 	fileOpts := iteminfo.FileOptions{
-		Access:   store.Access,
-		Username: d.user.Username,
-		Path:     utils.JoinPathAsUnix(userscope, path),
-		Source:   source,
-		Modify:   d.user.Permissions.Modify,
-		Expand:   false,
+		Path:   utils.JoinPathAsUnix(userscope, path),
+		Source: source,
+		Modify: d.user.Permissions.Modify,
+		Expand: false,
 	}
-	idx := indexing.GetIndex(source)
-	if idx == nil {
-		logger.Debugf("source %s not found", source)
-		return http.StatusNotFound, fmt.Errorf("source %s not found", source)
-	}
-	realPath, _, _ := idx.GetRealPath(userscope, path)
-	isDir := strings.HasSuffix(path, "/")
 	// Directories creation on POST.
-	if isDir {
+	if strings.HasSuffix(path, "/") {
 		err = files.WriteDirectory(fileOpts)
 		if err != nil {
-			logger.Debugf("error writing directory: %v", err)
 			return errToStatus(err), err
 		}
 		return http.StatusOK, nil
 	}
-
-	// Handle Chunked Uploads
-	chunkOffsetStr := r.Header.Get("X-File-Chunk-Offset")
-	if chunkOffsetStr != "" {
-		var offset int64
-		offset, err = strconv.ParseInt(chunkOffsetStr, 10, 64)
-		if err != nil {
-			logger.Debugf("invalid chunk offset: %v", err)
-			return http.StatusBadRequest, fmt.Errorf("invalid chunk offset: %v", err)
-		}
-
-		var totalSize int64
-		totalSizeStr := r.Header.Get("X-File-Total-Size")
-		totalSize, err = strconv.ParseInt(totalSizeStr, 10, 64)
-		if err != nil {
-			logger.Debugf("invalid total size: %v", err)
-			return http.StatusBadRequest, fmt.Errorf("invalid total size: %v", err)
-		}
-		// On the first chunk, check for conflicts or handle override
-		if offset == 0 {
-			var fileInfo *iteminfo.ExtendedFileInfo
-			fileInfo, err = files.FileInfoFaster(fileOpts)
-			if err == nil { // File exists
-				if r.URL.Query().Get("override") != "true" {
-					logger.Debugf("resource already exists: %v", fileInfo.RealPath)
-					logger.Debugf("Resource already exists: %v", fileInfo.RealPath)
-					return http.StatusConflict, nil
-				}
-				// If overriding, delete existing thumbnails
-				preview.DelThumbs(r.Context(), *fileInfo)
-			}
-		}
-
-		// Use a temporary file in the cache directory for chunks.
-		// Create a unique name for the temporary file to avoid collisions.
-		hasher := md5.New() //nolint:gosec
-		hasher.Write([]byte(realPath))
-		uploadID := hex.EncodeToString(hasher.Sum(nil))
-		tempFilePath := filepath.Join(settings.Config.Server.CacheDir, "uploads", uploadID)
-
-		if err = os.MkdirAll(filepath.Dir(tempFilePath), 0755); err != nil {
-			logger.Debugf("could not create temp dir: %v", err)
-			return http.StatusInternalServerError, fmt.Errorf("could not create temp dir: %v", err)
-		}
-		// Create or open the temporary file
-		var outFile *os.File
-		outFile, err = os.OpenFile(tempFilePath, os.O_CREATE|os.O_WRONLY, 0644)
-		if err != nil {
-			logger.Debugf("could not open temp file: %v", err)
-			return http.StatusInternalServerError, fmt.Errorf("could not open temp file: %v", err)
-		}
-		defer outFile.Close()
-
-		// Seek to the correct offset to write the chunk
-		_, err = outFile.Seek(offset, 0)
-		if err != nil {
-			logger.Debugf("could not seek in temp file: %v", err)
-			return http.StatusInternalServerError, fmt.Errorf("could not seek in temp file: %v", err)
-		}
-
-		// Write the request body (the chunk) to the file
-		var chunkSize int64
-		chunkSize, err = io.Copy(outFile, r.Body)
-		if err != nil {
-			logger.Debugf("could not write chunk to temp file: %v", err)
-			return http.StatusInternalServerError, fmt.Errorf("could not write chunk to temp file: %v", err)
-		}
-		// check if the file is complete
-		if (offset + chunkSize) >= totalSize {
-			// close file before moving
-			outFile.Close()
-			// Move the completed file from the temp location to the final destination
-			err = fileutils.MoveFile(tempFilePath, realPath)
-			if err != nil {
-				logger.Debugf("could not move temp file to destination: %v", err)
-				return http.StatusInternalServerError, fmt.Errorf("could not move temp file to destination: %v", err)
-			}
-			go files.RefreshIndex(source, realPath, false) //nolint:errcheck
-		}
-
-		return http.StatusOK, nil
-	}
-
-	logger.Debugf("non-chunked upload logic for %s", realPath)
-	// Non-chunked upload logic (original code)
 	fileInfo, err := files.FileInfoFaster(fileOpts)
 	if err == nil {
 		if r.URL.Query().Get("override") != "true" {
@@ -341,11 +213,15 @@ func resourcePostHandler(w http.ResponseWriter, r *http.Request, d *requestConte
 			return http.StatusConflict, nil
 		}
 
-		preview.DelThumbs(r.Context(), *fileInfo)
+		// Permission for overwriting the file
+		if !d.user.Permissions.Modify {
+			return http.StatusForbidden, nil
+		}
+
+		preview.DelThumbs(r.Context(), fileInfo)
 	}
 	err = files.WriteFile(fileOpts, r.Body)
 	if err != nil {
-		logger.Debugf("error writing file: %v", err)
 		return errToStatus(err), err
 
 	}
@@ -359,7 +235,8 @@ func resourcePostHandler(w http.ResponseWriter, r *http.Request, d *requestConte
 // @Accept json
 // @Produce json
 // @Param path query string true "Destination path where to place the files inside the destination source"
-// @Param source query string true "Source name for the desired source, default is used if not provided"
+// @Param source query string false "Source name for the desired source, default is used if not provided"
+// @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"
@@ -368,11 +245,15 @@ func resourcePostHandler(w http.ResponseWriter, r *http.Request, d *requestConte
 // @Router /api/resources [put]
 func resourcePutHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
 	source := r.URL.Query().Get("source")
-	var err error
-	// decode url encoded source name
-	source, err = url.QueryUnescape(source)
-	if err != nil {
-		return http.StatusBadRequest, fmt.Errorf("invalid source encoding: %v", err)
+	if source == "" {
+		source = config.Server.DefaultSource.Name
+	} else {
+		var err error
+		// decode url encoded source name
+		source, err = url.QueryUnescape(source)
+		if err != nil {
+			return http.StatusBadRequest, fmt.Errorf("invalid source encoding: %v", err)
+		}
 	}
 	if !d.user.Permissions.Modify {
 		return http.StatusForbidden, fmt.Errorf("user is not allowed to create or modify")
@@ -393,12 +274,10 @@ func resourcePutHandler(w http.ResponseWriter, r *http.Request, d *requestContex
 		return http.StatusForbidden, err
 	}
 	fileOpts := iteminfo.FileOptions{
-		Access:   store.Access,
-		Username: d.user.Username,
-		Path:     utils.JoinPathAsUnix(userscope, path),
-		Source:   source,
-		Modify:   d.user.Permissions.Modify,
-		Expand:   false,
+		Path:   utils.JoinPathAsUnix(userscope, path),
+		Source: source,
+		Modify: d.user.Permissions.Modify,
+		Expand: false,
 	}
 	err = files.WriteFile(fileOpts, r.Body)
 	return errToStatus(err), err
@@ -471,7 +350,7 @@ func resourcePatchHandler(w http.ResponseWriter, r *http.Request, d *requestCont
 		return http.StatusNotFound, fmt.Errorf("source %s not found", dstIndex)
 	}
 	// check target dir exists
-	parentDir, isDstDir, err := idx.GetRealPath(userscopeDst, filepath.Dir(dst))
+	parentDir, _, err := idx.GetRealPath(userscopeDst, filepath.Dir(dst))
 	if err != nil {
 		logger.Debugf("Could not get real path for parent dir: %v %v %v", userscopeDst, filepath.Dir(dst), err)
 		return http.StatusNotFound, err
@@ -496,24 +375,7 @@ func resourcePatchHandler(w http.ResponseWriter, r *http.Request, d *requestCont
 	if overwrite && !d.user.Permissions.Modify {
 		return http.StatusForbidden, fmt.Errorf("forbidden: user does not have permission to overwrite file")
 	}
-
-	// Validate move/rename operation to prevent circular references
-	if action == "rename" || action == "move" {
-		if err = validateMoveOperation(realSrc, realDest, isSrcDir); err != nil {
-			return http.StatusBadRequest, err
-		}
-	}
-
-	err = patchAction(r.Context(), patchActionParams{
-		action:   action,
-		srcIndex: srcIndex,
-		dstIndex: dstIndex,
-		src:      realSrc,
-		dst:      realDest,
-		d:        d,
-		isSrcDir: isSrcDir,
-		isDstDir: isDstDir,
-	})
+	err = patchAction(r.Context(), action, realSrc, realDest, d, isSrcDir, srcIndex, dstIndex)
 	if err != nil {
 		logger.Debugf("Could not run patch action. src=%v dst=%v err=%v", realSrc, realDest, err)
 	}
@@ -536,32 +398,19 @@ func addVersionSuffix(source string) string {
 	return source
 }
 
-type patchActionParams struct {
-	action   string
-	srcIndex string
-	dstIndex string
-	src      string
-	dst      string
-	d        *requestContext
-	isSrcDir bool
-	isDstDir bool
-}
-
-func patchAction(ctx context.Context, params patchActionParams) error {
-	switch params.action {
+func patchAction(ctx context.Context, action, src, dst string, d *requestContext, isSrcDir bool, srcIndex, destIndex string) error {
+	switch action {
 	case "copy":
-		err := files.CopyResource(params.isSrcDir, params.isDstDir, params.srcIndex, params.dstIndex, params.src, params.dst)
+		err := files.CopyResource(srcIndex, destIndex, src, dst)
 		return err
 	case "rename", "move":
-		idx := indexing.GetIndex(params.srcIndex)
-		srcPath := idx.MakeIndexPath(params.src)
+		idx := indexing.GetIndex(srcIndex)
+		srcPath := idx.MakeIndexPath(src)
 		fileInfo, err := files.FileInfoFaster(iteminfo.FileOptions{
-			Access:     store.Access,
-			Username:   params.d.user.Username,
 			Path:       srcPath,
-			Source:     params.srcIndex,
-			IsDir:      params.isSrcDir,
-			Modify:     params.d.user.Permissions.Modify,
+			Source:     srcIndex,
+			IsDir:      isSrcDir,
+			Modify:     d.user.Permissions.Modify,
 			Expand:     false,
 			ReadHeader: false,
 		})
@@ -571,16 +420,22 @@ func patchAction(ctx context.Context, params patchActionParams) error {
 		}
 
 		// delete thumbnails
-		preview.DelThumbs(ctx, *fileInfo)
-		return files.MoveResource(params.isSrcDir, params.isDstDir, params.srcIndex, params.dstIndex, params.src, params.dst, store.Share)
+		preview.DelThumbs(ctx, fileInfo)
+		return files.MoveResource(srcIndex, destIndex, src, dst)
 	default:
-		return fmt.Errorf("unsupported action %s: %w", params.action, errors.ErrInvalidRequestParams)
+		return fmt.Errorf("unsupported action %s: %w", action, errors.ErrInvalidRequestParams)
 	}
 }
 
 func inspectIndex(w http.ResponseWriter, r *http.Request) {
 	encodedPath := r.URL.Query().Get("path")
 	source := r.URL.Query().Get("source")
+	if source == "" {
+		source = config.Server.DefaultSource.Name
+	} else {
+		// decode url encoded source name
+		source, _ = url.QueryUnescape(source)
+	}
 	// Decode the URL-encoded path
 	path, _ := url.QueryUnescape(encodedPath)
 	isNotDir := r.URL.Query().Get("isDir") == "false" // default to isDir true
@@ -601,6 +456,6 @@ func mockData(w http.ResponseWriter, r *http.Request) {
 	if err != nil || err2 != nil {
 		return
 	}
-	mockDir := indexing.CreateMockData(NumDirs, numFiles)
+	mockDir := utils.CreateMockData(NumDirs, numFiles)
 	renderJSON(w, r, mockDir) // nolint:errcheck
 }

backend/http/search.go

@@ -50,7 +50,6 @@ import (
 // @Accept json
 // @Produce json
 // @Param query query string true "Search query"
-// @Param source query string true "Source name for the desired source"
 // @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} indexing.SearchResult "List of search results"
@@ -59,14 +58,21 @@ import (
 func searchHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
 	query := r.URL.Query().Get("query")
 	source := r.URL.Query().Get("source")
+	if source == "" {
+		source = config.Server.DefaultSource.Name
+	} else {
+		var err error
+		// decode url encoded source name
+		source, err = url.QueryUnescape(source)
+		if err != nil {
+			return http.StatusBadRequest, fmt.Errorf("invalid source encoding: %v", err)
+		}
+	}
 	scope := r.URL.Query().Get("scope")
 	unencodedScope, err := url.QueryUnescape(scope)
 	if err != nil {
 		return http.StatusBadRequest, fmt.Errorf("invalid path encoding: %v", err)
 	}
-	if len(query) < settings.Config.Server.MinSearchLength {
-		return http.StatusBadRequest, fmt.Errorf("query is too short, minimum length is %d", settings.Config.Server.MinSearchLength)
-	}
 	searchScope := strings.TrimPrefix(unencodedScope, ".")
 	// Retrieve the User-Agent and X-Auth headers from the request
 	sessionId := r.Header.Get("SessionId")
@@ -79,12 +85,11 @@ func searchHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (i
 		return http.StatusForbidden, err
 	}
 	combinedPath := index.MakeIndexPath(filepath.Join(userscope, searchScope))
-	combinedPath = strings.TrimSuffix(combinedPath, "/") + "/" // Ensure trailing slash
 	// Perform the search using the provided query and user scope
 	response := index.Search(query, combinedPath, sessionId)
 	for i := range response {
 		// Remove the user scope from the path
-		response[i].Path = strings.TrimPrefix(response[i].Path, combinedPath)
+		response[i].Path = strings.TrimPrefix(response[i].Path, userscope)
 		if response[i].Path == "" {
 			response[i].Path = "/"
 		}