.docker.json

@@ -3,6 +3,6 @@
   "baseURL": "",
   "address": "",
   "log": "stdout",
-  "database": "/database/filebrowser.db",
+  "database": "/database.db",
   "root": "/srv"
 }

.dockerignore

@@ -1,7 +1,3 @@
-.venv
+testdata/
-dist
+.github/
-.idea
+**.git
-frontend/node_modules
-frontend/dist
-filebrowser.db
-docs/index.md

.github/CODEOWNERS

@@ -1 +0,0 @@
-* @filebrowser/maintainers

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,22 @@
+---
+name: Bug report
+about: Create a report to help us improve
+---
+
+**Description**
+A clear and concise description of what the issue is about. What are you trying to do?
+
+**Expected behaviour**
+What did you expect to happen?
+
+**What is happening instead?**
+Please, give full error messages and/or log.
+
+**Additional context**
+Add any other context about the problem here. If applicable, add screenshots to help explain your problem.
+
+**How to reproduce?**
+Tell us how to reproduce this issue. How can someone who is starting from scratch reproduce this behaviour as minimally as possible?
+
+**Files**
+A list of relevant files for this issue. Large files can be uploaded one-by-one or in a tarball/zipfile.

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,53 +0,0 @@
-name: Bug Report
-description: Report a bug in FileBrowser.
-labels: [bug, 'waiting: triage']
-body:
-  - type: checkboxes
-    attributes:
-      label: Checklist
-      description: Please verify that you've followed these steps
-      options:
-        - label: This is a bug report, not a question.
-          required: true
-        - label: I have searched on the [issue tracker](https://github.com/filebrowser/filebrowser/issues?q=is%3Aissue) for my bug.
-          required: true
-        - label: I am running the latest [FileBrowser version](https://github.com/filebrowser/filebrowser/releases) or have an issue updating.
-          required: true
-  - type: textarea
-    id: version
-    attributes:
-      label: Version
-      render: Text
-      description: |
-        Enter the version of FileBrowser you are using.
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: Description
-      description: |
-        A clear and concise description of what the issue is about. What are you trying to do?
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: What did you expect to happen?
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: What actually happened?
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: Reproduction Steps
-      description: |
-        Tell us how to reproduce this issue. How can someone who is starting from scratch reproduce this behavior as minimally as possible?
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: Files
-      description: |
-        A list of relevant files for this issue. Large files can be uploaded one-by-one or in a tarball/zipfile.

.github/ISSUE_TEMPLATE/caddy_bug_report.md

@@ -0,0 +1,6 @@
+---
+name: Caddy related bug report
+about: Create a report to help us improve
+---
+
+### Please open the issue on https://github.com/filebrowser/caddy/issues/new

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +0,0 @@
-blank_issues_enabled: false
-contact_links:
-  - name: GitHub Discussions
-    url: https://github.com/filebrowser/filebrowser/discussions
-    about: Please ask questions and discuss features here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,16 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+---
+
+**Is your feature request related to a problem? Please describe.**
+Add a clear and concise description of what the problem is. E.g. *I'm always frustrated when [...]*
+
+**Describe the solution you'd like**
+Add a clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+Add a clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,16 +1,16 @@
-## Description
+**Description**
+Please explain the changes you made here.
+If the feature changes current behaviour, explain why your solution is better.
 
-<!-- Please explain the changes you made here. -->
+:rotating_light: Before submitting your PR, please read [community](https://github.com/filebrowser/community), and indicate which issues (in any of the repos) are either fixed or closed by this PR. See [GitHub Help: Closing issues using keywords](https://help.github.com/articles/closing-issues-via-commit-messages/).
 
-## Additional Information
+- [ ] DO make sure you are requesting to **pull a topic/feature/bugfix branch** (right side). Don't request your master!
+- [ ] DO make sure you are making a pull request against the **master branch** (left side). Also you should start *your branch* off *our master*.
+- [ ] DO make sure that File Browser can be successfully built. See [builds](https://github.com/filebrowser/community/blob/master/builds.md) and [development](https://github.com/filebrowser/community/blob/master/development.md).
+- [ ] DO make sure that related issues are opened in other repositories. I.e., the frontend, caddy plugins or the web page need to be updated accordingly.
+- [ ] AVOID breaking the continuous integration build.
 
-<!-- If it is a relatively large or complex change, please add more information to explain what you did, how you did it, if you considered any alternatives, etc. -->
+**Further comments**
+If this is a relatively large or complex change, kick off the discussion by explaining why you chose the solution you did, what alternatives you considered, etc.
 
-## Checklist
+:heart: Thank you!
-
-Before submitting your PR, please indicate which issues are either fixed or closed by this PR. See [GitHub Help: Closing issues using keywords](https://help.github.com/articles/closing-issues-via-commit-messages/).
-
-- [ ] I am aware the project is currently in maintenance-only mode. See [README](https://github.com/filebrowser/community/blob/master/README.md)
-- [ ] I am aware that translations MUST be made through [Transifex](https://app.transifex.com/file-browser/file-browser/) and that this PR is NOT a translation update
-- [ ] I am making a PR against the `master` branch.
-- [ ] I am sure File Browser can be successfully built. See [builds](https://github.com/filebrowser/community/blob/master/builds.md) and [development](https://github.com/filebrowser/community/blob/master/development.md).

.github/workflows/ci.yaml

@@ -1,115 +0,0 @@
-name: Continuous Integration
-
-on:
-  push:
-    branches:
-      - "master"
-    tags:
-      - "v*"
-  pull_request:
-
-jobs:
-  lint-frontend:
-    name: Lint Frontend
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - uses: pnpm/action-setup@v4
-        with:
-          package_json_file: "frontend/package.json"
-      - uses: actions/setup-node@v6
-        with:
-          node-version: "24.x"
-          cache: "pnpm"
-          cache-dependency-path: "frontend/pnpm-lock.yaml"
-      - working-directory: frontend
-        run: |
-          pnpm install --frozen-lockfile
-          pnpm run lint
-
-  lint-backend:
-    name: Lint Backend
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-go@v6
-        with:
-          go-version: "1.25.x"
-      - uses: golangci/golangci-lint-action@v9
-        with:
-          version: "latest"
-
-  test:
-    name: Test
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-go@v6
-        with:
-          go-version: "1.25.x"
-      - run: go test --race ./...
-
-  build:
-    name: Build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          fetch-depth: 0
-      - uses: actions/setup-go@v6
-        with:
-          go-version: '1.25'
-      - uses: pnpm/action-setup@v4
-        with:
-          package_json_file: "frontend/package.json"
-      - uses: actions/setup-node@v6
-        with:
-          node-version: "24.x"
-          cache: "pnpm"
-          cache-dependency-path: "frontend/pnpm-lock.yaml"
-      - name: Install Task
-        uses: go-task/setup-task@v1
-      - run: task build
-
-  release:
-    name: Release
-    needs: ["lint-frontend", "lint-backend", "test", "build"]
-    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          fetch-depth: 0
-      - uses: actions/setup-go@v6
-        with:
-          go-version: '1.25'
-      - uses: pnpm/action-setup@v4
-        with:
-          package_json_file: "frontend/package.json"
-      - uses: actions/setup-node@v6
-        with:
-          node-version: "24.x"
-          cache: "pnpm"
-          cache-dependency-path: "frontend/pnpm-lock.yaml"
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Install Task
-        uses: go-task/setup-task@v1
-      - run: task build:frontend
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-      - name: Run GoReleaser
-        uses: goreleaser/goreleaser-action@v6
-        with:
-          version: latest
-          args: release --clean
-        env:
-          GITHUB_TOKEN: ${{ secrets.GH_PAT }}
-
-
-

.github/workflows/docs.yml

@@ -1,52 +0,0 @@
-name: Docs
-
-on:
-  pull_request:
-    paths:
-      - 'www'
-      - '*.md'
-  push:
-    branches:
-      - master
-
-jobs:
-  build:
-    name: Build Docs
-    if: github.event_name == 'pull_request'
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Install Task
-        uses: go-task/setup-task@v1
-      - name: Build site
-        run: task docs
-
-  build-and-release:
-    if: github.event_name == 'push' && github.ref == 'refs/heads/master'
-    name: Build and Release Docs
-    permissions:
-      pages: write
-      id-token: write
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Install Task
-        uses: go-task/setup-task@v1
-      - name: Build site
-        run: task docs
-      - name: Upload static files as artifact
-        uses: actions/upload-pages-artifact@v4
-        with:
-          path: www/public
-      - name: Deploy to GitHub Pages
-        uses: actions/deploy-pages@v4

.github/workflows/lint-pr.yaml

@@ -1,46 +0,0 @@
-name: "Lint PR"
-
-on:
-  pull_request_target:
-    types:
-      - opened
-      - reopened
-      - edited
-      - synchronize
-
-permissions:
-  pull-requests: write
-
-jobs:
-  main:
-    name: Validate Title
-    runs-on: ubuntu-latest
-    steps:
-      - uses: amannn/action-semantic-pull-request@v6
-        id: lint_pr_title
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - uses: marocchino/sticky-pull-request-comment@v2
-        # When the previous steps fails, the workflow would stop. By adding this
-        # condition you can continue the execution with the populated error message.
-        if: always() && (steps.lint_pr_title.outputs.error_message != null)
-        with:
-          header: pr-title-lint-error
-          message: |
-            Hey there and thank you for opening this pull request! 👋🏼
-            
-            We require pull request titles to follow the [Conventional Commits specification](https://www.conventionalcommits.org/en/v1.0.0/) and it looks like your proposed title needs to be adjusted.
-
-            Details:
-            
-            ```
-            ${{ steps.lint_pr_title.outputs.error_message }}
-            ```
-
-      # Delete a previous comment when the issue has been resolved
-      - if: ${{ steps.lint_pr_title.outputs.error_message == null }}
-        uses: marocchino/sticky-pull-request-comment@v2
-        with:
-          header: pr-title-lint-error
-          delete: true

.gitignore

@@ -1,39 +1,5 @@
 *.db
+*.lock
 *.bak
 _old
 rice-box.go
-.idea/
-/filebrowser
-/filebrowser.exe
-/dist
-.venv
-
-.DS_Store
-node_modules
-
-# local env files
-.env.local
-.env.*.local
-
-# Log files
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-
-# Editor directories and files
-.idea
-.vscode
-*.suo
-*.ntvs*
-*.njsproj
-*.sln
-*.sw*
-bin/
-build/
-
-# Vue distributable files
-/frontend/dist/*
-!/frontend/dist/.gitkeep
-
-default.nix
-Dockerfile.dev

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "frontend"]
+	path = frontend
+	url = https://github.com/filebrowser/frontend

.golangci.yml

@@ -1,14 +1,20 @@
-version: "2"
+run:
+  deadline: 5m
 
 linters:
-  default: standard
   enable:
-    - gocritic
+    - deadcode
     - govet
-    - revive
+    - ineffassign
-  exclusions:
+    - interfacer
-    presets:
+    - maligned
-      - std-error-handling
+    - megacheck
-      - comments
+    - structcheck
-    paths:
+    - unconvert
-      - frontend/
+    - varcheck
+  enable-all: false
+  disable-all: true
+#  presets:
+#    - bugs
+#    - unused
+  fast: false

.goreleaser.yml

@@ -1,197 +1,58 @@
-version: 2
-
 project_name: filebrowser
 
-env:
+build:
-  - GO111MODULE=on
+  env:
+    - CGO_ENABLED=0
+  main: main.go
+  binary: filebrowser
+  goos:
+    - darwin
+    - linux
+    - windows
+    - freebsd
+    - netbsd
+    - openbsd
+    - dragonfly
+    - solaris
+  goarch:
+    - amd64
+    - 386
+    - arm
+    - arm64
+  goarm:
+    - 5
+    - 6
+    - 7
+  ignore:
+    - goos: darwin
+      goarch: 386
+    - goos: openbsd
+      goarch: arm
+    - goos: freebsd
+      goarch: arm
+    - goos: netbsd
+      goarch: arm
+    - goos: solaris
+      goarch: arm
 
-builds:
+archive:
-  - env:
+  name_template: "{{.Os}}-{{.Arch}}{{if .Arm}}v{{.Arm}}{{end}}-{{ .ProjectName }}"
-      - CGO_ENABLED=0
+  format: tar.gz
-    ldflags:
+  format_overrides:
-      - -s -w -X github.com/filebrowser/filebrowser/v2/version.Version={{ .Version }} -X github.com/filebrowser/filebrowser/v2/version.CommitSHA={{ .ShortCommit }}
+    - goos: windows
-    main: main.go
+      format: zip
-    binary: filebrowser
-    goos:
-      - darwin
-      - linux
-      - windows
-      - freebsd
-    goarch:
-      - amd64
-      - "386"
-      - arm
-      - arm64
-      - riscv64
-    goarm:
-      - "5"
-      - "6"
-      - "7"
-    ignore:
-      - goos: darwin
-        goarch: "386"
-      - goos: freebsd
-        goarch: arm
 
-archives:
+release:
-  - name_template: "{{.Os}}-{{.Arch}}{{if .Arm}}v{{.Arm}}{{end}}-{{ .ProjectName }}"
+  disable: true
-    formats: ["tar.gz"]
-    format_overrides:
-      - goos: windows
-        formats: ["zip"]
 
 dockers:
-  # Alpine docker images
+  -
-  - dockerfile: Dockerfile
-    use: buildx
-    build_flag_templates:
-      - "--pull"
-      - "--label=org.opencontainers.image.created={{.Date}}"
-      - "--label=org.opencontainers.image.name={{.ProjectName}}"
-      - "--label=org.opencontainers.image.revision={{.FullCommit}}"
-      - "--label=org.opencontainers.image.version={{.Version}}"
-      - "--label=org.opencontainers.image.source={{.GitURL}}"
-      - "--platform=linux/amd64"
     goos: linux
     goarch: amd64
+    goarm: ''
     image_templates:
-      - "filebrowser/filebrowser:{{ .Tag }}-amd64"
+      - "filebrowser/filebrowser:latest"
-      - "filebrowser/filebrowser:v{{ .Major }}-amd64"
+      - "filebrowser/filebrowser:{{ .Tag }}"
+    skip_push: true
     extra_files:
-      - docker
+      - .docker.json
-  - dockerfile: Dockerfile
-    use: buildx
-    build_flag_templates:
-      - "--pull"
-      - "--label=org.opencontainers.image.created={{.Date}}"
-      - "--label=org.opencontainers.image.name={{.ProjectName}}"
-      - "--label=org.opencontainers.image.revision={{.FullCommit}}"
-      - "--label=org.opencontainers.image.version={{.Version}}"
-      - "--label=org.opencontainers.image.source={{.GitURL}}"
-      - "--platform=linux/arm64"
-    goos: linux
-    goarch: arm64
-    image_templates:
-      - "filebrowser/filebrowser:{{ .Tag }}-arm64"
-      - "filebrowser/filebrowser:v{{ .Major }}-arm64"
-    extra_files:
-      - docker
-  - dockerfile: Dockerfile
-    use: buildx
-    build_flag_templates:
-      - "--pull"
-      - "--label=org.opencontainers.image.created={{.Date}}"
-      - "--label=org.opencontainers.image.name={{.ProjectName}}"
-      - "--label=org.opencontainers.image.revision={{.FullCommit}}"
-      - "--label=org.opencontainers.image.version={{.Version}}"
-      - "--label=org.opencontainers.image.source={{.GitURL}}"
-      - "--platform=linux/arm/v6"
-    goos: linux
-    goarch: arm
-    goarm: "6"
-    image_templates:
-      - "filebrowser/filebrowser:{{ .Tag }}-armv6"
-      - "filebrowser/filebrowser:v{{ .Major }}-armv6"
-    extra_files:
-      - docker
-  - dockerfile: Dockerfile
-    use: buildx
-    build_flag_templates:
-      - "--pull"
-      - "--label=org.opencontainers.image.created={{.Date}}"
-      - "--label=org.opencontainers.image.name={{.ProjectName}}"
-      - "--label=org.opencontainers.image.revision={{.FullCommit}}"
-      - "--label=org.opencontainers.image.version={{.Version}}"
-      - "--label=org.opencontainers.image.source={{.GitURL}}"
-      - "--platform=linux/arm/v7"
-    goos: linux
-    goarch: arm
-    goarm: "7"
-    image_templates:
-      - "filebrowser/filebrowser:{{ .Tag }}-armv7"
-      - "filebrowser/filebrowser:v{{ .Major }}-armv7"
-    extra_files:
-      - docker
-
-  ## s6-overlay docker images
-  - dockerfile: Dockerfile.s6
-    use: buildx
-    build_flag_templates:
-      - "--pull"
-      - "--label=org.opencontainers.image.created={{.Date}}"
-      - "--label=org.opencontainers.image.name={{.ProjectName}}"
-      - "--label=org.opencontainers.image.revision={{.FullCommit}}"
-      - "--label=org.opencontainers.image.version={{.Version}}"
-      - "--label=org.opencontainers.image.source={{.GitURL}}"
-      - "--platform=linux/amd64"
-    goos: linux
-    goarch: amd64
-    image_templates:
-      - "filebrowser/filebrowser:{{ .Tag }}-amd64-s6"
-      - "filebrowser/filebrowser:v{{ .Major }}-amd64-s6"
-    extra_files:
-      - docker
-  - dockerfile: Dockerfile.s6
-    use: buildx
-    build_flag_templates:
-      - "--pull"
-      - "--label=org.opencontainers.image.created={{.Date}}"
-      - "--label=org.opencontainers.image.name={{.ProjectName}}"
-      - "--label=org.opencontainers.image.revision={{.FullCommit}}"
-      - "--label=org.opencontainers.image.version={{.Version}}"
-      - "--label=org.opencontainers.image.source={{.GitURL}}"
-      - "--platform=linux/arm64"
-    goos: linux
-    goarch: arm64
-    image_templates:
-      - "filebrowser/filebrowser:{{ .Tag }}-arm64-s6"
-      - "filebrowser/filebrowser:v{{ .Major }}-arm64-s6"
-    extra_files:
-      - docker
-
-docker_manifests:
-  - name_template: "filebrowser/filebrowser:latest"
-    image_templates:
-      - "filebrowser/filebrowser:{{ .Tag }}-amd64"
-      - "filebrowser/filebrowser:{{ .Tag }}-arm64"
-      - "filebrowser/filebrowser:{{ .Tag }}-armv7"
-  - name_template: "filebrowser/filebrowser:{{ .Tag }}"
-    image_templates:
-      - "filebrowser/filebrowser:{{ .Tag }}-amd64"
-      - "filebrowser/filebrowser:{{ .Tag }}-arm64"
-      - "filebrowser/filebrowser:{{ .Tag }}-armv7"
-  - name_template: "filebrowser/filebrowser:v{{ .Major }}"
-    image_templates:
-      - "filebrowser/filebrowser:v{{ .Major }}-amd64"
-      - "filebrowser/filebrowser:v{{ .Major }}-arm64"
-      - "filebrowser/filebrowser:v{{ .Major }}-armv7"
-  ## s6 image manifests
-  - name_template: "filebrowser/filebrowser:s6"
-    image_templates:
-      - "filebrowser/filebrowser:{{ .Tag }}-amd64-s6"
-      - "filebrowser/filebrowser:{{ .Tag }}-arm64-s6"
-  - name_template: "filebrowser/filebrowser:{{ .Tag }}-s6"
-    image_templates:
-      - "filebrowser/filebrowser:{{ .Tag }}-amd64-s6"
-      - "filebrowser/filebrowser:{{ .Tag }}-arm64-s6"
-  - name_template: "filebrowser/filebrowser:v{{ .Major }}-s6"
-    image_templates:
-      - "filebrowser/filebrowser:v{{ .Major }}-amd64-s6"
-      - "filebrowser/filebrowser:v{{ .Major }}-arm64-s6"
-
-homebrew_casks:
-  - name: filebrowser
-    repository:
-      owner: filebrowser
-      name: homebrew-tap
-    commit_author:
-      name: FileBrowser Robot
-      email: robot@filebrowser.org
-    homepage: https://github.com/filebrowser/filebrowser
-    description: File Browser is a create-your-own-cloud-kind of software where you can install it on a server, direct it to a path and then access your files through a nice web interface
-    hooks:
-      post:
-        install: |
-          if system_command("/usr/bin/xattr", args: ["-h"]).exit_status == 0
-            system_command "/usr/bin/xattr", args: ["-dr", "com.apple.quarantine", "#{staged_path}/filebrowser"]
-          end

.travis.yml

@@ -0,0 +1,47 @@
+os: linux
+services: docker
+language: minimal
+install: skip
+addons:
+  apt:
+    packages:
+    - docker-ce
+    - pass
+env:
+  global:
+  - USE_DOCKER="true"
+stages:
+  - lint
+  - build
+  - release
+cache:
+  directories:
+    - http/rice-box.go
+jobs:
+  include:
+  - stage: lint
+    script: ./wizard.sh -l
+  - stage: build
+    script: ./wizard.sh -b
+    deploy:
+      provider: script
+      skip_cleanup: true
+      script: ./wizard.sh -p
+      on:
+        tags: false
+        repo: filebrowser/filebrowser
+        branch: master
+  - stage: release
+    script: ./wizard.sh -r "$TRAVIS_TAG"
+    if: tag IS present
+    deploy:
+      provider: releases
+      skip_cleanup: true
+      api_key:
+        secure: GCURbl9xmjOmeNc7cYSvfSwbEp46cacWmJRczcsU6rQa0aWqzjELYdyIsl6HWW+o0dzuZvbWRD6muxYqIud92oPLYDuXSnra9tM3mCjswrjiPCJ57bksWkSPBfFQcxIyB6c3o+A/FMnX3nnSE/2r5HYZnPNFbEcBbC7WSgwx9ejXUuyWn1PUFK9YQWANdl6J7b7EKsk+9MxS9Pmw6M2ycBwX8ScUQdofkUPvR/nqlXISm+3hs30VubqQi9Ha6DM9Bw3aFK3/Ts/ujCOxP1ZoMCBZ6tfnaQOElIG96WTwnt77eDYlZezBOLym3Z18iif+Qny+XndFKDbexaiUT06VlWFXCKtt3iLs6HJwRcjmiHmB0Z3v+W4cKPl3cEyxxrU2aal54k1PBhU+5L0Xc8ileKbDMYg5tps88zWHNefeZVfaxYSVrmUHkuygMe481oaBLacDXTxs4t6XEpStREuLmvx9NLTwTFAbWjMNM0PqlueDMxO4bdwNvzXg/TcKLWV9FezqAlre8lFNZK5wX6lKFVSZ3hFjxCfwrJL2cPwg5A8Yd5EOC4Nh81WdgYuFGOxZzMAoSJlaVRvQS1trCUP/++ONnDep3ExSxvw4B7vijGZWeXUhrOMiPQHXu+t6BnrlnDjQ4gi44QTW0y/iM2WC2DBKfgYjAKwyHx13hFrmOCg=
+      file: "dist/*.*"
+      file_glob: true
+      on:
+        repo: filebrowser/filebrowser
+        all_branches: true
+        tags: true

.versionrc

@@ -1,14 +0,0 @@
-{
-  "types": [
-    { "type": "feat", "section": "Features" },
-    { "type": "fix", "section": "Bug Fixes" },
-    { "type": "perf", "section": "Performance improvements" },
-    { "type": "revert", "section": "Reverts" },
-    { "type": "refactor", "section": "Refactorings" },
-    { "type": "build", "section": "Build" },
-    { "type": "ci", "hidden": true },
-    { "type": "test", "hidden": true },
-    { "type": "chore", "hidden": true },
-    { "type": "docs", "hidden": true }
-  ]
-}

CODE-OF-CONDUCT.md

@@ -1,46 +0,0 @@
-# Code of Conduct
-
-## Contributor Covenant Code of Conduct
-
-### Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
-
-### Our Standards
-
-Examples of behavior that contributes to creating a positive environment include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a professional setting
-
-### Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
-
-### Scope
-
-This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
-
-### Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at hacdias@gmail.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
-
-### Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.4, available at [https://contributor-covenant.org/version/1/4](https://contributor-covenant.org/version/1/4).
-

CONTRIBUTING.md

@@ -1,128 +0,0 @@
-# Contributing
-
-If you're interested in contributing to this project, this is the best place to start. Before contributing to this project, please take a bit of time to read our [Code of Conduct](code-of-conduct.md). Also, note that this project is open-source and licensed under [Apache License 2.0](LICENSE).
-
-## Project Structure
-
-The backend side of the application is written in [Go](https://golang.org/), while the frontend (located on a subdirectory of the same name) is written in [Vue.js](https://vuejs.org/). Due to the tight coupling required by some features, basic knowledge of both Go and Vue.js is recommended.
-
-* Learn Go: [https://github.com/golang/go/wiki/Learn](https://github.com/golang/go/wiki/Learn)
-* Learn Vue.js: [https://vuejs.org/guide/introduction.html](https://vuejs.org/guide/introduction.html)
-
-We encourage you to use git to manage your fork. To clone the main repository, just run:
-
-```bash
-git clone https://github.com/filebrowser/filebrowser
-```
-
-We use [Taskfile](https://taskfile.dev/) to manage the different processes (building, releasing, etc) automatically.
-
-## Build
-
-You can fully build the project in order to produce a binary by running:
-
-```bash
-task build
-```
-
-## Development
-
-For development, there are a few things to have in mind.
-
-### Frontend
-
-We use [Node.js](https://nodejs.org/en/) on the frontend to manage the build process. Prepare the frontend environment:
-
-```bash
-# From the root of the repo, go to frontend/
-cd frontend
-
-# Install the dependencies
-pnpm install
-```
-
-If you just want to develop the backend, you can create a static build of the frontend:
-
-```bash
-pnpm run build
-```
-
-If you want to develop the frontend, start a development server which watches for changes:
-
-```bash
-pnpm run dev
-```
-
-Please note that you need to access File Browser's interface through the development server of the frontend.
-
-### Backend
-
-First prepare the backend environment by downloading all required dependencies:
-
-```bash
-go mod download
-```
-
-You can now build or run File Browser as any other Go project:
-
-```bash
-# Build
-go build
-
-# Run
-go run .
-```
-
-## Documentation
-
-We rely on Docker to abstract all the dependencies required for building the documentation.
-
-To build the documentation to `www/public`:
-
-```bash
-task docs
-```
-
-To start a local server on port `8000` to view the built documentation:
-
-```bash
-task docs:serve
-```
-
-## Release
-
-To make a release, just run:
-
-```bash
-task release
-```
-
-## Translations
-
-Translations are managed on Transifex, which is an online website where everyone can contribute and translate strings for our project. It automatically syncs with the main language file \(in English\) and,, for you to contribute, you just need to:
-
-1. Go to our Transifex web page: [app.transifex.com/file-browser/file-browser](https://app.transifex.com/file-browser/file-browser/)
-2. Click on **Join the project** and pick your language. We'll accept you as soon as possible. If you're language is not on the list, please request it via the interface.
-
-Translations are automatically pushed to GitHub via an integration.
-
-## Authentication Provider
-
-To build a new authentication provider, you need to implement the [Auther interface](https://github.com/filebrowser/filebrowser/blob/master/auth/auth.go), whose method will be called on the login page after the user has submitted their login data.
-
-```go
-// Auther is the authentication interface.
-type Auther interface {
-    // Auth is called to authenticate a request.
-    Auth(r *http.Request, s *users.Storage, root string) (*users.User, error)
-}
-```
-
-After implementing the interface you should:
-
-1. Add it to [`auth` directory](https://github.com/filebrowser/filebrowser/blob/master/auth).
-2. Add it to the [configuration parser](https://github.com/filebrowser/filebrowser/blob/master/cmd/config.go) for the CLI.
-3. Add it to the [`authBackend.Get`](https://github.com/filebrowser/filebrowser/blob/master/storage/bolt/auth.go).
-
-If you need to add more flags, please update the function `addConfigFlags`.
-

Dockerfile

@@ -1,46 +1,11 @@
-## Multistage build: First stage fetches dependencies
+FROM scratch
-FROM alpine:3.23 AS fetcher
 
-# install and copy ca-certificates, mailcap, and tini-static; download JSON.sh
+COPY --from=filebrowser/dev /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certificates.crt
-RUN apk update && \
-    apk --no-cache add ca-certificates mailcap tini-static && \
-    wget -O /JSON.sh https://raw.githubusercontent.com/dominictarr/JSON.sh/0d5e5c77365f63809bf6e77ef44a1f34b0e05840/JSON.sh
-
-## Second stage: Use lightweight BusyBox image for final runtime environment
-FROM busybox:1.37.0-musl
-
-# Define non-root user UID and GID
-ENV UID=1000
-ENV GID=1000
-
-# Create user group and user
-RUN addgroup -g $GID user && \
-    adduser -D -u $UID -G user user
-
-# Copy binary, scripts, and configurations into image with proper ownership
-COPY --chown=user:user filebrowser /bin/filebrowser
-COPY --chown=user:user docker/common/ /
-COPY --chown=user:user docker/alpine/ /
-COPY --chown=user:user --from=fetcher /sbin/tini-static /bin/tini
-COPY --from=fetcher /JSON.sh /JSON.sh
-COPY --from=fetcher /etc/ca-certificates.conf /etc/ca-certificates.conf
-COPY --from=fetcher /etc/ca-certificates /etc/ca-certificates
-COPY --from=fetcher /etc/mime.types /etc/mime.types
-COPY --from=fetcher /etc/ssl /etc/ssl
-
-# Create data directories, set ownership, and ensure healthcheck script is executable
-RUN mkdir -p /config /database /srv && \
-    chown -R user:user /config /database /srv \
-    && chmod +x /healthcheck.sh
-
-# Define healthcheck script
-HEALTHCHECK --start-period=2s --interval=5s --timeout=3s CMD /healthcheck.sh
-
-# Set the user, volumes and exposed ports
-USER user
-
-VOLUME /srv /config /database
 
+VOLUME /srv
 EXPOSE 80
 
-ENTRYPOINT [ "tini", "--", "/init.sh" ]
+COPY .docker.json /.filebrowser.json
+COPY filebrowser /filebrowser
+
+ENTRYPOINT [ "/filebrowser" ]

Dockerfile.s6

@@ -1,24 +0,0 @@
-FROM ghcr.io/linuxserver/baseimage-alpine:3.23
-
-RUN apk update && \
-  apk --no-cache add ca-certificates mailcap jq libcap
-
-# Make user and create necessary directories
-RUN mkdir -p /config /database /srv && \
-  chown -R abc:abc /config /database /srv
-
-# Copy files and set permissions
-COPY filebrowser /bin/filebrowser
-COPY docker/common/ /
-COPY docker/s6/ /
-
-RUN chown -R abc:abc /bin/filebrowser /defaults healthcheck.sh && \
-  setcap 'cap_net_bind_service=+ep' /bin/filebrowser
-
-# Define healthcheck script
-HEALTHCHECK --start-period=2s --interval=5s --timeout=3s CMD /healthcheck.sh
-
-# Set the volumes and exposed ports
-VOLUME /srv /config /database
-
-EXPOSE 80

LICENSE

@@ -187,7 +187,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2018 File Browser Contributors
+   Copyright 2018 File Browser contributors
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

README.md

@@ -1,30 +1,31 @@
 <p align="center">
-  <img src="https://raw.githubusercontent.com/filebrowser/filebrowser/master/branding/banner.png" width="550"/>
+  <img src="https://raw.githubusercontent.com/filebrowser/logo/master/banner.png" width="550"/>
 </p>
 
-[![Build](https://github.com/filebrowser/filebrowser/actions/workflows/ci.yaml/badge.svg)](https://github.com/filebrowser/filebrowser/actions/workflows/ci.yaml)
+![Preview](https://user-images.githubusercontent.com/5447088/50716739-ebd26700-107a-11e9-9817-14230c53efd2.gif)
-[![Go Report Card](https://goreportcard.com/badge/github.com/filebrowser/filebrowser/v2)](https://goreportcard.com/report/github.com/filebrowser/filebrowser/v2)
-[![Version](https://img.shields.io/github/release/filebrowser/filebrowser.svg)](https://github.com/filebrowser/filebrowser/releases/latest)
 
-File Browser provides a file managing interface within a specified directory and it can be used to upload, delete, preview and edit your files. It is a **create-your-own-cloud**-kind of software where you can just install it on your server, direct it to a path and access your files through a nice web interface.
+[![Travis](https://img.shields.io/travis/com/filebrowser/filebrowser.svg?style=flat-square)](https://travis-ci.com/filebrowser/filebrowser)
+[![Go Report Card](https://goreportcard.com/badge/github.com/filebrowser/filebrowser?style=flat-square)](https://goreportcard.com/report/github.com/filebrowser/filebrowser)
+[![Documentation](https://img.shields.io/badge/godoc-reference-blue.svg?style=flat-square)](http://godoc.org/github.com/filebrowser/filebrowser)
+[![Version](https://img.shields.io/github/release/filebrowser/filebrowser.svg?style=flat-square)](https://github.com/filebrowser/filebrowser/releases/latest)
+[![Chat IRC](https://img.shields.io/badge/freenode-%23filebrowser-blue.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23filebrowser)
 
-## Documentation
+> ℹ INFO: **This project is not under active development ATM. A small group of developers keeps the project alive, but due to lack of time, we can't continue adding new features or doing deep changes. Please read [#532](https://github.com/filebrowser/filebrowser/issues/532) for more info!**
 
-Documentation on how to install, configure, and contribute to this project is hosted at [filebrowser.org](https://filebrowser.org).
+filebrowser provides a file managing interface within a specified directory and it can be used to upload, delete, preview, rename and edit your files. It allows the creation of multiple users and each user can have its own directory. It can be used as a standalone app or as a middleware.
 
-## Project Status
+## Features
 
-This project is a finished product which fulfills its goal: be a single binary web File Browser which can be run by anyone anywhere. That means that File Browser is currently on **maintenance-only** mode. Therefore, please note the following:
+Please refer to our docs at [docs.filebrowser.xyz/features](https://docs.filebrowser.xyz/features)
 
-- It can take a while until someone gets back to you. Please be patient.
+## Install
-- [Issues](https://github.com/filebrowser/filebrowser/issues) are meant to track bugs. Unrelated issues will be converted into [discussions](https://github.com/filebrowser/filebrowser/discussions).
+
-- No new features will be implemented by maintainers. Pull requests for new features will be reviewed on a case by case basis.
+Please refer to our docs at [docs.filebrowser.xyz](https://docs.filebrowser.xyz/).
-- The priority is triaging issues, addressing security issues and reviewing pull requests meant to solve bugs.
+
+## Usage
+
+Please refer to our docs at [docs.filebrowser.xyz/usage](https://docs.filebrowser.xyz/usage).
 
 ## Contributing
 
-Contributions are always welcome. To start contributing to this project, read our [guidelines](CONTRIBUTING.md) first.
+Please refer to our docs at [docs.filebrowser.xyz/contributing](https://docs.filebrowser.xyz/contributing).
-
-## License
-
-[Apache License 2.0](LICENSE) © File Browser Contributors

SECURITY.md

@@ -1,26 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-Use this section to tell people about which versions of your project are
-currently being supported with security updates.
-
-| Version | Supported          |
-| ------- | ------------------ |
-| 2.x     | :white_check_mark: |
-| < 2.0   | :x:                |
-
-## Reporting a Vulnerability
-
-Vulnerabilities with critical impact should be reported on the [Security](https://github.com/filebrowser/filebrowser/security) page of this repository, which is a private way of communicating vulnerabilities to maintainers. This project is in maintenance-only mode and it can take a while until someone gets back to you.
-
-If it is not a critical vulnerability, please open an issue and we will categorize it as a security issue. By giving visibility, we can get more help from the community at fixing such issues.
-
-When reporting an issue, where possible, please provide at least:
-
-* The commit version the issue was identified at
-* A proof of concept (plaintext; no binaries)
-* Steps to reproduce
-* Your recommended remediation(s), if any.
-
-The File Browser team is a volunteer-only effort, and may reach back out for clarification.

Taskfile.yml

@@ -1,83 +0,0 @@
-version: '3'
-
-vars:
-  SITE_DOCKER_FLAGS: >-
-    -v ./www:/docs
-    -v ./LICENSE:/docs/docs/LICENSE
-    -v ./SECURITY.md:/docs/docs/security.md
-    -v ./CHANGELOG.md:/docs/docs/changelog.md
-    -v ./CODE-OF-CONDUCT.md:/docs/docs/code-of-conduct.md
-    -v ./CONTRIBUTING.md:/docs/docs/contributing.md
-
-tasks:
-  build:frontend:
-    desc: Build frontend assets
-    dir: frontend
-    cmds:
-      - pnpm install --frozen-lockfile
-      - pnpm run build
-
-  build:backend:
-    desc: Build backend binary
-    cmds:
-      - go build -ldflags='-s -w -X "github.com/filebrowser/filebrowser/v2/version.Version={{.VERSION}}" -X "github.com/filebrowser/filebrowser/v2/version.CommitSHA={{.GIT_COMMIT}}"' -o filebrowser .
-    vars:
-      GIT_COMMIT:
-        sh: git log -n 1 --format=%h
-      VERSION:
-        sh: git describe --tags --abbrev=0 --match=v* | cut -c 2-
-
-  build:
-    desc: Build both frontend and backend
-    cmds:
-      - task: build:frontend
-      - task: build:backend
-
-  release:make:
-    internal: true
-    prompt: Do you wish to proceed?
-    cmds:
-      - pnpm dlx commit-and-tag-version -s
-
-  release:dry-run:
-    internal: true
-    cmds:
-      - pnpm dlx commit-and-tag-version --dry-run --skip
-
-  release:
-    desc: Create a new release
-    cmds:
-      - task: docs:cli:generate
-      - git add www/docs/cli
-      - |
-        if [[ `git status www/docs/cli --porcelain` ]]; then
-          git commit -m 'chore(docs): update CLI documentation'
-        fi
-      - task: release:dry-run
-      - task: release:make
-
-  docs:cli:generate:
-    cmds:
-      - rm -rf www/docs/cli
-      - mkdir -p www/docs/cli
-      - go run . docs
-    generates:
-      - www/docs/cli
-
-  docs:docker:generate:
-    internal: true
-    cmds: 
-      - docker build -f www/Dockerfile --progress=plain -t filebrowser.site www
-
-  docs:
-    desc: Generate documentation
-    cmds:
-      - rm -rf www/public
-      - task: docs:docker:generate
-      - docker run --rm {{.SITE_DOCKER_FLAGS}} filebrowser.site build -d "public"
-
-  docs:serve:
-    desc: Serve documentation
-    cmds:
-      - task: docs:docker:generate
-      - docker run --rm -it -p 8000:8000 {{.SITE_DOCKER_FLAGS}} filebrowser.site

auth/auth.go

@@ -3,14 +3,11 @@ package auth
 import (
 	"net/http"
 
-	"github.com/filebrowser/filebrowser/v2/settings"
 	"github.com/filebrowser/filebrowser/v2/users"
 )
 
 // Auther is the authentication interface.
 type Auther interface {
 	// Auth is called to authenticate a request.
-	Auth(r *http.Request, usr users.Store, stg *settings.Settings, srv *settings.Server) (*users.User, error)
+	Auth(r *http.Request, s *users.Storage, root string) (*users.User, error)
-	// LoginPage indicates if this auther needs a login page.
-	LoginPage() bool
 }

auth/hook.go

@@ -1,301 +0,0 @@
-package auth
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"log"
-	"net/http"
-	"os"
-	"os/exec"
-	"slices"
-	"strings"
-
-	fberrors "github.com/filebrowser/filebrowser/v2/errors"
-	"github.com/filebrowser/filebrowser/v2/files"
-	"github.com/filebrowser/filebrowser/v2/settings"
-	"github.com/filebrowser/filebrowser/v2/users"
-)
-
-// MethodHookAuth is used to identify hook auth.
-const MethodHookAuth settings.AuthMethod = "hook"
-
-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.Store, stg *settings.Settings, srv *settings.Server) (*users.User, error) {
-	var cred hookCred
-
-	if r.Body == nil {
-		return nil, os.ErrPermission
-	}
-
-	err := json.NewDecoder(r.Body).Decode(&cred)
-	if err != nil {
-		return nil, os.ErrPermission
-	}
-
-	a.Users = usr
-	a.Settings = stg
-	a.Server = srv
-	a.Cred = cred
-
-	action, err := a.RunCommand()
-	if err != nil {
-		return nil, err
-	}
-
-	switch action {
-	case "auth":
-		u, err := a.SaveUser()
-		if err != nil {
-			return nil, err
-		}
-		return u, nil
-	case "block":
-		return nil, os.ErrPermission
-	case "pass":
-		u, err := a.Users.Get(a.Server.Root, a.Cred.Username)
-		if err != nil || !users.CheckPwd(a.Cred.Password, u.Password) {
-			return nil, os.ErrPermission
-		}
-		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:]...)
-	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.Lines(s) {
-		v := strings.SplitN(val, "=", 2)
-
-		// skips non key and value format
-		if len(v) != 2 {
-			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.Server.Root, a.Cred.Username)
-	if err != nil && !errors.Is(err, fberrors.ErrNotExist) {
-		return nil, err
-	}
-
-	if u == nil {
-		pass, err := users.ValidateAndHashPwd(a.Cred.Password, a.Settings.MinimumPasswordLength)
-		if err != nil {
-			return nil, err
-		}
-
-		// create user with the provided credentials
-		d := &users.User{
-			Username:              a.Cred.Username,
-			Password:              pass,
-			Scope:                 a.Settings.Defaults.Scope,
-			Locale:                a.Settings.Defaults.Locale,
-			ViewMode:              a.Settings.Defaults.ViewMode,
-			SingleClick:           a.Settings.Defaults.SingleClick,
-			RedirectAfterCopyMove: a.Settings.Defaults.RedirectAfterCopyMove,
-			Sorting:               a.Settings.Defaults.Sorting,
-			Perm:                  a.Settings.Defaults.Perm,
-			Commands:              a.Settings.Defaults.Commands,
-			HideDotfiles:          a.Settings.Defaults.HideDotfiles,
-		}
-		u = a.GetUser(d)
-
-		userHome, err := a.Settings.MakeUserDir(u.Username, u.Scope, a.Server.Root)
-		if err != nil {
-			return nil, fmt.Errorf("user: failed to mkdir user home dir: [%s]", userHome)
-		}
-		u.Scope = userHome
-		log.Printf("user: %s, home dir: [%s].", u.Username, userHome)
-
-		err = a.Users.Save(u)
-		if err != nil {
-			return nil, err
-		}
-	} else if p := !users.CheckPwd(a.Cred.Password, u.Password); len(a.Fields.Values) > 1 || p {
-		u = a.GetUser(u)
-
-		// update the password when it doesn't match the current
-		if p {
-			pass, err := users.ValidateAndHashPwd(a.Cred.Password, a.Settings.MinimumPasswordLength)
-			if err != nil {
-				return nil, err
-			}
-			u.Password = pass
-		}
-
-		// update user with provided fields
-		err := a.Users.Update(u)
-		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 := a.Fields.GetBoolean("user.perm.admin", d.Perm.Admin)
-	perms := users.Permissions{
-		Admin:    isAdmin,
-		Execute:  isAdmin || a.Fields.GetBoolean("user.perm.execute", d.Perm.Execute),
-		Create:   isAdmin || a.Fields.GetBoolean("user.perm.create", d.Perm.Create),
-		Rename:   isAdmin || a.Fields.GetBoolean("user.perm.rename", d.Perm.Rename),
-		Modify:   isAdmin || a.Fields.GetBoolean("user.perm.modify", d.Perm.Modify),
-		Delete:   isAdmin || a.Fields.GetBoolean("user.perm.delete", d.Perm.Delete),
-		Share:    isAdmin || a.Fields.GetBoolean("user.perm.share", d.Perm.Share),
-		Download: isAdmin || a.Fields.GetBoolean("user.perm.download", d.Perm.Download),
-	}
-	user := users.User{
-		ID:                    d.ID,
-		Username:              d.Username,
-		Password:              d.Password,
-		Scope:                 a.Fields.GetString("user.scope", d.Scope),
-		Locale:                a.Fields.GetString("user.locale", d.Locale),
-		ViewMode:              users.ViewMode(a.Fields.GetString("user.viewMode", string(d.ViewMode))),
-		SingleClick:           a.Fields.GetBoolean("user.singleClick", d.SingleClick),
-		RedirectAfterCopyMove: a.Fields.GetBoolean("user.redirectAfterCopyMove", d.RedirectAfterCopyMove),
-		Sorting: files.Sorting{
-			Asc: a.Fields.GetBoolean("user.sorting.asc", d.Sorting.Asc),
-			By:  a.Fields.GetString("user.sorting.by", d.Sorting.By),
-		},
-		Commands:     a.Fields.GetArray("user.commands", d.Commands),
-		HideDotfiles: a.Fields.GetBoolean("user.hideDotfiles", d.HideDotfiles),
-		Perm:         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.redirectAfterCopyMove",
-	"user.sorting.by",
-	"user.sorting.asc",
-	"user.commands",
-	"user.hideDotfiles",
-	"user.perm.admin",
-	"user.perm.execute",
-	"user.perm.create",
-	"user.perm.rename",
-	"user.perm.modify",
-	"user.perm.delete",
-	"user.perm.share",
-	"user.perm.download",
-}
-
-// IsValid checks if the provided field is on the valid fields list
-func (hf *hookFields) IsValid(field string) bool {
-	return slices.Contains(validHookFields, field)
-}
-
-// 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
-}

auth/json.go

@@ -20,13 +20,13 @@ type jsonCred struct {
 	ReCaptcha string `json:"recaptcha"`
 }
 
-// JSONAuth is a json implementation of an Auther.
+// JSONAuth is a json implementaion of an Auther.
 type JSONAuth struct {
 	ReCaptcha *ReCaptcha `json:"recaptcha" yaml:"recaptcha"`
 }
 
 // Auth authenticates the user via a json in content body.
-func (a JSONAuth) Auth(r *http.Request, usr users.Store, _ *settings.Settings, srv *settings.Server) (*users.User, error) {
+func (a JSONAuth) Auth(r *http.Request, sto *users.Storage, root string) (*users.User, error) {
 	var cred jsonCred
 
 	if r.Body == nil {
@@ -39,7 +39,7 @@ func (a JSONAuth) Auth(r *http.Request, usr users.Store, _ *settings.Settings, s
 	}
 
 	// If ReCaptcha is enabled, check the code.
-	if a.ReCaptcha != nil && a.ReCaptcha.Secret != "" {
+	if a.ReCaptcha != nil && len(a.ReCaptcha.Secret) > 0 {
 		ok, err := a.ReCaptcha.Ok(cred.ReCaptcha)
 
 		if err != nil {
@@ -51,7 +51,7 @@ func (a JSONAuth) Auth(r *http.Request, usr users.Store, _ *settings.Settings, s
 		}
 	}
 
-	u, err := usr.Get(srv.Root, cred.Username)
+	u, err := sto.Get(root, cred.Username)
 	if err != nil || !users.CheckPwd(cred.Password, u.Password) {
 		return nil, os.ErrPermission
 	}
@@ -59,14 +59,9 @@ func (a JSONAuth) Auth(r *http.Request, usr users.Store, _ *settings.Settings, s
 	return u, nil
 }
 
-// LoginPage tells that json auth doesn't require a login page.
-func (a JSONAuth) LoginPage() bool {
-	return true
-}
-
 const reCaptchaAPI = "/recaptcha/api/siteverify"
 
-// ReCaptcha identifies a recaptcha connection.
+// ReCaptcha identifies a recaptcha conenction.
 type ReCaptcha struct {
 	Host   string `json:"host"`
 	Key    string `json:"key"`
@@ -76,7 +71,7 @@ type ReCaptcha struct {
 // Ok checks if a reCaptcha responde is correct.
 func (r *ReCaptcha) Ok(response string) (bool, error) {
 	body := url.Values{}
-	body.Set("secret", r.Secret)
+	body.Set("secret", r.Key)
 	body.Add("response", response)
 
 	client := &http.Client{}
@@ -89,7 +84,6 @@ func (r *ReCaptcha) Ok(response string) (bool, error) {
 	if err != nil {
 		return false, err
 	}
-	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
 		return false, nil

auth/none.go

@@ -14,11 +14,6 @@ const MethodNoAuth settings.AuthMethod = "noauth"
 type NoAuth struct{}
 
 // Auth uses authenticates user 1.
-func (a NoAuth) Auth(_ *http.Request, usr users.Store, _ *settings.Settings, srv *settings.Server) (*users.User, error) {
+func (a NoAuth) Auth(r *http.Request, sto *users.Storage, root string) (*users.User, error) {
-	return usr.Get(srv.Root, uint(1))
+	return sto.Get(root, uint(1))
-}
-
-// LoginPage tells that no auth doesn't require a login page.
-func (a NoAuth) LoginPage() bool {
-	return false
 }

auth/proxy.go

@@ -1,10 +1,10 @@
 package auth
 
 import (
-	"errors"
 	"net/http"
+	"os"
 
-	fberrors "github.com/filebrowser/filebrowser/v2/errors"
+	"github.com/filebrowser/filebrowser/v2/errors"
 	"github.com/filebrowser/filebrowser/v2/settings"
 	"github.com/filebrowser/filebrowser/v2/users"
 )
@@ -18,51 +18,12 @@ type ProxyAuth struct {
 }
 
 // Auth authenticates the user via an HTTP header.
-func (a ProxyAuth) Auth(r *http.Request, usr users.Store, setting *settings.Settings, srv *settings.Server) (*users.User, error) {
+func (a ProxyAuth) Auth(r *http.Request, sto *users.Storage, root string) (*users.User, error) {
 	username := r.Header.Get(a.Header)
-	user, err := usr.Get(srv.Root, username)
+	user, err := sto.Get(root, username)
-	if errors.Is(err, fberrors.ErrNotExist) {
+	if err == errors.ErrNotExist {
-		return a.createUser(usr, setting, srv, username)
+		return nil, os.ErrPermission
 	}
+
 	return user, err
 }
-
-func (a ProxyAuth) createUser(usr users.Store, setting *settings.Settings, srv *settings.Server, username string) (*users.User, error) {
-	const randomPasswordLength = settings.DefaultMinimumPasswordLength + 10
-	pwd, err := users.RandomPwd(randomPasswordLength)
-	if err != nil {
-		return nil, err
-	}
-
-	var hashedRandomPassword string
-	hashedRandomPassword, err = users.ValidateAndHashPwd(pwd, setting.MinimumPasswordLength)
-	if err != nil {
-		return nil, err
-	}
-
-	user := &users.User{
-		Username:     username,
-		Password:     hashedRandomPassword,
-		LockPassword: true,
-	}
-	setting.Defaults.Apply(user)
-
-	var userHome string
-	userHome, err = setting.MakeUserDir(user.Username, user.Scope, srv.Root)
-	if err != nil {
-		return nil, err
-	}
-	user.Scope = userHome
-
-	err = usr.Save(user)
-	if err != nil {
-		return nil, err
-	}
-
-	return user, nil
-}
-
-// LoginPage tells that proxy auth doesn't require a login page.
-func (a ProxyAuth) LoginPage() bool {
-	return false
-}

auth/storage.go

@@ -18,8 +18,8 @@ type Storage struct {
 }
 
 // NewStorage creates a auth storage from a backend.
-func NewStorage(back StorageBackend, userStore *users.Storage) *Storage {
+func NewStorage(back StorageBackend, users *users.Storage) *Storage {
-	return &Storage{back: back, users: userStore}
+	return &Storage{back: back, users: users}
 }
 
 // Get wraps a StorageBackend.Get.

branding/icon.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="700" height="700" shape-rendering="geometricPrecision" text-rendering="geometricPrecision" image-rendering="optimizeQuality" fill-rule="evenodd" clip-rule="evenodd"><defs><style>.prefix__fil1{fill:#fefefe}.prefix__fil6{fill:#006498}.prefix__fil5{fill:#bdeaff}</style></defs><g id="prefix__Layer_x0020_1"><path d="M80 0h540c44 0 80 36 80 80v540c0 44-36 80-80 80H80c-44 0-80-36-80-80V80C0 36 36 0 80 0z" fill="#455a64"/><path class="prefix__fil1" d="M350 71c154 0 279 125 279 279S504 629 350 629 71 504 71 350 196 71 350 71z"/><path d="M475 236l118 151c3 116-149 252-292 198l-76-99 114-156s138-95 136-94z" fill="#332c2b" fill-opacity=".149"/><path d="M231 211h208l38 24v246c0 5-3 8-8 8H231c-5 0-8-3-8-8V219c0-5 3-8 8-8z" fill="#2bbcff"/><path d="M231 211h208l38 24v2l-37-23H231c-4 0-7 3-7 7v263c-1-1-1-2-1-3V219c0-5 3-8 8-8z" fill="#53c6fc"/><path class="prefix__fil5" d="M305 212h113v98H305zM255 363h189c3 0 5 2 5 4v116H250V367c0-2 2-4 5-4z"/><path class="prefix__fil6" d="M250 470h199v13H250zM380 226h10c3 0 6 2 6 5v40c0 3-3 6-6 6h-10c-3 0-6-3-6-6v-40c0-3 3-5 6-5z"/><path class="prefix__fil1" d="M254 226c10 0 17 7 17 17 0 9-7 16-17 16-9 0-17-7-17-16 0-10 8-17 17-17z"/><path class="prefix__fil6" d="M267 448h165c2 0 3 1 3 3 0 1-1 3-3 3H267c-2 0-3-2-3-3 0-2 1-3 3-3zM267 415h165c2 0 3 1 3 3 0 1-1 2-3 2H267c-2 0-3-1-3-2 0-2 1-3 3-3zM267 381h165c2 0 3 2 3 3 0 2-1 3-3 3H267c-2 0-3-1-3-3 0-1 1-3 3-3z"/><path class="prefix__fil1" d="M236 472c3 0 5 2 5 5 0 2-2 4-5 4s-5-2-5-4c0-3 2-5 5-5zM463 472c3 0 5 2 5 5 0 2-2 4-5 4s-5-2-5-4c0-3 2-5 5-5z"/><path class="prefix__fil6" d="M305 212h-21v98h21z"/><path d="M477 479v2c0 5-3 8-8 8H231c-5 0-8-3-8-8v-2c0 4 3 8 8 8h238c5 0 8-4 8-8z" fill="#0ea5eb"/><path d="M350 70c155 0 280 125 280 280S505 630 350 630 70 505 70 350 195 70 350 70zm0 46c129 0 234 105 234 234S479 584 350 584 116 479 116 350s105-234 234-234z" fill="#2979ff"/></g></svg>

branding/logo.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" xml:space="preserve" width="560" height="560" version="1.1" id="prefix__svg44" clip-rule="evenodd" fill-rule="evenodd" image-rendering="optimizeQuality" shape-rendering="geometricPrecision" text-rendering="geometricPrecision"><defs id="prefix__defs4"><style type="text/css" id="style2">.prefix__fil1{fill:#fefefe}.prefix__fil6{fill:#006498}.prefix__fil5{fill:#bdeaff}</style></defs><g id="prefix__g85" transform="translate(-70 -70)"><path class="prefix__fil1" d="M350 71c154 0 279 125 279 279S504 629 350 629 71 504 71 350 196 71 350 71z" id="prefix__path9" fill="#fefefe"/><path d="M475 236l118 151c3 116-149 252-292 198l-76-99 114-156s138-95 136-94z" id="prefix__path11" fill="#332c2b" fill-opacity=".149"/><path d="M231 211h208l38 24v246c0 5-3 8-8 8H231c-5 0-8-3-8-8V219c0-5 3-8 8-8z" id="prefix__path13" fill="#2bbcff"/><path d="M231 211h208l38 24v2l-37-23H231c-4 0-7 3-7 7v263c-1-1-1-2-1-3V219c0-5 3-8 8-8z" id="prefix__path15" fill="#53c6fc"/><path class="prefix__fil5" id="prefix__polygon17" fill="#bdeaff" d="M305 212h113v98H305z"/><path class="prefix__fil5" d="M255 363h189c3 0 5 2 5 4v116H250V367c0-2 2-4 5-4z" id="prefix__path19" fill="#bdeaff"/><path class="prefix__fil6" id="prefix__polygon21" fill="#006498" d="M250 470h199v13H250z"/><path class="prefix__fil6" d="M380 226h10c3 0 6 2 6 5v40c0 3-3 6-6 6h-10c-3 0-6-3-6-6v-40c0-3 3-5 6-5z" id="prefix__path23" fill="#006498"/><path class="prefix__fil1" d="M254 226c10 0 17 7 17 17 0 9-7 16-17 16-9 0-17-7-17-16 0-10 8-17 17-17z" id="prefix__path25" fill="#fefefe"/><path class="prefix__fil6" d="M267 448h165c2 0 3 1 3 3 0 1-1 3-3 3H267c-2 0-3-2-3-3 0-2 1-3 3-3z" id="prefix__path27" fill="#006498"/><path class="prefix__fil6" d="M267 415h165c2 0 3 1 3 3 0 1-1 2-3 2H267c-2 0-3-1-3-2 0-2 1-3 3-3z" id="prefix__path29" fill="#006498"/><path class="prefix__fil6" d="M267 381h165c2 0 3 2 3 3 0 2-1 3-3 3H267c-2 0-3-1-3-3 0-1 1-3 3-3z" id="prefix__path31" fill="#006498"/><path class="prefix__fil1" d="M236 472c3 0 5 2 5 5 0 2-2 4-5 4s-5-2-5-4c0-3 2-5 5-5z" id="prefix__path33" fill="#fefefe"/><path class="prefix__fil1" d="M463 472c3 0 5 2 5 5 0 2-2 4-5 4s-5-2-5-4c0-3 2-5 5-5z" id="prefix__path35" fill="#fefefe"/><path class="prefix__fil6" id="prefix__polygon37" fill="#006498" d="M305 212h-21v98h21z"/><path d="M477 479v2c0 5-3 8-8 8H231c-5 0-8-3-8-8v-2c0 4 3 8 8 8h238c5 0 8-4 8-8z" id="prefix__path39" fill="#0ea5eb"/><path d="M350 70c155 0 280 125 280 280S505 630 350 630 70 505 70 350 195 70 350 70zm0 46c129 0 234 105 234 234S479 584 350 584 116 479 116 350s105-234 234-234z" id="prefix__path41" fill="#2979ff"/></g></svg>

cmd/cmd.go

@@ -1,6 +1,12 @@
 package cmd
 
+import (
+	"log"
+)
+
 // Execute executes the commands.
-func Execute() error {
+func Execute() {
-	return rootCmd.Execute()
+	if err := rootCmd.Execute(); err != nil {
+		log.Fatal(err)
+	}
 }

cmd/cmd_test.go

@@ -1,35 +0,0 @@
-package cmd
-
-import (
-	"testing"
-
-	"github.com/samber/lo"
-	"github.com/spf13/cobra"
-)
-
-// TestEnvCollisions ensures that there are no collisions in the produced environment
-// variable names for all commands and their flags.
-func TestEnvCollisions(t *testing.T) {
-	testEnvCollisions(t, rootCmd)
-}
-
-func testEnvCollisions(t *testing.T, cmd *cobra.Command) {
-	for _, cmd := range cmd.Commands() {
-		testEnvCollisions(t, cmd)
-	}
-
-	replacements := generateEnvKeyReplacements(cmd)
-	envVariables := []string{}
-
-	for i := range replacements {
-		if i%2 != 0 {
-			envVariables = append(envVariables, replacements[i])
-		}
-	}
-
-	duplicates := lo.FindDuplicates(envVariables)
-
-	if len(duplicates) > 0 {
-		t.Errorf("Found duplicate environment variable keys for command %q: %v", cmd.Name(), duplicates)
-	}
-}

cmd/cmds.go

@@ -11,10 +11,11 @@ func init() {
 }
 
 var cmdsCmd = &cobra.Command{
-	Use:   "cmds",
+	Use:     "cmds",
-	Short: "Command runner management utility",
+	Version: rootCmd.Version,
-	Long:  `Command runner management utility.`,
+	Short:   "Command runner management utility",
-	Args:  cobra.NoArgs,
+	Long:    `Command runner management utility.`,
+	Args:    cobra.NoArgs,
 }
 
 func printEvents(m map[string][]string) {

cmd/cmds_add.go

@@ -15,18 +15,13 @@ var cmdsAddCmd = &cobra.Command{
 	Short: "Add a command to run on a specific event",
 	Long:  `Add a command to run on a specific event.`,
 	Args:  cobra.MinimumNArgs(2),
-	RunE: withStore(func(_ *cobra.Command, args []string, st *store) error {
+	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		s, err := st.Settings.Get()
+		s, err := d.store.Settings.Get()
-		if err != nil {
+		checkErr(err)
-			return err
-		}
 		command := strings.Join(args[1:], " ")
 		s.Commands[args[0]] = append(s.Commands[args[0]], command)
-		err = st.Settings.Save(s)
+		err = d.store.Settings.Save(s)
-		if err != nil {
+		checkErr(err)
-			return err
-		}
 		printEvents(s.Commands)
-		return nil
+	}, pythonConfig{}),
-	}, storeOptions{}),
 }

cmd/cmds_ls.go

@@ -14,16 +14,10 @@ var cmdsLsCmd = &cobra.Command{
 	Short: "List all commands for each event",
 	Long:  `List all commands for each event.`,
 	Args:  cobra.NoArgs,
-	RunE: withStore(func(cmd *cobra.Command, _ []string, st *store) error {
+	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		s, err := st.Settings.Get()
+		s, err := d.store.Settings.Get()
-		if err != nil {
+		checkErr(err)
-			return err
+		evt := mustGetString(cmd.Flags(), "event")
-		}
-
-		evt, err := cmd.Flags().GetString("event")
-		if err != nil {
-			return err
-		}
 
 		if evt == "" {
 			printEvents(s.Commands)
@@ -33,7 +27,5 @@ var cmdsLsCmd = &cobra.Command{
 			show["after_"+evt] = s.Commands["after_"+evt]
 			printEvents(show)
 		}
-
+	}, pythonConfig{}),
-		return nil
-	}, storeOptions{}),
 }

cmd/cmds_rm.go

@@ -35,31 +35,22 @@ including 'index_end'.`,
 
 		return nil
 	},
-	RunE: withStore(func(_ *cobra.Command, args []string, st *store) error {
+	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		s, err := st.Settings.Get()
+		s, err := d.store.Settings.Get()
-		if err != nil {
+		checkErr(err)
-			return err
-		}
 		evt := args[0]
 
 		i, err := strconv.Atoi(args[1])
-		if err != nil {
+		checkErr(err)
-			return err
-		}
 		f := i
 		if len(args) == 3 {
 			f, err = strconv.Atoi(args[2])
-			if err != nil {
+			checkErr(err)
-				return err
-			}
 		}
 
 		s.Commands[evt] = append(s.Commands[evt][:i], s.Commands[evt][f+1:]...)
-		err = st.Settings.Save(s)
+		err = d.store.Settings.Save(s)
-		if err != nil {
+		checkErr(err)
-			return err
-		}
 		printEvents(s.Commands)
-		return nil
+	}, pythonConfig{}),
-	}, storeOptions{}),
 }

cmd/config.go

@@ -2,18 +2,17 @@ package cmd
 
 import (
 	"encoding/json"
-	"errors"
+	nerrors "errors"
 	"fmt"
 	"os"
 	"strings"
 	"text/tabwriter"
 
+	"github.com/filebrowser/filebrowser/v2/auth"
+	"github.com/filebrowser/filebrowser/v2/errors"
+	"github.com/filebrowser/filebrowser/v2/settings"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
-
-	"github.com/filebrowser/filebrowser/v2/auth"
-	fberrors "github.com/filebrowser/filebrowser/v2/errors"
-	"github.com/filebrowser/filebrowser/v2/settings"
 )
 
 func init() {
@@ -21,235 +20,98 @@ func init() {
 }
 
 var configCmd = &cobra.Command{
-	Use:   "config",
+	Use:     "config",
-	Short: "Configuration management utility",
+	Version: rootCmd.Version,
-	Long:  `Configuration management utility.`,
+	Short:   "Configuration management utility",
-	Args:  cobra.NoArgs,
+	Long:    `Configuration management utility.`,
+	Args:    cobra.NoArgs,
 }
 
 func addConfigFlags(flags *pflag.FlagSet) {
 	addServerFlags(flags)
 	addUserFlags(flags)
-
 	flags.BoolP("signup", "s", false, "allow users to signup")
-	flags.Bool("hideLoginButton", false, "hide login button from public pages")
-	flags.Bool("createUserDir", false, "generate user's home directory automatically")
-	flags.Uint("minimumPasswordLength", settings.DefaultMinimumPasswordLength, "minimum password length for new users")
 	flags.String("shell", "", "shell command to which other commands should be appended")
 
-	// NB: these are string so they can be presented as octal in the help text
-	// as that's the conventional representation for modes in Unix.
-	flags.String("fileMode", fmt.Sprintf("%O", settings.DefaultFileMode), "mode bits that new files are created with")
-	flags.String("dirMode", fmt.Sprintf("%O", settings.DefaultDirMode), "mode bits that new directories are created with")
-
 	flags.String("auth.method", string(auth.MethodJSONAuth), "authentication type")
 	flags.String("auth.header", "", "HTTP header for auth.method=proxy")
-	flags.String("auth.command", "", "command for auth.method=hook")
-	flags.String("auth.logoutPage", "", "url of custom logout page")
 
 	flags.String("recaptcha.host", "https://www.google.com", "use another host for ReCAPTCHA. recaptcha.net might be useful in China")
 	flags.String("recaptcha.key", "", "ReCaptcha site key")
 	flags.String("recaptcha.secret", "", "ReCaptcha secret")
 
 	flags.String("branding.name", "", "replace 'File Browser' by this name")
-	flags.String("branding.theme", "", "set the theme")
-	flags.String("branding.color", "", "set the theme color")
 	flags.String("branding.files", "", "path to directory with images and custom styles")
 	flags.Bool("branding.disableExternal", false, "disable external links such as GitHub links")
-	flags.Bool("branding.disableUsedPercentage", false, "disable used disk percentage graph")
-
-	flags.Uint64("tus.chunkSize", settings.DefaultTusChunkSize, "the tus chunk size")
-	flags.Uint16("tus.retryCount", settings.DefaultTusRetryCount, "the tus retry count")
 }
 
-func getAuthMethod(flags *pflag.FlagSet, defaults ...interface{}) (settings.AuthMethod, map[string]interface{}, error) {
+func getAuthentication(flags *pflag.FlagSet) (settings.AuthMethod, auth.Auther) {
-	methodStr, err := flags.GetString("auth.method")
+	method := settings.AuthMethod(mustGetString(flags, "auth.method"))
-	if err != nil {
-		return "", nil, err
-	}
-	method := settings.AuthMethod(methodStr)
-
-	var defaultAuther map[string]interface{}
-	if len(defaults) > 0 {
-		if hasAuth := defaults[0]; hasAuth != true {
-			for _, arg := range defaults {
-				switch def := arg.(type) {
-				case *settings.Settings:
-					method = def.AuthMethod
-				case auth.Auther:
-					ms, err := json.Marshal(def)
-					if err != nil {
-						return "", nil, err
-					}
-					err = json.Unmarshal(ms, &defaultAuther)
-					if err != nil {
-						return "", nil, err
-					}
-				}
-			}
-		}
-	}
-
-	return method, defaultAuther, nil
-}
-
-func getProxyAuth(flags *pflag.FlagSet, defaultAuther map[string]interface{}) (auth.Auther, error) {
-	header, err := flags.GetString("auth.header")
-	if err != nil {
-		return nil, err
-	}
-
-	if header == ""  && defaultAuther != nil {
-		header = defaultAuther["header"].(string)
-	}
-
-	if header == "" {
-		return nil, errors.New("you must set the flag 'auth.header' for method 'proxy'")
-	}
-
-	return &auth.ProxyAuth{Header: header}, nil
-}
-
-func getNoAuth() auth.Auther {
-	return &auth.NoAuth{}
-}
-
-func getJSONAuth(flags *pflag.FlagSet, defaultAuther map[string]interface{}) (auth.Auther, error) {
-	jsonAuth := &auth.JSONAuth{}
-	host, err := flags.GetString("recaptcha.host")
-	if err != nil {
-		return nil, err
-	}
-
-	key, err := flags.GetString("recaptcha.key")
-	if err != nil {
-		return nil, err
-	}
-
-	secret, err := flags.GetString("recaptcha.secret")
-	if err != nil {
-		return nil, err
-	}
-
-	if key == "" {
-		if kmap, ok := defaultAuther["recaptcha"].(map[string]interface{}); ok {
-			key = kmap["key"].(string)
-		}
-	}
-
-	if secret == "" {
-		if smap, ok := defaultAuther["recaptcha"].(map[string]interface{}); ok {
-			secret = smap["secret"].(string)
-		}
-	}
-
-	if key != "" && secret != "" {
-		jsonAuth.ReCaptcha = &auth.ReCaptcha{
-			Host:   host,
-			Key:    key,
-			Secret: secret,
-		}
-	}
-	return jsonAuth, nil
-}
-
-func getHookAuth(flags *pflag.FlagSet, defaultAuther map[string]interface{}) (auth.Auther, error) {
-	command, err := flags.GetString("auth.command")
-	if err != nil {
-		return nil, err
-	}
-	if command == "" {
-		command = defaultAuther["command"].(string)
-	}
-
-	if command == "" {
-		return nil, errors.New("you must set the flag 'auth.command' for method 'hook'")
-	}
-
-	return &auth.HookAuth{Command: command}, nil
-}
-
-func getAuthentication(flags *pflag.FlagSet, defaults ...interface{}) (settings.AuthMethod, auth.Auther, error) {
-	method, defaultAuther, err := getAuthMethod(flags, defaults...)
-	if err != nil {
-		return "", nil, err
-	}
 
 	var auther auth.Auther
-	switch method {
+	if method == auth.MethodProxyAuth {
-	case auth.MethodProxyAuth:
+		header := mustGetString(flags, "auth.header")
-		auther, err = getProxyAuth(flags, defaultAuther)
+		if header == "" {
-	case auth.MethodNoAuth:
+			panic(nerrors.New("you must set the flag 'auth.header' for method 'proxy'"))
-		auther = getNoAuth()
+		}
-	case auth.MethodJSONAuth:
+		auther = &auth.ProxyAuth{Header: header}
-		auther, err = getJSONAuth(flags, defaultAuther)
-	case auth.MethodHookAuth:
-		auther, err = getHookAuth(flags, defaultAuther)
-	default:
-		return "", nil, fberrors.ErrInvalidAuthMethod
 	}
 
-	if err != nil {
+	if method == auth.MethodNoAuth {
-		return "", nil, err
+		auther = &auth.NoAuth{}
 	}
 
-	return method, auther, nil
+	if method == auth.MethodJSONAuth {
+		jsonAuth := &auth.JSONAuth{}
+
+		host := mustGetString(flags, "recaptcha.host")
+		key := mustGetString(flags, "recaptcha.key")
+		secret := mustGetString(flags, "recaptcha.secret")
+
+		if key != "" && secret != "" {
+			jsonAuth.ReCaptcha = &auth.ReCaptcha{
+				Host:   host,
+				Key:    key,
+				Secret: secret,
+			}
+		}
+
+		auther = jsonAuth
+	}
+
+	if auther == nil {
+		panic(errors.ErrInvalidAuthMethod)
+	}
+
+	return method, auther
 }
 
-func printSettings(ser *settings.Server, set *settings.Settings, auther auth.Auther) error {
+func printSettings(ser *settings.Server, set *settings.Settings, auther auth.Auther) {
 	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
 
 	fmt.Fprintf(w, "Sign up:\t%t\n", set.Signup)
-	fmt.Fprintf(w, "Hide Login Button:\t%t\n", set.HideLoginButton)
+	fmt.Fprintf(w, "Auth method:\t%s\n", set.AuthMethod)
-	fmt.Fprintf(w, "Create User Dir:\t%t\n", set.CreateUserDir)
-	fmt.Fprintf(w, "Logout Page:\t%s\n", set.LogoutPage)
-	fmt.Fprintf(w, "Minimum Password Length:\t%d\n", set.MinimumPasswordLength)
-	fmt.Fprintf(w, "Auth Method:\t%s\n", set.AuthMethod)
 	fmt.Fprintf(w, "Shell:\t%s\t\n", strings.Join(set.Shell, " "))
-
 	fmt.Fprintln(w, "\nBranding:")
 	fmt.Fprintf(w, "\tName:\t%s\n", set.Branding.Name)
 	fmt.Fprintf(w, "\tFiles override:\t%s\n", set.Branding.Files)
 	fmt.Fprintf(w, "\tDisable external links:\t%t\n", set.Branding.DisableExternal)
-	fmt.Fprintf(w, "\tDisable used disk percentage graph:\t%t\n", set.Branding.DisableUsedPercentage)
-	fmt.Fprintf(w, "\tColor:\t%s\n", set.Branding.Color)
-	fmt.Fprintf(w, "\tTheme:\t%s\n", set.Branding.Theme)
-
 	fmt.Fprintln(w, "\nServer:")
 	fmt.Fprintf(w, "\tLog:\t%s\n", ser.Log)
 	fmt.Fprintf(w, "\tPort:\t%s\n", ser.Port)
 	fmt.Fprintf(w, "\tBase URL:\t%s\n", ser.BaseURL)
 	fmt.Fprintf(w, "\tRoot:\t%s\n", ser.Root)
-	fmt.Fprintf(w, "\tSocket:\t%s\n", ser.Socket)
 	fmt.Fprintf(w, "\tAddress:\t%s\n", ser.Address)
 	fmt.Fprintf(w, "\tTLS Cert:\t%s\n", ser.TLSCert)
 	fmt.Fprintf(w, "\tTLS Key:\t%s\n", ser.TLSKey)
-	fmt.Fprintf(w, "\tToken Expiration Time:\t%s\n", ser.TokenExpirationTime)
-	fmt.Fprintf(w, "\tExec Enabled:\t%t\n", ser.EnableExec)
-	fmt.Fprintf(w, "\tThumbnails Enabled:\t%t\n", ser.EnableThumbnails)
-	fmt.Fprintf(w, "\tResize Preview:\t%t\n", ser.ResizePreview)
-	fmt.Fprintf(w, "\tType Detection by Header:\t%t\n", ser.TypeDetectionByHeader)
-
-	fmt.Fprintln(w, "\nTUS:")
-	fmt.Fprintf(w, "\tChunk size:\t%d\n", set.Tus.ChunkSize)
-	fmt.Fprintf(w, "\tRetry count:\t%d\n", set.Tus.RetryCount)
-
 	fmt.Fprintln(w, "\nDefaults:")
 	fmt.Fprintf(w, "\tScope:\t%s\n", set.Defaults.Scope)
-	fmt.Fprintf(w, "\tHideDotfiles:\t%t\n", set.Defaults.HideDotfiles)
 	fmt.Fprintf(w, "\tLocale:\t%s\n", set.Defaults.Locale)
 	fmt.Fprintf(w, "\tView mode:\t%s\n", set.Defaults.ViewMode)
-	fmt.Fprintf(w, "\tSingle Click:\t%t\n", set.Defaults.SingleClick)
-	fmt.Fprintf(w, "\tRedirect after Copy/Move:\t%t\n", set.Defaults.RedirectAfterCopyMove)
-	fmt.Fprintf(w, "\tFile Creation Mode:\t%O\n", set.FileMode)
-	fmt.Fprintf(w, "\tDirectory Creation Mode:\t%O\n", set.DirMode)
 	fmt.Fprintf(w, "\tCommands:\t%s\n", strings.Join(set.Defaults.Commands, " "))
-	fmt.Fprintf(w, "\tAce editor syntax highlighting theme:\t%s\n", set.Defaults.AceEditorTheme)
-
 	fmt.Fprintf(w, "\tSorting:\n")
 	fmt.Fprintf(w, "\t\tBy:\t%s\n", set.Defaults.Sorting.By)
 	fmt.Fprintf(w, "\t\tAsc:\t%t\n", set.Defaults.Sorting.Asc)
-
 	fmt.Fprintf(w, "\tPermissions:\n")
 	fmt.Fprintf(w, "\t\tAdmin:\t%t\n", set.Defaults.Perm.Admin)
 	fmt.Fprintf(w, "\t\tExecute:\t%t\n", set.Defaults.Perm.Execute)
@@ -259,133 +121,9 @@ func printSettings(ser *settings.Server, set *settings.Settings, auther auth.Aut
 	fmt.Fprintf(w, "\t\tDelete:\t%t\n", set.Defaults.Perm.Delete)
 	fmt.Fprintf(w, "\t\tShare:\t%t\n", set.Defaults.Perm.Share)
 	fmt.Fprintf(w, "\t\tDownload:\t%t\n", set.Defaults.Perm.Download)
-
 	w.Flush()
 
 	b, err := json.MarshalIndent(auther, "", "  ")
-	if err != nil {
+	checkErr(err)
-		return err
-	}
 	fmt.Printf("\nAuther configuration (raw):\n\n%s\n\n", string(b))
-	return nil
-}
-
-func getSettings(flags *pflag.FlagSet, set *settings.Settings, ser *settings.Server, auther auth.Auther, all bool) (auth.Auther, error) {
-	errs := []error{}
-	hasAuth := false
-
-	visit := func(flag *pflag.Flag) {
-		var err error
-
-		switch flag.Name {
-		// Server flags from [addServerFlags]
-		case "address":
-			ser.Address, err = flags.GetString(flag.Name)
-		case "log":
-			ser.Log, err = flags.GetString(flag.Name)
-		case "port":
-			ser.Port, err = flags.GetString(flag.Name)
-		case "cert":
-			ser.TLSCert, err = flags.GetString(flag.Name)
-		case "key":
-			ser.TLSKey, err = flags.GetString(flag.Name)
-		case "root":
-			ser.Root, err = flags.GetString(flag.Name)
-		case "socket":
-			ser.Socket, err = flags.GetString(flag.Name)
-		case "baseURL":
-			ser.BaseURL, err = flags.GetString(flag.Name)
-		case "tokenExpirationTime":
-			ser.TokenExpirationTime, err = flags.GetString(flag.Name)
-		case "disableThumbnails":
-			ser.EnableThumbnails, err = flags.GetBool(flag.Name)
-			ser.EnableThumbnails = !ser.EnableThumbnails
-		case "disablePreviewResize":
-			ser.ResizePreview, err = flags.GetBool(flag.Name)
-			ser.ResizePreview = !ser.ResizePreview
-		case "disableExec":
-			ser.EnableExec, err = flags.GetBool(flag.Name)
-			ser.EnableExec = !ser.EnableExec
-		case "disableTypeDetectionByHeader":
-			ser.TypeDetectionByHeader, err = flags.GetBool(flag.Name)
-			ser.TypeDetectionByHeader = !ser.TypeDetectionByHeader
-		case "disableImageResolutionCalc":
-			ser.ImageResolutionCal, err = flags.GetBool(flag.Name)
-			ser.ImageResolutionCal = !ser.ImageResolutionCal
-
-		// Settings flags from [addConfigFlags]
-		case "signup":
-			set.Signup, err = flags.GetBool(flag.Name)
-		case "hideLoginButton":
-			set.HideLoginButton, err = flags.GetBool(flag.Name)
-		case "createUserDir":
-			set.CreateUserDir, err = flags.GetBool(flag.Name)
-		case "minimumPasswordLength":
-			set.MinimumPasswordLength, err = flags.GetUint(flag.Name)
-		case "shell":
-			var shell string
-			shell, err = flags.GetString(flag.Name)
-			if err == nil {
-				set.Shell = convertCmdStrToCmdArray(shell)
-			}
-		case "fileMode":
-			set.FileMode, err = getAndParseFileMode(flags, flag.Name)
-		case "dirMode":
-			set.DirMode, err = getAndParseFileMode(flags, flag.Name)
-		case "auth.method":
-			hasAuth = true
-		case "auth.logoutPage":
-			set.LogoutPage, err = flags.GetString(flag.Name)
-		case "branding.name":
-			set.Branding.Name, err = flags.GetString(flag.Name)
-		case "branding.theme":
-			set.Branding.Theme, err = flags.GetString(flag.Name)
-		case "branding.color":
-			set.Branding.Color, err = flags.GetString(flag.Name)
-		case "branding.files":
-			set.Branding.Files, err = flags.GetString(flag.Name)
-		case "branding.disableExternal":
-			set.Branding.DisableExternal, err = flags.GetBool(flag.Name)
-		case "branding.disableUsedPercentage":
-			set.Branding.DisableUsedPercentage, err = flags.GetBool(flag.Name)
-		case "tus.chunkSize":
-			set.Tus.ChunkSize, err = flags.GetUint64(flag.Name)
-		case "tus.retryCount":
-			set.Tus.RetryCount, err = flags.GetUint16(flag.Name)
-		}
-
-		if err != nil {
-			errs = append(errs, err)
-		}
-	}
-
-	if all {
-		flags.VisitAll(visit)
-	} else {
-		flags.Visit(visit)
-	}
-
-	err := errors.Join(errs...)
-	if err != nil {
-		return nil, err
-	}
-
-	err = getUserDefaults(flags, &set.Defaults, all)
-	if err != nil {
-		return nil, err
-	}
-
-	if all {
-		set.AuthMethod, auther, err = getAuthentication(flags)
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		set.AuthMethod, auther, err = getAuthentication(flags, hasAuth, set, auther)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return auther, nil
 }

cmd/config_cat.go

@@ -13,19 +13,13 @@ var configCatCmd = &cobra.Command{
 	Short: "Prints the configuration",
 	Long:  `Prints the configuration.`,
 	Args:  cobra.NoArgs,
-	RunE: withStore(func(_ *cobra.Command, _ []string, st *store) error {
+	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		set, err := st.Settings.Get()
+		set, err := d.store.Settings.Get()
-		if err != nil {
+		checkErr(err)
-			return err
+		ser, err := d.store.Settings.GetServer()
-		}
+		checkErr(err)
-		ser, err := st.Settings.GetServer()
+		auther, err := d.store.Auth.Get(set.AuthMethod)
-		if err != nil {
+		checkErr(err)
-			return err
+		printSettings(ser, set, auther)
-		}
+	}, pythonConfig{}),
-		auther, err := st.Auth.Get(set.AuthMethod)
-		if err != nil {
-			return err
-		}
-		return printSettings(ser, set, auther)
-	}, storeOptions{}),
 }

cmd/config_export.go

@@ -15,21 +15,15 @@ var configExportCmd = &cobra.Command{
 json or yaml file. This exported configuration can be changed,
 and imported again with 'config import' command.`,
 	Args: jsonYamlArg,
-	RunE: withStore(func(_ *cobra.Command, args []string, st *store) error {
+	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		settings, err := st.Settings.Get()
+		settings, err := d.store.Settings.Get()
-		if err != nil {
+		checkErr(err)
-			return err
-		}
 
-		server, err := st.Settings.GetServer()
+		server, err := d.store.Settings.GetServer()
-		if err != nil {
+		checkErr(err)
-			return err
-		}
 
-		auther, err := st.Auth.Get(settings.AuthMethod)
+		auther, err := d.store.Auth.Get(settings.AuthMethod)
-		if err != nil {
+		checkErr(err)
-			return err
-		}
 
 		data := &settingsFile{
 			Settings: settings,
@@ -38,9 +32,6 @@ and imported again with 'config import' command.`,
 		}
 
 		err = marshal(args[0], data)
-		if err != nil {
+		checkErr(err)
-			return err
+	}, pythonConfig{}),
-		}
-		return nil
-	}, storeOptions{}),
 }

cmd/config_import.go

@@ -6,10 +6,9 @@ import (
 	"path/filepath"
 	"reflect"
 
-	"github.com/spf13/cobra"
-
 	"github.com/filebrowser/filebrowser/v2/auth"
 	"github.com/filebrowser/filebrowser/v2/settings"
+	"github.com/spf13/cobra"
 )
 
 func init() {
@@ -34,39 +33,26 @@ database.
 
 The path must be for a json or yaml file.`,
 	Args: jsonYamlArg,
-	RunE: withStore(func(_ *cobra.Command, args []string, st *store) error {
+	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
 		var key []byte
-		var err error
+		if d.hadDB {
-		if st.databaseExisted {
+			settings, err := d.store.Settings.Get()
-			settings, settingErr := st.Settings.Get()
+			checkErr(err)
-			if settingErr != nil {
-				return settingErr
-			}
 			key = settings.Key
 		} else {
 			key = generateKey()
 		}
 
 		file := settingsFile{}
-		err = unmarshal(args[0], &file)
+		err := unmarshal(args[0], &file)
-		if err != nil {
+		checkErr(err)
-			return err
-		}
-
-		if file.Settings == nil || file.Server == nil {
-			return errors.New("invalid configuration file: 'settings' or 'server' fields are missing. Please ensure you are importing a file generated by the 'config export' command")
-		}
 
 		file.Settings.Key = key
-		err = st.Settings.Save(file.Settings)
+		err = d.store.Settings.Save(file.Settings)
-		if err != nil {
+		checkErr(err)
-			return err
-		}
 
-		err = st.Settings.SaveServer(file.Server)
+		err = d.store.Settings.SaveServer(file.Server)
-		if err != nil {
+		checkErr(err)
-			return err
-		}
 
 		var rawAuther interface{}
 		if filepath.Ext(args[0]) != ".json" {
@@ -76,51 +62,30 @@ The path must be for a json or yaml file.`,
 		}
 
 		var auther auth.Auther
-		var autherErr error
 		switch file.Settings.AuthMethod {
 		case auth.MethodJSONAuth:
-			var a interface{}
+			auther = getAuther(auth.JSONAuth{}, rawAuther).(*auth.JSONAuth)
-			a, autherErr = getAuther(auth.JSONAuth{}, rawAuther)
-			auther = a.(*auth.JSONAuth)
 		case auth.MethodNoAuth:
-			var a interface{}
+			auther = getAuther(auth.NoAuth{}, rawAuther).(*auth.NoAuth)
-			a, autherErr = getAuther(auth.NoAuth{}, rawAuther)
-			auther = a.(*auth.NoAuth)
 		case auth.MethodProxyAuth:
-			var a interface{}
+			auther = getAuther(auth.ProxyAuth{}, rawAuther).(*auth.ProxyAuth)
-			a, autherErr = getAuther(auth.ProxyAuth{}, rawAuther)
-			auther = a.(*auth.ProxyAuth)
-		case auth.MethodHookAuth:
-			var a interface{}
-			a, autherErr = getAuther(&auth.HookAuth{}, rawAuther)
-			auther = a.(*auth.HookAuth)
 		default:
-			return errors.New("invalid auth method")
+			checkErr(errors.New("invalid auth method"))
 		}
 
-		if autherErr != nil {
+		err = d.store.Auth.Save(auther)
-			return autherErr
+		checkErr(err)
-		}
 
-		err = st.Auth.Save(auther)
+		printSettings(file.Server, file.Settings, auther)
-		if err != nil {
+	}, pythonConfig{allowNoDB: true}),
-			return err
-		}
-
-		return printSettings(file.Server, file.Settings, auther)
-	}, storeOptions{allowsNoDatabase: true}),
 }
 
-func getAuther(sample auth.Auther, data interface{}) (interface{}, error) {
+func getAuther(sample auth.Auther, data interface{}) interface{} {
 	authType := reflect.TypeOf(sample)
 	auther := reflect.New(authType).Interface()
 	bytes, err := json.Marshal(data)
-	if err != nil {
+	checkErr(err)
-		return nil, err
-	}
 	err = json.Unmarshal(bytes, &auther)
-	if err != nil {
+	checkErr(err)
-		return nil, err
+	return auther
-	}
-	return auther, nil
 }

cmd/config_init.go

@@ -2,10 +2,10 @@ package cmd
 
 import (
 	"fmt"
-
+	"strings"
-	"github.com/spf13/cobra"
 
 	"github.com/filebrowser/filebrowser/v2/settings"
+	"github.com/spf13/cobra"
 )
 
 func init() {
@@ -22,40 +22,47 @@ this options can be changed in the future with the command
 to the defaults when creating new users and you don't
 override the options.`,
 	Args: cobra.NoArgs,
-	RunE: withStore(func(cmd *cobra.Command, _ []string, st *store) error {
+	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
+		defaults := settings.UserDefaults{}
 		flags := cmd.Flags()
+		getUserDefaults(flags, &defaults, true)
+		authMethod, auther := getAuthentication(flags)
 
-		// Initialize config
+		s := &settings.Settings{
-		s := &settings.Settings{Key: generateKey()}
+			Key:        generateKey(),
-		ser := &settings.Server{}
+			Signup:     mustGetBool(flags, "signup"),
-
+			Shell:      strings.Split(strings.TrimSpace(mustGetString(flags, "shell")), " "),
-		// Fill config with options
+			AuthMethod: authMethod,
-		auther, err := getSettings(flags, s, ser, nil, true)
+			Defaults:   defaults,
-		if err != nil {
+			Branding: settings.Branding{
-			return err
+				Name:            mustGetString(flags, "branding.name"),
+				DisableExternal: mustGetBool(flags, "branding.disableExternal"),
+				Files:           mustGetString(flags, "branding.files"),
+			},
 		}
 
-		// Save updated config
+		ser := &settings.Server{
-		err = st.Settings.Save(s)
+			Address: mustGetString(flags, "address"),
-		if err != nil {
+			Root:    mustGetString(flags, "root"),
-			return err
+			BaseURL: mustGetString(flags, "baseurl"),
+			TLSKey:  mustGetString(flags, "key"),
+			TLSCert: mustGetString(flags, "cert"),
+			Port:    mustGetString(flags, "port"),
+			Log:     mustGetString(flags, "log"),
 		}
 
-		err = st.Settings.SaveServer(ser)
+		err := d.store.Settings.Save(s)
-		if err != nil {
+		checkErr(err)
-			return err
+		err = d.store.Settings.SaveServer(ser)
-		}
+		checkErr(err)
-
+		err = d.store.Auth.Save(auther)
-		err = st.Auth.Save(auther)
+		checkErr(err)
-		if err != nil {
-			return err
-		}
 
 		fmt.Printf(`
 Congratulations! You've set up your database to use with File Browser.
-Now add your first user via 'filebrowser users add' and then you just
+Now add your first user via 'filebrowser users new' and then you just
 need to call the main command to boot up the server.
 `)
-		return printSettings(ser, s, auther)
+		printSettings(ser, s, auther)
-	}, storeOptions{expectsNoDatabase: true}),
+	}, pythonConfig{noDB: true}),
 }

cmd/config_set.go

@@ -1,7 +1,11 @@
 package cmd
 
 import (
+	"strings"
+
+	"github.com/filebrowser/filebrowser/v2/auth"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
 func init() {
@@ -15,47 +19,62 @@ var configSetCmd = &cobra.Command{
 	Long: `Updates the configuration. Set the flags for the options
 you want to change. Other options will remain unchanged.`,
 	Args: cobra.NoArgs,
-	RunE: withStore(func(cmd *cobra.Command, _ []string, st *store) error {
+	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
 		flags := cmd.Flags()
+		set, err := d.store.Settings.Get()
+		checkErr(err)
 
-		// Read existing config
+		ser, err := d.store.Settings.GetServer()
-		set, err := st.Settings.Get()
+		checkErr(err)
-		if err != nil {
+
-			return err
+		hasAuth := false
+		flags.Visit(func(flag *pflag.Flag) {
+			switch flag.Name {
+			case "baseurl":
+				ser.BaseURL = mustGetString(flags, flag.Name)
+			case "root":
+				ser.Root = mustGetString(flags, flag.Name)
+			case "cert":
+				ser.TLSCert = mustGetString(flags, flag.Name)
+			case "key":
+				ser.TLSKey = mustGetString(flags, flag.Name)
+			case "address":
+				ser.Address = mustGetString(flags, flag.Name)
+			case "port":
+				ser.Port = mustGetString(flags, flag.Name)
+			case "log":
+				ser.Log = mustGetString(flags, flag.Name)
+			case "signup":
+				set.Signup = mustGetBool(flags, flag.Name)
+			case "auth.method":
+				hasAuth = true
+			case "shell":
+				set.Shell = strings.Split(strings.TrimSpace(mustGetString(flags, flag.Name)), " ")
+			case "branding.name":
+				set.Branding.Name = mustGetString(flags, flag.Name)
+			case "branding.disableExternal":
+				set.Branding.DisableExternal = mustGetBool(flags, flag.Name)
+			case "branding.files":
+				set.Branding.Files = mustGetString(flags, flag.Name)
+			}
+		})
+
+		getUserDefaults(flags, &set.Defaults, false)
+
+		var auther auth.Auther
+		if hasAuth {
+			set.AuthMethod, auther = getAuthentication(flags)
+			err = d.store.Auth.Save(auther)
+			checkErr(err)
+		} else {
+			auther, err = d.store.Auth.Get(set.AuthMethod)
+			checkErr(err)
 		}
 
-		ser, err := st.Settings.GetServer()
+		err = d.store.Settings.Save(set)
-		if err != nil {
+		checkErr(err)
-			return err
+		err = d.store.Settings.SaveServer(ser)
-		}
+		checkErr(err)
-
+		printSettings(ser, set, auther)
-		auther, err := st.Auth.Get(set.AuthMethod)
+	}, pythonConfig{}),
-		if err != nil {
-			return err
-		}
-
-		// Get updated config
-		auther, err = getSettings(flags, set, ser, auther, false)
-		if err != nil {
-			return err
-		}
-
-		// Save updated config
-		err = st.Auth.Save(auther)
-		if err != nil {
-			return err
-		}
-
-		err = st.Settings.Save(set)
-		if err != nil {
-			return err
-		}
-
-		err = st.Settings.SaveServer(ser)
-		if err != nil {
-			return err
-		}
-
-		return printSettings(ser, set, auther)
-	}, storeOptions{}),
 }

cmd/docs.go

@@ -3,80 +3,137 @@ package cmd
 import (
 	"bytes"
 	"fmt"
+	"io"
 	"os"
-	"path"
+	"path/filepath"
-	"regexp"
+	"sort"
 	"strings"
 
 	"github.com/spf13/cobra"
-	"github.com/spf13/cobra/doc"
+	"github.com/spf13/pflag"
 )
 
 func init() {
 	rootCmd.AddCommand(docsCmd)
-	docsCmd.Flags().String("out", "www/docs/cli", "directory to write the docs to")
+	docsCmd.Flags().StringP("path", "p", "./docs", "path to save the docs")
+}
+
+func printToc(names []string) {
+	for i, name := range names {
+		name = strings.TrimSuffix(name, filepath.Ext(name))
+		name = strings.Replace(name, "-", " ", -1)
+		names[i] = name
+	}
+
+	sort.Strings(names)
+
+	toc := ""
+	for _, name := range names {
+		toc += "* [" + name + "](cli/" + strings.Replace(name, " ", "-", -1) + ".md)\n"
+	}
+
+	fmt.Println(toc)
 }
 
 var docsCmd = &cobra.Command{
 	Use:    "docs",
 	Hidden: true,
 	Args:   cobra.NoArgs,
-	RunE: func(cmd *cobra.Command, _ []string) error {
+	Run: func(cmd *cobra.Command, args []string) {
-		outputDir, err := cmd.Flags().GetString("out")
+		dir := mustGetString(cmd.Flags(), "path")
-		if err != nil {
+		generateDocs(rootCmd, dir)
-			return err
+		names := []string{}
-		}
 
-		tempDir, err := os.MkdirTemp(os.TempDir(), "filebrowser-docs-")
+		err := filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
+			if err != nil || info.IsDir() {
-			return err
+				return err
-		}
+			}
-		defer os.RemoveAll(tempDir)
 
-		rootCmd.Root().DisableAutoGenTag = true
+			if !strings.HasPrefix(info.Name(), "filebrowser") {
+				return nil
+			}
 
-		err = doc.GenMarkdownTreeCustom(cmd.Root(), tempDir, func(_ string) string {
+			names = append(names, info.Name())
-			return ""
+			return nil
-		}, func(s string) string {
-			return s
 		})
-		if err != nil {
-			return err
-		}
 
-		entries, err := os.ReadDir(tempDir)
+		checkErr(err)
-		if err != nil {
+		printToc(names)
-			return err
-		}
-
-		headerRegex := regexp.MustCompile(`(?m)^(##)(.*)$`)
-		linkRegex := regexp.MustCompile(`\(filebrowser(.*)\.md\)`)
-
-		fmt.Println("Generated Documents:")
-
-		for _, entry := range entries {
-			srcPath := path.Join(tempDir, entry.Name())
-			dstPath := path.Join(outputDir, strings.ReplaceAll(entry.Name(), "_", "-"))
-
-			data, err := os.ReadFile(srcPath)
-			if err != nil {
-				return err
-			}
-
-			data = headerRegex.ReplaceAll(data, []byte("#$2"))
-			data = linkRegex.ReplaceAllFunc(data, func(b []byte) []byte {
-				return bytes.ReplaceAll(b, []byte("_"), []byte("-"))
-			})
-			data = bytes.ReplaceAll(data, []byte("## SEE ALSO"), []byte("## See Also"))
-
-			err = os.WriteFile(dstPath, data, 0666)
-			if err != nil {
-				return err
-			}
-
-			fmt.Println("- " + dstPath)
-		}
-
-		return nil
 	},
 }
+
+func generateDocs(cmd *cobra.Command, dir string) {
+	for _, c := range cmd.Commands() {
+		if !c.IsAvailableCommand() || c.IsAdditionalHelpTopicCommand() {
+			continue
+		}
+
+		generateDocs(c, dir)
+	}
+
+	basename := strings.Replace(cmd.CommandPath(), " ", "-", -1) + ".md"
+	filename := filepath.Join(dir, basename)
+	f, err := os.Create(filename)
+	checkErr(err)
+	defer f.Close()
+	generateMarkdown(cmd, f)
+}
+
+func generateMarkdown(cmd *cobra.Command, w io.Writer) {
+	cmd.InitDefaultHelpCmd()
+	cmd.InitDefaultHelpFlag()
+
+	buf := new(bytes.Buffer)
+	name := cmd.CommandPath()
+
+	short := cmd.Short
+	long := cmd.Long
+	if len(long) == 0 {
+		long = short
+	}
+
+	buf.WriteString("---\ndescription: " + short + "\n---\n\n")
+	buf.WriteString("# " + name + "\n\n")
+	buf.WriteString("## Synopsis\n\n")
+	buf.WriteString(long + "\n\n")
+
+	if cmd.Runnable() {
+		buf.WriteString(fmt.Sprintf("```\n%s\n```\n\n", cmd.UseLine()))
+	}
+
+	if len(cmd.Example) > 0 {
+		buf.WriteString("## Examples\n\n")
+		buf.WriteString(fmt.Sprintf("```\n%s\n```\n\n", cmd.Example))
+	}
+
+	printOptions(buf, cmd, name)
+	_, err := buf.WriteTo(w)
+	checkErr(err)
+}
+
+func generateFlagsTable(fs *pflag.FlagSet, buf *bytes.Buffer) {
+	buf.WriteString("| Name | Shorthand | Usage |\n")
+	buf.WriteString("|------|-----------|-------|\n")
+
+	fs.VisitAll(func(f *pflag.Flag) {
+		buf.WriteString("|" + f.Name + "|" + f.Shorthand + "|" + f.Usage + "|\n")
+	})
+}
+
+func printOptions(buf *bytes.Buffer, cmd *cobra.Command, name string) {
+	flags := cmd.NonInheritedFlags()
+	flags.SetOutput(buf)
+	if flags.HasAvailableFlags() {
+		buf.WriteString("## Options\n\n")
+		generateFlagsTable(flags, buf)
+		buf.WriteString("\n")
+	}
+
+	parentFlags := cmd.InheritedFlags()
+	parentFlags.SetOutput(buf)
+	if parentFlags.HasAvailableFlags() {
+		buf.WriteString("### Inherited\n\n")
+		generateFlagsTable(parentFlags, buf)
+		buf.WriteString("\n")
+	}
+}

cmd/hash.go

@@ -3,9 +3,8 @@ package cmd
 import (
 	"fmt"
 
-	"github.com/spf13/cobra"
-
 	"github.com/filebrowser/filebrowser/v2/users"
+	"github.com/spf13/cobra"
 )
 
 func init() {
@@ -13,16 +12,14 @@ func init() {
 }
 
 var hashCmd = &cobra.Command{
-	Use:   "hash <password>",
+	Use:     "hash <password>",
-	Short: "Hashes a password",
+	Version: rootCmd.Version,
-	Long:  `Hashes a password using bcrypt algorithm.`,
+	Short:   "Hashes a password",
-	Args:  cobra.ExactArgs(1),
+	Long:    `Hashes a password using bcrypt algorithm.`,
-	RunE: func(_ *cobra.Command, args []string) error {
+	Args:    cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
 		pwd, err := users.HashPwd(args[0])
-		if err != nil {
+		checkErr(err)
-			return err
-		}
 		fmt.Println(pwd)
-		return nil
 	},
 }

cmd/root.go

@@ -1,99 +1,49 @@
 package cmd
 
 import (
-	"context"
 	"crypto/tls"
-	"errors"
+	"io/ioutil"
-	"fmt"
-	"io"
-	"io/fs"
 	"log"
 	"net"
 	"net/http"
 	"os"
-	"os/signal"
 	"path/filepath"
-	"syscall"
+	"strings"
-	"time"
-
-	"github.com/spf13/afero"
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-	"github.com/spf13/viper"
-	lumberjack "gopkg.in/natefinch/lumberjack.v2"
 
 	"github.com/filebrowser/filebrowser/v2/auth"
-	"github.com/filebrowser/filebrowser/v2/diskcache"
-	"github.com/filebrowser/filebrowser/v2/frontend"
 	fbhttp "github.com/filebrowser/filebrowser/v2/http"
-	"github.com/filebrowser/filebrowser/v2/img"
 	"github.com/filebrowser/filebrowser/v2/settings"
 	"github.com/filebrowser/filebrowser/v2/storage"
 	"github.com/filebrowser/filebrowser/v2/users"
+	"github.com/filebrowser/filebrowser/v2/version"
+	homedir "github.com/mitchellh/go-homedir"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+	v "github.com/spf13/viper"
+	lumberjack "gopkg.in/natefinch/lumberjack.v2"
 )
 
 var (
-	flagNamesMigrations = map[string]string{
+	cfgFile string
-		"file-mode":                        "fileMode",
-		"dir-mode":                         "dirMode",
-		"hide-login-button":                "hideLoginButton",
-		"create-user-dir":                  "createUserDir",
-		"minimum-password-length":          "minimumPasswordLength",
-		"socket-perm":                      "socketPerm",
-		"disable-thumbnails":               "disableThumbnails",
-		"disable-preview-resize":           "disablePreviewResize",
-		"disable-exec":                     "disableExec",
-		"disable-type-detection-by-header": "disableTypeDetectionByHeader",
-		"img-processors":                   "imageProcessors",
-		"cache-dir":                        "cacheDir",
-		"token-expiration-time":            "tokenExpirationTime",
-		"baseurl":                          "baseURL",
-	}
-
-	warnedFlags = map[string]bool{}
 )
 
-// TODO(remove): remove after July 2026.
-func migrateFlagNames(_ *pflag.FlagSet, name string) pflag.NormalizedName {
-	if newName, ok := flagNamesMigrations[name]; ok {
-
-		if !warnedFlags[name] {
-			warnedFlags[name] = true
-			log.Printf("DEPRECATION NOTICE: Flag --%s has been deprecated, use --%s instead\n", name, newName)
-		}
-
-		name = newName
-	}
-
-	return pflag.NormalizedName(name)
-}
-
 func init() {
-	rootCmd.SilenceUsage = true
+	cobra.OnInitialize(initConfig)
-	rootCmd.SetGlobalNormalizationFunc(migrateFlagNames)
-
-	cobra.MousetrapHelpText = ""
 
 	rootCmd.SetVersionTemplate("File Browser version {{printf \"%s\" .Version}}\n")
 
-	// Flags available across the whole program
-	persistent := rootCmd.PersistentFlags()
-	persistent.StringP("config", "c", "", "config file path")
-	persistent.StringP("database", "d", "./filebrowser.db", "database path")
-
-	// Runtime flags for the root command
 	flags := rootCmd.Flags()
+	persistent := rootCmd.PersistentFlags()
+
+	persistent.StringVarP(&cfgFile, "config", "c", "", "config file path")
+	persistent.StringP("database", "d", "./filebrowser.db", "database path")
 	flags.Bool("noauth", false, "use the noauth auther when using quick setup")
-	flags.String("username", "admin", "username for the first user when using quick setup")
+	flags.String("username", "admin", "username for the first user when using quick config")
-	flags.String("password", "", "hashed password for the first user when using quick setup")
+	flags.String("password", "", "hashed password for the first user when using quick config (default \"admin\")")
-	flags.Uint32("socketPerm", 0666, "unix socket file permissions")
+
-	flags.String("cacheDir", "", "file cache directory (disabled if empty)")
-	flags.Int("imageProcessors", 4, "image processors count")
 	addServerFlags(flags)
 }
 
-// addServerFlags adds server related flags to the given FlagSet. These flags are available
-// in both the root command, config set and config init commands.
 func addServerFlags(flags *pflag.FlagSet) {
 	flags.StringP("address", "a", "127.0.0.1", "address to listen on")
 	flags.StringP("log", "l", "stdout", "log output")
@@ -101,21 +51,15 @@ func addServerFlags(flags *pflag.FlagSet) {
 	flags.StringP("cert", "t", "", "tls certificate")
 	flags.StringP("key", "k", "", "tls key")
 	flags.StringP("root", "r", ".", "root to prepend to relative paths")
-	flags.String("socket", "", "socket to listen to (cannot be used with address, port, cert nor key flags)")
+	flags.StringP("baseurl", "b", "", "base url")
-	flags.StringP("baseURL", "b", "", "base url")
-	flags.String("tokenExpirationTime", "2h", "user session timeout")
-	flags.Bool("disableThumbnails", false, "disable image thumbnails")
-	flags.Bool("disablePreviewResize", false, "disable resize of image previews")
-	flags.Bool("disableExec", true, "disables Command Runner feature")
-	flags.Bool("disableTypeDetectionByHeader", false, "disables type detection by reading file headers")
-	flags.Bool("disableImageResolutionCalc", false, "disables image resolution calculation by reading image files")
 }
 
 var rootCmd = &cobra.Command{
-	Use:   "filebrowser",
+	Use:     "filebrowser",
-	Short: "A stylish web-based file browser",
+	Version: version.Version,
+	Short:   "A stylish web-based file browser",
 	Long: `File Browser CLI lets you create the database to use with File Browser,
-manage your users and all the configurations without accessing the
+manage your users and all the configurations without acessing the
 web interface.
 
 If you've never run File Browser, you'll need to have a database for
@@ -123,245 +67,132 @@ it. Don't worry: you don't need to setup a separate database server.
 We're using Bolt DB which is a single file database and all managed
 by ourselves.
 
-For this command, all flags are available as environmental variables,
+For this specific command, all the flags you have available (except
-except for "--config", which specifies the configuration file to use.
+"config" for the configuration file), can be given either through
-The environment variables are prefixed by "FB_" followed by the flag name in
+environment variables or configuration files.
-UPPER_SNAKE_CASE. For example, the flag "--disablePreviewResize" is available
-as FB_DISABLE_PREVIEW_RESIZE.
 
-If "--config" is not specified, File Browser will look for a configuration
+If you don't set "config", it will look for a configuration file called
-file named .filebrowser.{json, toml, yaml, yml} in the following directories:
+.filebrowser.{json, toml, yaml, yml} in the following directories:
 
 - ./
 - $HOME/
 - /etc/filebrowser/
 
-**Note:** Only the options listed below can be set via the config file or
-environment variables. Other configuration options live exclusively in the
-database and so they must be set by the "config set" or "config
-import" commands.
-
 The precedence of the configuration values are as follows:
 
-- Flags
+- flags
-- Environment variables
+- environment variables
-- Configuration file
+- configuration file
-- Database values
+- database values
-- Defaults
+- defaults
+
+The environment variables are prefixed by "FB_" followed by the option
+name in caps. So to set "database" via an env variable, you should
+set FB_DATABASE.
 
 Also, if the database path doesn't exist, File Browser will enter into
-the quick setup mode and a new database will be bootstrapped and a new
+the quick setup mode and a new database will be bootstraped and a new
 user created with the credentials from options "username" and "password".`,
-	RunE: withViperAndStore(func(_ *cobra.Command, _ []string, v *viper.Viper, st *store) error {
+	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		if !st.databaseExisted {
+		log.Println(cfgFile)
-			err := quickSetup(v, st.Storage)
+
-			if err != nil {
+		if !d.hadDB {
-				return err
+			quickSetup(cmd.Flags(), d)
-			}
 		}
 
-		// build img service
+		server := getRunParams(cmd.Flags(), d.store)
-		imgWorkersCount := v.GetInt("imageProcessors")
-		if imgWorkersCount < 1 {
-			return errors.New("image resize workers count could not be < 1")
-		}
-		imageService := img.New(imgWorkersCount)
-
-		var fileCache diskcache.Interface = diskcache.NewNoOp()
-		cacheDir := v.GetString("cacheDir")
-		if cacheDir != "" {
-			if err := os.MkdirAll(cacheDir, 0700); err != nil {
-				return fmt.Errorf("can't make directory %s: %w", cacheDir, err)
-			}
-			fileCache = diskcache.New(afero.NewOsFs(), cacheDir)
-		}
-
-		server, err := getServerSettings(v, st.Storage)
-		if err != nil {
-			return err
-		}
 		setupLog(server.Log)
 
 		root, err := filepath.Abs(server.Root)
-		if err != nil {
+		checkErr(err)
-			return err
-		}
 		server.Root = root
 
 		adr := server.Address + ":" + server.Port
 
 		var listener net.Listener
 
-		switch {
+		if server.TLSKey != "" && server.TLSCert != "" {
-		case server.Socket != "":
-			listener, err = net.Listen("unix", server.Socket)
-			if err != nil {
-				return err
-			}
-			socketPerm := v.GetUint32("socketPerm")
-			err = os.Chmod(server.Socket, os.FileMode(socketPerm))
-			if err != nil {
-				return err
-			}
-		case server.TLSKey != "" && server.TLSCert != "":
 			cer, err := tls.LoadX509KeyPair(server.TLSCert, server.TLSKey)
-			if err != nil {
+			checkErr(err)
-				return err
+			listener, err = tls.Listen("tcp", adr, &tls.Config{Certificates: []tls.Certificate{cer}})
-			}
+			checkErr(err)
-			listener, err = tls.Listen("tcp", adr, &tls.Config{
+		} else {
-				MinVersion:   tls.VersionTLS12,
-				Certificates: []tls.Certificate{cer}},
-			)
-			if err != nil {
-				return err
-			}
-		default:
 			listener, err = net.Listen("tcp", adr)
-			if err != nil {
+			checkErr(err)
-				return err
-			}
 		}
 
-		assetsFs, err := fs.Sub(frontend.Assets(), "dist")
+		handler, err := fbhttp.NewHandler(d.store, server)
-		if err != nil {
+		checkErr(err)
-			panic(err)
-		}
-
-		handler, err := fbhttp.NewHandler(imageService, fileCache, st.Storage, server, assetsFs)
-		if err != nil {
-			return err
-		}
-
-		defer listener.Close()
 
 		log.Println("Listening on", listener.Addr().String())
-		srv := &http.Server{
+		if err := http.Serve(listener, handler); err != nil {
-			Handler:           handler,
+			log.Fatal(err)
-			ReadHeaderTimeout: 60 * time.Second,
 		}
-
+	}, pythonConfig{allowNoDB: true}),
-		go func() {
-			if err := srv.Serve(listener); !errors.Is(err, http.ErrServerClosed) {
-				log.Fatalf("HTTP server error: %v", err)
-			}
-
-			log.Println("Stopped serving new connections.")
-		}()
-
-		sigc := make(chan os.Signal, 1)
-		signal.Notify(sigc,
-			os.Interrupt,
-			syscall.SIGHUP,
-			syscall.SIGINT,
-			syscall.SIGTERM,
-			syscall.SIGQUIT,
-		)
-		sig := <-sigc
-		log.Println("Got signal:", sig)
-
-		shutdownCtx, shutdownRelease := context.WithTimeout(context.Background(), 10*time.Second)
-		defer shutdownRelease()
-
-		if err := srv.Shutdown(shutdownCtx); err != nil {
-			log.Fatalf("HTTP shutdown error: %v", err)
-		}
-		log.Println("Graceful shutdown complete.")
-
-		return nil
-	}, storeOptions{allowsNoDatabase: true}),
 }
 
-func getServerSettings(v *viper.Viper, st *storage.Storage) (*settings.Server, error) {
+func getRunParams(flags *pflag.FlagSet, st *storage.Storage) *settings.Server {
 	server, err := st.Settings.GetServer()
-	if err != nil {
+	checkErr(err)
-		return nil, err
+
+	if val, set := getParamB(flags, "root"); set {
+		server.Root = val
 	}
 
-	isSocketSet := false
+	if val, set := getParamB(flags, "baseurl"); set {
-	isAddrSet := false
+		server.BaseURL = val
-
-	if v.IsSet("address") {
-		server.Address = v.GetString("address")
-		isAddrSet = true
 	}
 
-	if v.IsSet("log") {
+	if val, set := getParamB(flags, "address"); set {
-		server.Log = v.GetString("log")
+		server.Address = val
 	}
 
-	if v.IsSet("port") {
+	if val, set := getParamB(flags, "port"); set {
-		server.Port = v.GetString("port")
+		server.Port = val
-		isAddrSet = true
 	}
 
-	if v.IsSet("cert") {
+	if val, set := getParamB(flags, "log"); set {
-		server.TLSCert = v.GetString("cert")
+		server.Log = val
-		isAddrSet = true
 	}
 
-	if v.IsSet("key") {
+	if val, set := getParamB(flags, "key"); set {
-		server.TLSKey = v.GetString("key")
+		server.TLSKey = val
-		isAddrSet = true
 	}
 
-	if v.IsSet("root") {
+	if val, set := getParamB(flags, "cert"); set {
-		server.Root = v.GetString("root")
+		server.TLSCert = val
 	}
 
-	if v.IsSet("socket") {
+	return server
-		server.Socket = v.GetString("socket")
+}
-		isSocketSet = true
+
+// getParamB returns a parameter as a string and a boolean to tell if it is different from the default
+//
+// NOTE: we could simply bind the flags to viper and use IsSet.
+// Although there is a bug on Viper that always returns true on IsSet
+// if a flag is binded. Our alternative way is to manually check
+// the flag and then the value from env/config/gotten by viper.
+// https://github.com/spf13/viper/pull/331
+func getParamB(flags *pflag.FlagSet, key string) (string, bool) {
+	value, _ := flags.GetString(key)
+
+	// If set on Flags, use it.
+	if flags.Changed(key) {
+		return value, true
 	}
 
-	if v.IsSet("baseURL") {
+	// If set through viper (env, config), return it.
-		server.BaseURL = v.GetString("baseURL")
+	if v.IsSet(key) {
-		// TODO(remove): remove after July 2026.
+		return v.GetString(key), true
-	} else if v := os.Getenv("FB_BASEURL"); v != "" {
-		log.Println("DEPRECATION NOTICE: Environment variable FB_BASEURL has been deprecated, use FB_BASE_URL instead")
-		server.BaseURL = v
 	}
 
-	if v.IsSet("tokenExpirationTime") {
+	// Otherwise use default value on flags.
-		server.TokenExpirationTime = v.GetString("tokenExpirationTime")
+	return value, false
-	}
+}
 
-	if v.IsSet("disableThumbnails") {
+func getParam(flags *pflag.FlagSet, key string) string {
-		server.EnableThumbnails = !v.GetBool("disableThumbnails")
+	val, _ := getParamB(flags, key)
-	}
+	return val
-
-	if v.IsSet("disablePreviewResize") {
-		server.ResizePreview = !v.GetBool("disablePreviewResize")
-	}
-
-	if v.IsSet("disableTypeDetectionByHeader") {
-		server.TypeDetectionByHeader = !v.GetBool("disableTypeDetectionByHeader")
-	}
-
-	if v.IsSet("disableImageResolutionCalc") {
-		server.ImageResolutionCal = !v.GetBool("disableImageResolutionCalc")
-	}
-
-	if v.IsSet("disableExec") {
-		server.EnableExec = !v.GetBool("disableExec")
-	}
-
-	if isAddrSet && isSocketSet {
-		return nil, errors.New("--socket flag cannot be used with --address, --port, --key nor --cert")
-	}
-
-	// Do not use saved Socket if address was manually set.
-	if isAddrSet && server.Socket != "" {
-		server.Socket = ""
-	}
-
-	if server.EnableExec {
-		log.Println("WARNING: Command Runner feature enabled!")
-		log.Println("WARNING: This feature has known security vulnerabilities and should not")
-		log.Println("WARNING: you fully understand the risks involved. For more information")
-		log.Println("WARNING: read https://github.com/filebrowser/filebrowser/issues/5199")
-	}
-
-	return server, nil
 }
 
 func setupLog(logMethod string) {
@@ -371,7 +202,7 @@ func setupLog(logMethod string) {
 	case "stderr":
 		log.SetOutput(os.Stderr)
 	case "":
-		log.SetOutput(io.Discard)
+		log.SetOutput(ioutil.Discard)
 	default:
 		log.SetOutput(&lumberjack.Logger{
 			Filename:   logMethod,
@@ -382,22 +213,13 @@ func setupLog(logMethod string) {
 	}
 }
 
-func quickSetup(v *viper.Viper, s *storage.Storage) error {
+func quickSetup(flags *pflag.FlagSet, d pythonData) {
-	log.Println("Performing quick setup")
-
 	set := &settings.Settings{
-		Key:                   generateKey(),
+		Key:    generateKey(),
-		Signup:                false,
+		Signup: false,
-		HideLoginButton:       true,
-		CreateUserDir:         false,
-		MinimumPasswordLength: settings.DefaultMinimumPasswordLength,
-		UserHomeBasePath:      settings.DefaultUsersHomeBasePath,
 		Defaults: settings.UserDefaults{
-			Scope:                 ".",
+			Scope:  ".",
-			Locale:                "en",
+			Locale: "en",
-			SingleClick:           false,
-			RedirectAfterCopyMove: true,
-			AceEditorTheme:        v.GetString("defaults.aceEditorTheme"),
 			Perm: users.Permissions{
 				Admin:    false,
 				Execute:  true,
@@ -409,72 +231,40 @@ func quickSetup(v *viper.Viper, s *storage.Storage) error {
 				Download: true,
 			},
 		},
-		AuthMethod: "",
-		Branding:   settings.Branding{},
-		Tus: settings.Tus{
-			ChunkSize:  settings.DefaultTusChunkSize,
-			RetryCount: settings.DefaultTusRetryCount,
-		},
-		Commands: nil,
-		Shell:    nil,
-		Rules:    nil,
 	}
 
 	var err error
-	if v.GetBool("noauth") {
+	if _, noauth := getParamB(flags, "noauth"); noauth {
 		set.AuthMethod = auth.MethodNoAuth
-		err = s.Auth.Save(&auth.NoAuth{})
+		err = d.store.Auth.Save(&auth.NoAuth{})
 	} else {
 		set.AuthMethod = auth.MethodJSONAuth
-		err = s.Auth.Save(&auth.JSONAuth{})
+		err = d.store.Auth.Save(&auth.JSONAuth{})
-	}
-	if err != nil {
-		return err
 	}
 
-	err = s.Settings.Save(set)
+	checkErr(err)
-	if err != nil {
+	err = d.store.Settings.Save(set)
-		return err
+	checkErr(err)
-	}
 
 	ser := &settings.Server{
-		BaseURL:               v.GetString("baseURL"),
+		BaseURL: getParam(flags, "baseurl"),
-		Port:                  v.GetString("port"),
+		Port:    getParam(flags, "port"),
-		Log:                   v.GetString("log"),
+		Log:     getParam(flags, "log"),
-		TLSKey:                v.GetString("key"),
+		TLSKey:  getParam(flags, "key"),
-		TLSCert:               v.GetString("cert"),
+		TLSCert: getParam(flags, "cert"),
-		Address:               v.GetString("address"),
+		Address: getParam(flags, "address"),
-		Root:                  v.GetString("root"),
+		Root:    getParam(flags, "root"),
-		TokenExpirationTime:   v.GetString("tokenExpirationTime"),
-		EnableThumbnails:      !v.GetBool("disableThumbnails"),
-		ResizePreview:         !v.GetBool("disablePreviewResize"),
-		EnableExec:            !v.GetBool("disableExec"),
-		TypeDetectionByHeader: !v.GetBool("disableTypeDetectionByHeader"),
-		ImageResolutionCal:    !v.GetBool("disableImageResolutionCalc"),
 	}
 
-	err = s.Settings.SaveServer(ser)
+	err = d.store.Settings.SaveServer(ser)
-	if err != nil {
+	checkErr(err)
-		return err
-	}
 
-	username := v.GetString("username")
+	username := getParam(flags, "username")
-	password := v.GetString("password")
+	password := getParam(flags, "password")
 
 	if password == "" {
-		var pwd string
+		password, err = users.HashPwd("admin")
-		pwd, err = users.RandomPwd(set.MinimumPasswordLength)
+		checkErr(err)
-		if err != nil {
-			return err
-		}
-
-		log.Printf("User '%s' initialized with randomly generated password: %s\n", username, pwd)
-		password, err = users.ValidateAndHashPwd(pwd, set.MinimumPasswordLength)
-		if err != nil {
-			return err
-		}
-	} else {
-		log.Printf("User '%s' initialize wth user-provided password\n", username)
 	}
 
 	if username == "" || password == "" {
@@ -490,5 +280,33 @@ func quickSetup(v *viper.Viper, s *storage.Storage) error {
 	set.Defaults.Apply(user)
 	user.Perm.Admin = true
 
-	return s.Users.Save(user)
+	err = d.store.Users.Save(user)
+	checkErr(err)
+}
+
+func initConfig() {
+	if cfgFile == "" {
+		home, err := homedir.Dir()
+		checkErr(err)
+		v.AddConfigPath(".")
+		v.AddConfigPath(home)
+		v.AddConfigPath("/etc/filebrowser/")
+		v.SetConfigName(".filebrowser")
+	} else {
+		v.SetConfigFile(cfgFile)
+	}
+
+	v.SetEnvPrefix("FB")
+	v.AutomaticEnv()
+	v.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
+
+	if err := v.ReadInConfig(); err != nil {
+		if _, ok := err.(v.ConfigParseError); ok {
+			panic(err)
+		}
+		cfgFile = "No config file used"
+	} else {
+		cfgFile = "Using config file: " + v.ConfigFileUsed()
+	}
+
 }

cmd/rule_rm.go

@@ -3,16 +3,15 @@ package cmd
 import (
 	"strconv"
 
-	"github.com/spf13/cobra"
-
 	"github.com/filebrowser/filebrowser/v2/settings"
 	"github.com/filebrowser/filebrowser/v2/users"
+	"github.com/spf13/cobra"
 )
 
 func init() {
 	rulesCmd.AddCommand(rulesRmCommand)
 	rulesRmCommand.Flags().Uint("index", 0, "index of rule to remove")
-	_ = rulesRmCommand.MarkFlagRequired("index")
+	rulesRmCommand.MarkFlagRequired("index")
 }
 
 var rulesRmCommand = &cobra.Command{
@@ -40,29 +39,27 @@ including 'index_end'.`,
 
 		return nil
 	},
-	RunE: withStore(func(cmd *cobra.Command, args []string, st *store) error {
+	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
 		i, err := strconv.Atoi(args[0])
-		if err != nil {
+		checkErr(err)
-			return err
-		}
 		f := i
 		if len(args) == 2 {
 			f, err = strconv.Atoi(args[1])
-			if err != nil {
+			checkErr(err)
-				return err
-			}
 		}
 
-		user := func(u *users.User) error {
+		user := func(u *users.User) {
 			u.Rules = append(u.Rules[:i], u.Rules[f+1:]...)
-			return st.Users.Save(u)
+			err := d.store.Users.Save(u)
+			checkErr(err)
 		}
 
-		global := func(s *settings.Settings) error {
+		global := func(s *settings.Settings) {
 			s.Rules = append(s.Rules[:i], s.Rules[f+1:]...)
-			return st.Settings.Save(s)
+			err := d.store.Settings.Save(s)
+			checkErr(err)
 		}
 
-		return runRules(st.Storage, cmd, user, global)
+		runRules(d.store, cmd, user, global)
-	}, storeOptions{}),
+	}, pythonConfig{}),
 }

cmd/rules.go

@@ -3,13 +3,12 @@ package cmd
 import (
 	"fmt"
 
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-
 	"github.com/filebrowser/filebrowser/v2/rules"
 	"github.com/filebrowser/filebrowser/v2/settings"
 	"github.com/filebrowser/filebrowser/v2/storage"
 	"github.com/filebrowser/filebrowser/v2/users"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
 func init() {
@@ -19,8 +18,9 @@ func init() {
 }
 
 var rulesCmd = &cobra.Command{
-	Use:   "rules",
+	Use:     "rules",
-	Short: "Rules management utility",
+	Version: rootCmd.Version,
+	Short:   "Rules management utility",
 	Long: `On each subcommand you'll have available at least two flags:
 "username" and "id". You must either set only one of them
 or none. If you set one of them, the command will apply to
@@ -29,73 +29,51 @@ rules.`,
 	Args: cobra.NoArgs,
 }
 
-func runRules(st *storage.Storage, cmd *cobra.Command, usersFn func(*users.User) error, globalFn func(*settings.Settings) error) error {
+func runRules(st *storage.Storage, cmd *cobra.Command, users func(*users.User), global func(*settings.Settings)) {
-	id, err := getUserIdentifier(cmd.Flags())
+	id := getUserIdentifier(cmd.Flags())
-	if err != nil {
-		return err
-	}
 	if id != nil {
-		var user *users.User
+		user, err := st.Users.Get("", id)
-		user, err = st.Users.Get("", id)
+		checkErr(err)
-		if err != nil {
-			return err
-		}
 
-		if usersFn != nil {
+		if users != nil {
-			err = usersFn(user)
+			users(user)
-			if err != nil {
-				return err
-			}
 		}
 
 		printRules(user.Rules, id)
-		return nil
+		return
 	}
 
 	s, err := st.Settings.Get()
-	if err != nil {
+	checkErr(err)
-		return err
-	}
 
-	if globalFn != nil {
+	if global != nil {
-		err = globalFn(s)
+		global(s)
-		if err != nil {
-			return err
-		}
 	}
 
 	printRules(s.Rules, id)
+}
+
+func getUserIdentifier(flags *pflag.FlagSet) interface{} {
+	id := mustGetUint(flags, "id")
+	username := mustGetString(flags, "username")
+
+	if id != 0 {
+		return id
+	} else if username != "" {
+		return username
+	}
+
 	return nil
 }
 
-func getUserIdentifier(flags *pflag.FlagSet) (interface{}, error) {
+func printRules(rules []rules.Rule, id interface{}) {
-	id, err := flags.GetUint("id")
-	if err != nil {
-		return nil, err
-	}
-
-	username, err := flags.GetString("username")
-	if err != nil {
-		return nil, err
-	}
-
-	if id != 0 {
-		return id, nil
-	} else if username != "" {
-		return username, nil
-	}
-
-	return nil, nil
-}
-
-func printRules(rulez []rules.Rule, id interface{}) {
 	if id == nil {
 		fmt.Printf("Global Rules:\n\n")
 	} else {
 		fmt.Printf("Rules for user %v:\n\n", id)
 	}
 
-	for id, rule := range rulez {
+	for id, rule := range rules {
 		fmt.Printf("(%d) ", id)
 		if rule.Regex {
 			if rule.Allow {

cmd/rules_add.go

@@ -3,11 +3,10 @@ package cmd
 import (
 	"regexp"
 
-	"github.com/spf13/cobra"
-
 	"github.com/filebrowser/filebrowser/v2/rules"
 	"github.com/filebrowser/filebrowser/v2/settings"
 	"github.com/filebrowser/filebrowser/v2/users"
+	"github.com/spf13/cobra"
 )
 
 func init() {
@@ -21,19 +20,9 @@ var rulesAddCmd = &cobra.Command{
 	Short: "Add a global rule or user rule",
 	Long:  `Add a global rule or user rule.`,
 	Args:  cobra.ExactArgs(1),
-	RunE: withStore(func(cmd *cobra.Command, args []string, st *store) error {
+	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		flags := cmd.Flags()
+		allow := mustGetBool(cmd.Flags(), "allow")
-
+		regex := mustGetBool(cmd.Flags(), "regex")
-		allow, err := flags.GetBool("allow")
-		if err != nil {
-			return err
-		}
-
-		regex, err := flags.GetBool("regex")
-		if err != nil {
-			return err
-		}
-
 		exp := args[0]
 
 		if regex {
@@ -51,16 +40,18 @@ var rulesAddCmd = &cobra.Command{
 			rule.Path = exp
 		}
 
-		user := func(u *users.User) error {
+		user := func(u *users.User) {
 			u.Rules = append(u.Rules, rule)
-			return st.Users.Save(u)
+			err := d.store.Users.Save(u)
+			checkErr(err)
 		}
 
-		global := func(s *settings.Settings) error {
+		global := func(s *settings.Settings) {
 			s.Rules = append(s.Rules, rule)
-			return st.Settings.Save(s)
+			err := d.store.Settings.Save(s)
+			checkErr(err)
 		}
 
-		return runRules(st.Storage, cmd, user, global)
+		runRules(d.store, cmd, user, global)
-	}, storeOptions{}),
+	}, pythonConfig{}),
 }

cmd/rules_ls.go

@@ -13,7 +13,7 @@ var rulesLsCommand = &cobra.Command{
 	Short: "List global rules or user specific rules",
 	Long:  `List global rules or user specific rules.`,
 	Args:  cobra.NoArgs,
-	RunE: withStore(func(cmd *cobra.Command, _ []string, st *store) error {
+	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		return runRules(st.Storage, cmd, nil, nil)
+		runRules(d.store, cmd, nil, nil)
-	}, storeOptions{}),
+	}, pythonConfig{}),
 }

cmd/upgrade.go

@@ -0,0 +1,31 @@
+package cmd
+
+import (
+	"github.com/filebrowser/filebrowser/v2/storage/bolt/importer"
+	"github.com/spf13/cobra"
+)
+
+func init() {
+	rootCmd.AddCommand(upgradeCmd)
+
+	upgradeCmd.Flags().String("old.database", "", "")
+	upgradeCmd.Flags().String("old.config", "", "")
+	upgradeCmd.MarkFlagRequired("old.database")
+}
+
+var upgradeCmd = &cobra.Command{
+	Use:     "upgrade",
+	Version: rootCmd.Version,
+	Short:   "Upgrades an old configuration",
+	Long: `Upgrades an old configuration. This command DOES NOT
+import share links because they are incompatible with
+this version.`,
+	Args: cobra.NoArgs,
+	Run: func(cmd *cobra.Command, args []string) {
+		flags := cmd.Flags()
+		oldDB := mustGetString(flags, "old.database")
+		oldConf := mustGetString(flags, "old.config")
+		err := importer.Import(oldDB, oldConf, getParam(flags, "database"))
+		checkErr(err)
+	},
+}

cmd/users.go

@@ -7,11 +7,10 @@ import (
 	"strconv"
 	"text/tabwriter"
 
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-
 	"github.com/filebrowser/filebrowser/v2/settings"
 	"github.com/filebrowser/filebrowser/v2/users"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
 func init() {
@@ -19,46 +18,45 @@ func init() {
 }
 
 var usersCmd = &cobra.Command{
-	Use:   "users",
+	Use:     "users",
-	Short: "Users management utility",
+	Version: rootCmd.Version,
-	Long:  `Users management utility.`,
+	Short:   "Users management utility",
-	Args:  cobra.NoArgs,
+	Long:    `Users management utility.`,
+	Args:    cobra.NoArgs,
 }
 
-func printUsers(usrs []*users.User) {
+func printUsers(users []*users.User) {
 	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
-	fmt.Fprintln(w, "ID\tUsername\tScope\tLocale\tV. Mode\tS.Click\tAdmin\tExecute\tCreate\tRename\tModify\tDelete\tShare\tDownload\tPwd Lock")
+	fmt.Fprintln(w, "ID\tUsername\tScope\tLocale\tV. Mode\tAdmin\tExecute\tCreate\tRename\tModify\tDelete\tShare\tDownload\tPwd Lock")
 
-	for _, u := range usrs {
+	for _, user := range users {
-		fmt.Fprintf(w, "%d\t%s\t%s\t%s\t%s\t%t\t%t\t%t\t%t\t%t\t%t\t%t\t%t\t%t\t%t\t%t\t\n",
+		fmt.Fprintf(w, "%d\t%s\t%s\t%s\t%s\t%t\t%t\t%t\t%t\t%t\t%t\t%t\t%t\t%t\t\n",
-			u.ID,
+			user.ID,
-			u.Username,
+			user.Username,
-			u.Scope,
+			user.Scope,
-			u.Locale,
+			user.Locale,
-			u.ViewMode,
+			user.ViewMode,
-			u.SingleClick,
+			user.Perm.Admin,
-			u.RedirectAfterCopyMove,
+			user.Perm.Execute,
-			u.Perm.Admin,
+			user.Perm.Create,
-			u.Perm.Execute,
+			user.Perm.Rename,
-			u.Perm.Create,
+			user.Perm.Modify,
-			u.Perm.Rename,
+			user.Perm.Delete,
-			u.Perm.Modify,
+			user.Perm.Share,
-			u.Perm.Delete,
+			user.Perm.Download,
-			u.Perm.Share,
+			user.LockPassword,
-			u.Perm.Download,
-			u.LockPassword,
 		)
 	}
 
 	w.Flush()
 }
 
-func parseUsernameOrID(arg string) (username string, id uint) {
+func parseUsernameOrID(arg string) (string, uint) {
-	id64, err := strconv.ParseUint(arg, 10, 64)
+	id, err := strconv.ParseUint(arg, 10, 0)
 	if err != nil {
 		return arg, 0
 	}
-	return "", uint(id64)
+	return "", uint(id)
 }
 
 func addUserFlags(flags *pflag.FlagSet) {
@@ -77,73 +75,49 @@ func addUserFlags(flags *pflag.FlagSet) {
 	flags.String("scope", ".", "scope for users")
 	flags.String("locale", "en", "locale for users")
 	flags.String("viewMode", string(users.ListViewMode), "view mode for users")
-	flags.Bool("singleClick", false, "use single clicks only")
-	flags.Bool("redirectAfterCopyMove", false, "redirect to destination after copy/move")
-	flags.Bool("dateFormat", false, "use date format (true for absolute time, false for relative)")
-	flags.Bool("hideDotfiles", false, "hide dotfiles")
-	flags.String("aceEditorTheme", "", "ace editor's syntax highlighting theme for users")
 }
 
-func getAndParseViewMode(flags *pflag.FlagSet) (users.ViewMode, error) {
+func getViewMode(flags *pflag.FlagSet) users.ViewMode {
-	viewModeStr, err := flags.GetString("viewMode")
+	viewMode := users.ViewMode(mustGetString(flags, "viewMode"))
-	if err != nil {
-		return "", err
-	}
-
-	viewMode := users.ViewMode(viewModeStr)
 	if viewMode != users.ListViewMode && viewMode != users.MosaicViewMode {
-		return "", errors.New("view mode must be \"" + string(users.ListViewMode) + "\" or \"" + string(users.MosaicViewMode) + "\"")
+		checkErr(errors.New("view mode must be \"" + string(users.ListViewMode) + "\" or \"" + string(users.MosaicViewMode) + "\""))
 	}
-
+	return viewMode
-	return viewMode, nil
 }
 
-func getUserDefaults(flags *pflag.FlagSet, defaults *settings.UserDefaults, all bool) error {
+func getUserDefaults(flags *pflag.FlagSet, defaults *settings.UserDefaults, all bool) {
-	errs := []error{}
-
 	visit := func(flag *pflag.Flag) {
-		var err error
 		switch flag.Name {
 		case "scope":
-			defaults.Scope, err = flags.GetString(flag.Name)
+			defaults.Scope = mustGetString(flags, flag.Name)
 		case "locale":
-			defaults.Locale, err = flags.GetString(flag.Name)
+			defaults.Locale = mustGetString(flags, flag.Name)
 		case "viewMode":
-			defaults.ViewMode, err = getAndParseViewMode(flags)
+			defaults.ViewMode = getViewMode(flags)
-		case "singleClick":
-			defaults.SingleClick, err = flags.GetBool(flag.Name)
-		case "redirectAfterCopyMove":
-			defaults.RedirectAfterCopyMove, err = flags.GetBool(flag.Name)
-		case "aceEditorTheme":
-			defaults.AceEditorTheme, err = flags.GetString(flag.Name)
 		case "perm.admin":
-			defaults.Perm.Admin, err = flags.GetBool(flag.Name)
+			defaults.Perm.Admin = mustGetBool(flags, flag.Name)
 		case "perm.execute":
-			defaults.Perm.Execute, err = flags.GetBool(flag.Name)
+			defaults.Perm.Execute = mustGetBool(flags, flag.Name)
 		case "perm.create":
-			defaults.Perm.Create, err = flags.GetBool(flag.Name)
+			defaults.Perm.Create = mustGetBool(flags, flag.Name)
 		case "perm.rename":
-			defaults.Perm.Rename, err = flags.GetBool(flag.Name)
+			defaults.Perm.Rename = mustGetBool(flags, flag.Name)
 		case "perm.modify":
-			defaults.Perm.Modify, err = flags.GetBool(flag.Name)
+			defaults.Perm.Modify = mustGetBool(flags, flag.Name)
 		case "perm.delete":
-			defaults.Perm.Delete, err = flags.GetBool(flag.Name)
+			defaults.Perm.Delete = mustGetBool(flags, flag.Name)
 		case "perm.share":
-			defaults.Perm.Share, err = flags.GetBool(flag.Name)
+			defaults.Perm.Share = mustGetBool(flags, flag.Name)
 		case "perm.download":
-			defaults.Perm.Download, err = flags.GetBool(flag.Name)
+			defaults.Perm.Download = mustGetBool(flags, flag.Name)
 		case "commands":
-			defaults.Commands, err = flags.GetStringSlice(flag.Name)
+			commands, err := flags.GetStringSlice(flag.Name)
+			checkErr(err)
+			defaults.Commands = commands
 		case "sorting.by":
-			defaults.Sorting.By, err = flags.GetString(flag.Name)
+			defaults.Sorting.By = mustGetString(flags, flag.Name)
 		case "sorting.asc":
-			defaults.Sorting.Asc, err = flags.GetBool(flag.Name)
+			defaults.Sorting.Asc = mustGetBool(flags, flag.Name)
-		case "hideDotfiles":
-			defaults.HideDotfiles, err = flags.GetBool(flag.Name)
-		}
-
-		if err != nil {
-			errs = append(errs, err)
 		}
 	}
 
@@ -152,6 +126,4 @@ func getUserDefaults(flags *pflag.FlagSet, defaults *settings.UserDefaults, all
 	} else {
 		flags.Visit(visit)
 	}
-
-	return errors.Join(errs...)
 }

cmd/users_add.go

@@ -1,9 +1,8 @@
 package cmd
 
 import (
-	"github.com/spf13/cobra"
-
 	"github.com/filebrowser/filebrowser/v2/users"
+	"github.com/spf13/cobra"
 )
 
 func init() {
@@ -16,67 +15,23 @@ var usersAddCmd = &cobra.Command{
 	Short: "Create a new user",
 	Long:  `Create a new user and add it to the database.`,
 	Args:  cobra.ExactArgs(2),
-	RunE: withStore(func(cmd *cobra.Command, args []string, st *store) error {
+	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		flags := cmd.Flags()
+		s, err := d.store.Settings.Get()
-		s, err := st.Settings.Get()
+		checkErr(err)
-		if err != nil {
+		getUserDefaults(cmd.Flags(), &s.Defaults, false)
-			return err
-		}
-		err = getUserDefaults(flags, &s.Defaults, false)
-		if err != nil {
-			return err
-		}
 
-		password, err := users.ValidateAndHashPwd(args[1], s.MinimumPasswordLength)
+		password, err := users.HashPwd(args[1])
-		if err != nil {
+		checkErr(err)
-			return err
-		}
 
 		user := &users.User{
-			Username: args[0],
+			Username:     args[0],
-			Password: password,
+			Password:     password,
-		}
+			LockPassword: mustGetBool(cmd.Flags(), "lockPassword"),
-
-		user.LockPassword, err = flags.GetBool("lockPassword")
-		if err != nil {
-			return err
-		}
-
-		user.DateFormat, err = flags.GetBool("dateFormat")
-		if err != nil {
-			return err
-		}
-
-		user.HideDotfiles, err = flags.GetBool("hideDotfiles")
-		if err != nil {
-			return err
 		}
 
 		s.Defaults.Apply(user)
-
+		err = d.store.Users.Save(user)
-		servSettings, err := st.Settings.GetServer()
+		checkErr(err)
-		if err != nil {
-			return err
-		}
-		// since getUserDefaults() polluted s.Defaults.Scope
-		// which makes the Scope not the one saved in the db
-		// we need the right s.Defaults.Scope here
-		s2, err := st.Settings.Get()
-		if err != nil {
-			return err
-		}
-
-		userHome, err := s2.MakeUserDir(user.Username, user.Scope, servSettings.Root)
-		if err != nil {
-			return err
-		}
-		user.Scope = userHome
-
-		err = st.Users.Save(user)
-		if err != nil {
-			return err
-		}
 		printUsers([]*users.User{user})
-		return nil
+	}, pythonConfig{}),
-	}, storeOptions{}),
 }

cmd/users_export.go

@@ -14,16 +14,11 @@ var usersExportCmd = &cobra.Command{
 	Long: `Export all users to a json or yaml file. Please indicate the
 path to the file where you want to write the users.`,
 	Args: jsonYamlArg,
-	RunE: withStore(func(_ *cobra.Command, args []string, st *store) error {
+	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		list, err := st.Users.Gets("")
+		list, err := d.store.Users.Gets("")
-		if err != nil {
+		checkErr(err)
-			return err
-		}
 
 		err = marshal(args[0], list)
-		if err != nil {
+		checkErr(err)
-			return err
+	}, pythonConfig{}),
-		}
-		return nil
-	}, storeOptions{}),
 }

cmd/users_find.go

@@ -1,9 +1,8 @@
 package cmd
 
 import (
-	"github.com/spf13/cobra"
-
 	"github.com/filebrowser/filebrowser/v2/users"
+	"github.com/spf13/cobra"
 )
 
 func init() {
@@ -16,17 +15,17 @@ var usersFindCmd = &cobra.Command{
 	Short: "Find a user by username or id",
 	Long:  `Find a user by username or id. If no flag is set, all users will be printed.`,
 	Args:  cobra.ExactArgs(1),
-	RunE:  findUsers,
+	Run:   findUsers,
 }
 
 var usersLsCmd = &cobra.Command{
 	Use:   "ls",
 	Short: "List all users.",
 	Args:  cobra.NoArgs,
-	RunE:  findUsers,
+	Run:   findUsers,
 }
 
-var findUsers = withStore(func(_ *cobra.Command, args []string, st *store) error {
+var findUsers = python(func(cmd *cobra.Command, args []string, d pythonData) {
 	var (
 		list []*users.User
 		user *users.User
@@ -36,19 +35,16 @@ var findUsers = withStore(func(_ *cobra.Command, args []string, st *store) error
 	if len(args) == 1 {
 		username, id := parseUsernameOrID(args[0])
 		if username != "" {
-			user, err = st.Users.Get("", username)
+			user, err = d.store.Users.Get("", username)
 		} else {
-			user, err = st.Users.Get("", id)
+			user, err = d.store.Users.Get("", id)
 		}
 
 		list = []*users.User{user}
 	} else {
-		list, err = st.Users.Gets("")
+		list, err = d.store.Users.Gets("")
 	}
 
-	if err != nil {
+	checkErr(err)
-		return err
-	}
 	printUsers(list)
-	return nil
+}, pythonConfig{})
-}, storeOptions{})

cmd/users_import.go

@@ -2,13 +2,11 @@ package cmd
 
 import (
 	"errors"
-	"fmt"
 	"os"
 	"strconv"
 
-	"github.com/spf13/cobra"
-
 	"github.com/filebrowser/filebrowser/v2/users"
+	"github.com/spf13/cobra"
 )
 
 func init() {
@@ -25,89 +23,61 @@ file. You can use this command to import new users to your
 installation. For that, just don't place their ID on the files
 list or set it to 0.`,
 	Args: jsonYamlArg,
-	RunE: withStore(func(cmd *cobra.Command, args []string, st *store) error {
+	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		flags := cmd.Flags()
 		fd, err := os.Open(args[0])
-		if err != nil {
+		checkErr(err)
-			return err
-		}
 		defer fd.Close()
 
 		list := []*users.User{}
 		err = unmarshal(args[0], &list)
-		if err != nil {
+		checkErr(err)
-			return err
-		}
 
 		for _, user := range list {
 			err = user.Clean("")
-			if err != nil {
+			checkErr(err)
-				return err
-			}
 		}
 
-		replace, err := flags.GetBool("replace")
+		if mustGetBool(cmd.Flags(), "replace") {
-		if err != nil {
+			oldUsers, err := d.store.Users.Gets("")
-			return err
+			checkErr(err)
-		}
-
-		if replace {
-			oldUsers, userImportErr := st.Users.Gets("")
-			if userImportErr != nil {
-				return userImportErr
-			}
 
 			err = marshal("users.backup.json", list)
-			if err != nil {
+			checkErr(err)
-				return err
-			}
 
 			for _, user := range oldUsers {
-				err = st.Users.Delete(user.ID)
+				err = d.store.Users.Delete(user.ID)
-				if err != nil {
+				checkErr(err)
-					return err
-				}
 			}
 		}
 
-		overwrite, err := flags.GetBool("overwrite")
+		overwrite := mustGetBool(cmd.Flags(), "overwrite")
-		if err != nil {
-			return err
-		}
 
 		for _, user := range list {
-			onDB, err := st.Users.Get("", user.ID)
+			onDB, err := d.store.Users.Get("", user.ID)
 
 			// User exists in DB.
 			if err == nil {
 				if !overwrite {
-					return errors.New("user " + strconv.Itoa(int(user.ID)) + " is already registered")
+					checkErr(errors.New("user " + strconv.Itoa(int(user.ID)) + " is already registred"))
 				}
 
 				// If the usernames mismatch, check if there is another one in the DB
 				// with the new username. If there is, print an error and cancel the
 				// operation
 				if user.Username != onDB.Username {
-					if conflictuous, err := st.Users.Get("", user.Username); err == nil {
+					conflictuous, err := d.store.Users.Get("", user.Username)
-						return usernameConflictError(user.Username, conflictuous.ID, user.ID)
+					if err == nil {
+						checkErr(usernameConflictError(user.Username, conflictuous.ID, user.ID))
 					}
 				}
-			} else {
-				// If it doesn't exist, set the ID to 0 to automatically get a new
-				// one that make sense in this DB.
-				user.ID = 0
 			}
 
-			err = st.Users.Save(user)
+			err = d.store.Users.Save(user)
-			if err != nil {
+			checkErr(err)
-				return err
-			}
 		}
-		return nil
+	}, pythonConfig{}),
-	}, storeOptions{}),
 }
 
-func usernameConflictError(username string, originalID, newID uint) error {
+func usernameConflictError(username string, original, new uint) error {
-	return fmt.Errorf(`can't import user with ID %d and username "%s" because the username is already registered with the user %d`,
+	return errors.New("can't import user with ID " + strconv.Itoa(int(new)) + " and username \"" + username + "\" because the username is already registred with the user " + strconv.Itoa(int(original)))
-		newID, username, originalID)
 }

cmd/users_rm.go

@@ -15,20 +15,17 @@ var usersRmCmd = &cobra.Command{
 	Short: "Delete a user by username or id",
 	Long:  `Delete a user by username or id`,
 	Args:  cobra.ExactArgs(1),
-	RunE: withStore(func(_ *cobra.Command, args []string, st *store) error {
+	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
 		username, id := parseUsernameOrID(args[0])
 		var err error
 
 		if username != "" {
-			err = st.Users.Delete(username)
+			err = d.store.Users.Delete(username)
 		} else {
-			err = st.Users.Delete(id)
+			err = d.store.Users.Delete(id)
 		}
 
-		if err != nil {
+		checkErr(err)
-			return err
-		}
 		fmt.Println("user deleted successfully")
-		return nil
+	}, pythonConfig{}),
-	}, storeOptions{}),
 }

cmd/users_update.go

@@ -1,10 +1,9 @@
 package cmd
 
 import (
-	"github.com/spf13/cobra"
-
 	"github.com/filebrowser/filebrowser/v2/settings"
 	"github.com/filebrowser/filebrowser/v2/users"
+	"github.com/spf13/cobra"
 )
 
 func init() {
@@ -21,91 +20,53 @@ var usersUpdateCmd = &cobra.Command{
 	Long: `Updates an existing user. Set the flags for the
 options you want to change.`,
 	Args: cobra.ExactArgs(1),
-	RunE: withStore(func(cmd *cobra.Command, args []string, st *store) error {
+	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		flags := cmd.Flags()
 		username, id := parseUsernameOrID(args[0])
-		password, err := flags.GetString("password")
+		flags := cmd.Flags()
-		if err != nil {
+		password := mustGetString(flags, "password")
-			return err
+		newUsername := mustGetString(flags, "username")
-		}
-
-		newUsername, err := flags.GetString("username")
-		if err != nil {
-			return err
-		}
-
-		s, err := st.Settings.Get()
-		if err != nil {
-			return err
-		}
 
 		var (
+			err  error
 			user *users.User
 		)
+
 		if id != 0 {
-			user, err = st.Users.Get("", id)
+			user, err = d.store.Users.Get("", id)
 		} else {
-			user, err = st.Users.Get("", username)
+			user, err = d.store.Users.Get("", username)
-		}
-		if err != nil {
-			return err
 		}
 
+		checkErr(err)
+
 		defaults := settings.UserDefaults{
-			Scope:                 user.Scope,
+			Scope:    user.Scope,
-			Locale:                user.Locale,
+			Locale:   user.Locale,
-			ViewMode:              user.ViewMode,
+			ViewMode: user.ViewMode,
-			SingleClick:           user.SingleClick,
+			Perm:     user.Perm,
-			RedirectAfterCopyMove: user.RedirectAfterCopyMove,
+			Sorting:  user.Sorting,
-			Perm:                  user.Perm,
+			Commands: user.Commands,
-			Sorting:               user.Sorting,
-			Commands:              user.Commands,
 		}
-
+		getUserDefaults(flags, &defaults, false)
-		err = getUserDefaults(flags, &defaults, false)
-		if err != nil {
-			return err
-		}
-
 		user.Scope = defaults.Scope
 		user.Locale = defaults.Locale
 		user.ViewMode = defaults.ViewMode
-		user.SingleClick = defaults.SingleClick
-		user.RedirectAfterCopyMove = defaults.RedirectAfterCopyMove
 		user.Perm = defaults.Perm
 		user.Commands = defaults.Commands
 		user.Sorting = defaults.Sorting
-		user.LockPassword, err = flags.GetBool("lockPassword")
+		user.LockPassword = mustGetBool(flags, "lockPassword")
-		if err != nil {
-			return err
-		}
-
-		user.DateFormat, err = flags.GetBool("dateFormat")
-		if err != nil {
-			return err
-		}
-
-		user.HideDotfiles, err = flags.GetBool("hideDotfiles")
-		if err != nil {
-			return err
-		}
 
 		if newUsername != "" {
 			user.Username = newUsername
 		}
 
 		if password != "" {
-			user.Password, err = users.ValidateAndHashPwd(password, s.MinimumPasswordLength)
+			user.Password, err = users.HashPwd(password)
-			if err != nil {
+			checkErr(err)
-				return err
-			}
 		}
 
-		err = st.Users.Update(user)
+		err = d.store.Users.Update(user)
-		if err != nil {
+		checkErr(err)
-			return err
-		}
 		printUsers([]*users.User{user})
-		return nil
+	}, pythonConfig{}),
-	}, storeOptions{}),
 }

cmd/utils.go

@@ -4,206 +4,106 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"io/fs"
 	"log"
 	"os"
 	"path/filepath"
-	"strconv"
-	"strings"
-
-	"github.com/asdine/storm/v3"
-	homedir "github.com/mitchellh/go-homedir"
-	"github.com/samber/lo"
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-	"github.com/spf13/viper"
-	yaml "gopkg.in/yaml.v3"
 
+	"github.com/asdine/storm"
 	"github.com/filebrowser/filebrowser/v2/settings"
 	"github.com/filebrowser/filebrowser/v2/storage"
 	"github.com/filebrowser/filebrowser/v2/storage/bolt"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+	yaml "gopkg.in/yaml.v2"
 )
 
-const databasePermissions = 0640
+func checkErr(err error) {
-
-func getAndParseFileMode(flags *pflag.FlagSet, name string) (fs.FileMode, error) {
-	mode, err := flags.GetString(name)
 	if err != nil {
-		return 0, err
+		log.Fatal(err)
 	}
+}
 
-	b, err := strconv.ParseUint(mode, 0, 32)
+func mustGetString(flags *pflag.FlagSet, flag string) string {
-	if err != nil {
+	s, err := flags.GetString(flag)
-		return 0, err
+	checkErr(err)
-	}
+	return s
+}
 
-	return fs.FileMode(b), nil
+func mustGetBool(flags *pflag.FlagSet, flag string) bool {
+	b, err := flags.GetBool(flag)
+	checkErr(err)
+	return b
+}
+
+func mustGetUint(flags *pflag.FlagSet, flag string) uint {
+	b, err := flags.GetUint(flag)
+	checkErr(err)
+	return b
 }
 
 func generateKey() []byte {
 	k, err := settings.GenerateKey()
-	if err != nil {
+	checkErr(err)
-		panic(err)
-	}
 	return k
 }
 
+type cobraFunc func(cmd *cobra.Command, args []string)
+type pythonFunc func(cmd *cobra.Command, args []string, data pythonData)
+
+type pythonConfig struct {
+	noDB      bool
+	allowNoDB bool
+}
+
+type pythonData struct {
+	hadDB bool
+	store *storage.Storage
+}
+
 func dbExists(path string) (bool, error) {
 	stat, err := os.Stat(path)
-	if err == nil {
-		return stat.Size() != 0, nil
-	}
 
 	if os.IsNotExist(err) {
-		d := filepath.Dir(path)
+		return false, nil
-		_, err = os.Stat(d)
+	} else if err != nil {
-		if os.IsNotExist(err) {
+		return false, err
-			if err := os.MkdirAll(d, 0700); err != nil {
-				return false, err
-			}
-			return false, nil
-		}
 	}
 
-	return false, err
+	if stat.Size() == 0 {
-}
+		return false, nil
-
-// Generate the replacements for all environment variables. This allows to
-// use FB_BRANDING_DISABLE_EXTERNAL environment variables, even when the
-// option name is branding.disableExternal.
-func generateEnvKeyReplacements(cmd *cobra.Command) []string {
-	replacements := []string{}
-
-	cmd.Flags().VisitAll(func(f *pflag.Flag) {
-		oldName := strings.ToUpper(f.Name)
-		newName := strings.ToUpper(lo.SnakeCase(f.Name))
-		replacements = append(replacements, oldName, newName)
-	})
-
-	return replacements
-}
-
-func initViper(cmd *cobra.Command) (*viper.Viper, error) {
-	v := viper.New()
-
-	// Get config file from flag
-	cfgFile, err := cmd.Flags().GetString("config")
-	if err != nil {
-		return nil, err
 	}
 
-	// Configuration file
+	return true, nil
-	if cfgFile == "" {
-		home, err := homedir.Dir()
-		if err != nil {
-			return nil, err
-		}
-		v.AddConfigPath(".")
-		v.AddConfigPath(home)
-		v.AddConfigPath("/etc/filebrowser/")
-		v.SetConfigName(".filebrowser")
-	} else {
-		v.SetConfigFile(cfgFile)
-	}
-
-	// Environment variables
-	v.SetEnvPrefix("FB")
-	v.AutomaticEnv()
-	v.SetEnvKeyReplacer(strings.NewReplacer(generateEnvKeyReplacements(cmd)...))
-
-	// Bind the flags
-	err = v.BindPFlags(cmd.Flags())
-	if err != nil {
-		return nil, err
-	}
-
-	// Read in configuration
-	if err := v.ReadInConfig(); err != nil {
-		if errors.Is(err, viper.ConfigParseError{}) {
-			return nil, err
-		}
-
-		log.Println("No config file used")
-	} else {
-		log.Printf("Using config file: %s", v.ConfigFileUsed())
-	}
-
-	// Return Viper
-	return v, nil
 }
 
-type store struct {
+func python(fn pythonFunc, cfg pythonConfig) cobraFunc {
-	*storage.Storage
+	return func(cmd *cobra.Command, args []string) {
-	databaseExisted bool
+		data := pythonData{hadDB: true}
-}
-
-type storeOptions struct {
-	expectsNoDatabase bool
-	allowsNoDatabase  bool
-}
-
-type cobraFunc func(cmd *cobra.Command, args []string) error
-
-// withViperAndStore initializes Viper and the storage.Store and passes them to the callback function.
-// This function should only be used by [withStore] and the root command. No other command should call
-// this function directly.
-func withViperAndStore(fn func(cmd *cobra.Command, args []string, v *viper.Viper, store *store) error, options storeOptions) cobraFunc {
-	return func(cmd *cobra.Command, args []string) error {
-		v, err := initViper(cmd)
-		if err != nil {
-			return err
-		}
-
-		path, err := filepath.Abs(v.GetString("database"))
-		if err != nil {
-			return err
-		}
 
+		path := getParam(cmd.Flags(), "database")
 		exists, err := dbExists(path)
-		switch {
+
-		case err != nil:
+		if err != nil {
-			return err
+			panic(err)
-		case exists && options.expectsNoDatabase:
+		} else if exists && cfg.noDB {
 			log.Fatal(path + " already exists")
-		case !exists && !options.expectsNoDatabase && !options.allowsNoDatabase:
+		} else if !exists && !cfg.noDB && !cfg.allowNoDB {
 			log.Fatal(path + " does not exist. Please run 'filebrowser config init' first.")
-		case !exists && !options.expectsNoDatabase:
-			log.Println("WARNING: filebrowser.db can't be found. Initialing in " + strings.TrimSuffix(path, "filebrowser.db"))
 		}
 
-		log.Println("Using database: " + path)
+		data.hadDB = exists
-
+		db, err := storm.Open(path)
-		db, err := storm.Open(path, storm.BoltOptions(databasePermissions, nil))
+		checkErr(err)
-		if err != nil {
-			return err
-		}
 		defer db.Close()
-
+		data.store, err = bolt.NewStorage(db)
-		storage, err := bolt.NewStorage(db)
+		checkErr(err)
-		if err != nil {
+		fn(cmd, args, data)
-			return err
-		}
-
-		store := &store{
-			Storage:         storage,
-			databaseExisted: exists,
-		}
-
-		return fn(cmd, args, v, store)
 	}
 }
 
-func withStore(fn func(cmd *cobra.Command, args []string, store *store) error, options storeOptions) cobraFunc {
-	return withViperAndStore(func(cmd *cobra.Command, args []string, _ *viper.Viper, store *store) error {
-		return fn(cmd, args, store)
-	}, options)
-}
-
 func marshal(filename string, data interface{}) error {
 	fd, err := os.Create(filename)
-	if err != nil {
+	checkErr(err)
-		return err
-	}
 	defer fd.Close()
 
 	switch ext := filepath.Ext(filename); ext {
@@ -221,9 +121,7 @@ func marshal(filename string, data interface{}) error {
 
 func unmarshal(filename string, data interface{}) error {
 	fd, err := os.Open(filename)
-	if err != nil {
+	checkErr(err)
-		return err
-	}
 	defer fd.Close()
 
 	switch ext := filepath.Ext(filename); ext {
@@ -275,15 +173,3 @@ func cleanUpMapValue(v interface{}) interface{} {
 		return v
 	}
 }
-
-// convertCmdStrToCmdArray checks if cmd string is blank (whitespace included)
-// then returns empty string array, else returns the split word array of cmd.
-// This is to ensure the result will never be []string{""}
-func convertCmdStrToCmdArray(cmd string) []string {
-	var cmdArray []string
-	trimmedCmdStr := strings.TrimSpace(cmd)
-	if trimmedCmdStr != "" {
-		cmdArray = strings.Split(trimmedCmdStr, " ")
-	}
-	return cmdArray
-}

cmd/version.go

@@ -1,21 +1,32 @@
 package cmd
 
 import (
-	"fmt"
+	"text/template"
 
 	"github.com/spf13/cobra"
-
-	"github.com/filebrowser/filebrowser/v2/version"
 )
 
 func init() {
 	rootCmd.AddCommand(versionCmd)
+	cmdsCmd.AddCommand(versionCmd)
+	configCmd.AddCommand(versionCmd)
+	hashCmd.AddCommand(versionCmd)
+	upgradeCmd.AddCommand(versionCmd)
+	rulesCmd.AddCommand(versionCmd)
+	usersCmd.AddCommand(versionCmd)
 }
 
 var versionCmd = &cobra.Command{
 	Use:   "version",
-	Short: "Print the version number",
+	Short: "Print the version number of File Browser",
-	Run: func(_ *cobra.Command, _ []string) {
+	Long:  `All software has versions. This is File Browser's`,
-		fmt.Println("File Browser v" + version.Version + "/" + version.CommitSHA)
+	Run: func(cmd *cobra.Command, args []string) {
+		// https://github.com/spf13/cobra/issues/724
+		t := template.New("version")
+		template.Must(t.Parse(rootCmd.VersionTemplate()))
+		err := t.Execute(rootCmd.OutOrStdout(), rootCmd)
+		if err != nil {
+			rootCmd.Println(err)
+		}
 	},
 }

diskcache/cache.go

@@ -1,11 +0,0 @@
-package diskcache
-
-import (
-	"context"
-)
-
-type Interface interface {
-	Store(ctx context.Context, key string, value []byte) error
-	Load(ctx context.Context, key string) (value []byte, exist bool, err error)
-	Delete(ctx context.Context, key string) error
-}

diskcache/file_cache.go

@@ -1,110 +0,0 @@
-package diskcache
-
-import (
-	"context"
-	"crypto/sha1"
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"sync"
-
-	"github.com/spf13/afero"
-)
-
-type FileCache struct {
-	fs afero.Fs
-
-	// granular locks
-	scopedLocks struct {
-		sync.Mutex
-		sync.Once
-		locks map[string]sync.Locker
-	}
-}
-
-func New(fs afero.Fs, root string) *FileCache {
-	return &FileCache{
-		fs: afero.NewBasePathFs(fs, root),
-	}
-}
-
-func (f *FileCache) Store(_ context.Context, key string, value []byte) error {
-	mu := f.getScopedLocks(key)
-	mu.Lock()
-	defer mu.Unlock()
-
-	fileName := f.getFileName(key)
-	if err := f.fs.MkdirAll(filepath.Dir(fileName), 0700); err != nil {
-		return err
-	}
-
-	if err := afero.WriteFile(f.fs, fileName, value, 0700); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (f *FileCache) Load(_ context.Context, key string) (value []byte, exist bool, err error) {
-	r, ok, err := f.open(key)
-	if err != nil || !ok {
-		return nil, ok, err
-	}
-	defer r.Close()
-
-	value, err = io.ReadAll(r)
-	if err != nil {
-		return nil, false, err
-	}
-	return value, true, nil
-}
-
-func (f *FileCache) Delete(_ context.Context, key string) error {
-	mu := f.getScopedLocks(key)
-	mu.Lock()
-	defer mu.Unlock()
-
-	fileName := f.getFileName(key)
-	if err := f.fs.Remove(fileName); err != nil && !errors.Is(err, os.ErrNotExist) {
-		return err
-	}
-	return nil
-}
-
-func (f *FileCache) open(key string) (afero.File, bool, error) {
-	fileName := f.getFileName(key)
-	file, err := f.fs.Open(fileName)
-	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			return nil, false, nil
-		}
-		return nil, false, err
-	}
-
-	return file, true, nil
-}
-
-// getScopedLocks pull lock from the map if found or create a new one
-func (f *FileCache) getScopedLocks(key string) (lock sync.Locker) {
-	f.scopedLocks.Do(func() { f.scopedLocks.locks = map[string]sync.Locker{} })
-
-	f.scopedLocks.Lock()
-	lock, ok := f.scopedLocks.locks[key]
-	if !ok {
-		lock = &sync.Mutex{}
-		f.scopedLocks.locks[key] = lock
-	}
-	f.scopedLocks.Unlock()
-
-	return lock
-}
-
-func (f *FileCache) getFileName(key string) string {
-	hasher := sha1.New()
-	_, _ = hasher.Write([]byte(key))
-	hash := hex.EncodeToString(hasher.Sum(nil))
-	return fmt.Sprintf("%s/%s/%s", hash[:1], hash[1:3], hash)
-}

diskcache/file_cache_test.go

@@ -1,55 +0,0 @@
-package diskcache
-
-import (
-	"context"
-	"path/filepath"
-	"testing"
-
-	"github.com/spf13/afero"
-	"github.com/stretchr/testify/require"
-)
-
-func TestFileCache(t *testing.T) {
-	ctx := context.Background()
-	const (
-		key            = "key"
-		value          = "some text"
-		newValue       = "new text"
-		cacheRoot      = "/cache"
-		cachedFilePath = "a/62/a62f2225bf70bfaccbc7f1ef2a397836717377de"
-	)
-
-	fs := afero.NewMemMapFs()
-	cache := New(fs, "/cache")
-
-	// store new key
-	err := cache.Store(ctx, key, []byte(value))
-	require.NoError(t, err)
-	checkValue(ctx, t, fs, filepath.Join(cacheRoot, cachedFilePath), cache, key, value)
-
-	// update existing key
-	err = cache.Store(ctx, key, []byte(newValue))
-	require.NoError(t, err)
-	checkValue(ctx, t, fs, filepath.Join(cacheRoot, cachedFilePath), cache, key, newValue)
-
-	// delete key
-	err = cache.Delete(ctx, key)
-	require.NoError(t, err)
-	exists, err := afero.Exists(fs, filepath.Join(cacheRoot, cachedFilePath))
-	require.NoError(t, err)
-	require.False(t, exists)
-}
-
-func checkValue(ctx context.Context, t *testing.T, fs afero.Fs, fileFullPath string, cache *FileCache, key, wantValue string) {
-	t.Helper()
-	// check actual file content
-	b, err := afero.ReadFile(fs, fileFullPath)
-	require.NoError(t, err)
-	require.Equal(t, wantValue, string(b))
-
-	// check cache content
-	b, ok, err := cache.Load(ctx, key)
-	require.NoError(t, err)
-	require.True(t, ok)
-	require.Equal(t, wantValue, string(b))
-}

diskcache/noop_cache.go

@@ -1,24 +0,0 @@
-package diskcache
-
-import (
-	"context"
-)
-
-type NoOp struct {
-}
-
-func NewNoOp() *NoOp {
-	return &NoOp{}
-}
-
-func (n *NoOp) Store(_ context.Context, _ string, _ []byte) error {
-	return nil
-}
-
-func (n *NoOp) Load(_ context.Context, _ string) (value []byte, exist bool, err error) {
-	return nil, false, nil
-}
-
-func (n *NoOp) Delete(_ context.Context, _ string) error {
-	return nil
-}

docker/alpine/healthcheck.sh

@@ -1,9 +0,0 @@
-#!/bin/sh
-
-set -e
-
-PORT=${FB_PORT:-$(cat /config/settings.json | sh /JSON.sh | grep '\["port"\]' | awk '{print $2}')}
-ADDRESS=${FB_ADDRESS:-$(cat /config/settings.json | sh /JSON.sh | grep '\["address"\]' | awk '{print $2}' | sed 's/"//g')}
-ADDRESS=${ADDRESS:-localhost}
-
-wget -q --spider http://$ADDRESS:$PORT/health || exit 1

docker/alpine/init.sh

@@ -1,35 +0,0 @@
-#!/bin/sh
-
-set -e
-
-# Ensure configuration exists
-if [ ! -f "/config/settings.json" ]; then
-  cp -a /defaults/settings.json /config/settings.json
-fi
-
-# Extract config file path from arguments
-config_file=""
-next_is_config=0
-for arg in "$@"; do
-  if [ "$next_is_config" -eq 1 ]; then
-    config_file="$arg"
-    break
-  fi
-  case "$arg" in
-    -c|--config)
-      next_is_config=1
-      ;;
-    -c=*|--config=*)
-      config_file="${arg#*=}"
-      break
-      ;;
-  esac
-done
-
-# If no config argument is provided, set the default and add it to the args                                                                 
-if [ -z "$config_file" ]; then 
-  config_file="/config/settings.json"                                                                                                                                                                                                 
-  set -- --config=/config/settings.json "$@"                                                                                                       
-fi                                                                                                                                                                                                                                                                                                                                                             
-
-exec filebrowser "$@"

docker/common/healthcheck.sh

@@ -1,9 +0,0 @@
-#!/bin/sh
-
-set -e
-
-PORT=${FB_PORT:-$(jq -r .port /config/settings.json)}
-ADDRESS=${FB_ADDRESS:-$(jq -r .address /config/settings.json)}
-ADDRESS=${ADDRESS:-localhost}
-
-wget -q --spider http://$ADDRESS:$PORT/health || exit 1

docker/s6/custom-cont-init.d/20-config

@@ -1,12 +0,0 @@
-#!/usr/bin/with-contenv bash
-
-# Ensure configuration exists
-if [ ! -f "/config/settings.json" ]; then
-  cp -a /defaults/settings.json /config/settings.json
-fi
-
-# permissions
-chown abc:abc \
-	/config/settings.json \
-	/database \
-	/srv

docker/s6/etc/services.d/filebrowser/run

@@ -1,3 +0,0 @@
-#!/usr/bin/with-contenv bash
-
-exec s6-setuidgid abc filebrowser -c /config/settings.json;

errors/errors.go

@@ -1,34 +1,17 @@
-package fberrors
+package errors
 
-import (
+import "errors"
-	"errors"
-	"fmt"
-)
 
 var (
-	ErrEmptyKey                 = errors.New("empty key")
+	ErrEmptyKey          = errors.New("empty key")
-	ErrExist                    = errors.New("the resource already exists")
+	ErrExist             = errors.New("the resource already exists")
-	ErrNotExist                 = errors.New("the resource does not exist")
+	ErrNotExist          = errors.New("the resource does not exist")
-	ErrEmptyPassword            = errors.New("password is empty")
+	ErrEmptyPassword     = errors.New("password is empty")
-	ErrEasyPassword             = errors.New("password is too easy")
+	ErrEmptyUsername     = errors.New("username is empty")
-	ErrEmptyUsername            = errors.New("username is empty")
+	ErrEmptyRequest      = errors.New("empty request")
-	ErrEmptyRequest             = errors.New("empty request")
+	ErrScopeIsRelative   = errors.New("scope is a relative path")
-	ErrScopeIsRelative          = errors.New("scope is a relative path")
+	ErrInvalidDataType   = errors.New("invalid data type")
-	ErrInvalidDataType          = errors.New("invalid data type")
+	ErrIsDirectory       = errors.New("file is directory")
-	ErrIsDirectory              = errors.New("file is directory")
+	ErrInvalidOption     = errors.New("invalid option")
-	ErrInvalidOption            = errors.New("invalid option")
+	ErrInvalidAuthMethod = errors.New("invalid auth method")
-	ErrInvalidAuthMethod        = errors.New("invalid auth method")
-	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")
-	ErrCurrentPasswordIncorrect = errors.New("the current password is incorrect")
 )
-
-type ErrShortPassword struct {
-	MinimumLength uint
-}
-
-func (e ErrShortPassword) Error() string {
-	return fmt.Sprintf("password is too short, minimum length is %d", e.MinimumLength)
-}

files/file.go

@@ -6,151 +6,62 @@ import (
 	"crypto/sha256"
 	"crypto/sha512"
 	"encoding/hex"
-	"errors"
 	"hash"
-	"image"
 	"io"
-	"io/fs"
 	"log"
 	"mime"
 	"net/http"
 	"os"
 	"path"
 	"path/filepath"
-	"regexp"
 	"strings"
 	"time"
 
-	"github.com/spf13/afero"
+	"github.com/filebrowser/filebrowser/v2/errors"
-
-	fberrors "github.com/filebrowser/filebrowser/v2/errors"
 	"github.com/filebrowser/filebrowser/v2/rules"
-)
+	"github.com/spf13/afero"
-
-var (
-	reSubDirs = regexp.MustCompile("(?i)^sub(s|titles)$")
-	reSubExts = regexp.MustCompile("(?i)(.vtt|.srt|.ass|.ssa)$")
 )
 
 // FileInfo describes a file.
 type FileInfo struct {
 	*Listing
-	Fs         afero.Fs          `json:"-"`
+	Fs        afero.Fs          `json:"-"`
-	Path       string            `json:"path"`
+	Path      string            `json:"path"`
-	Name       string            `json:"name"`
+	Name      string            `json:"name"`
-	Size       int64             `json:"size"`
+	Size      int64             `json:"size"`
-	Extension  string            `json:"extension"`
+	Extension string            `json:"extension"`
-	ModTime    time.Time         `json:"modified"`
+	ModTime   time.Time         `json:"modified"`
-	Mode       os.FileMode       `json:"mode"`
+	Mode      os.FileMode       `json:"mode"`
-	IsDir      bool              `json:"isDir"`
+	IsDir     bool              `json:"isDir"`
-	IsSymlink  bool              `json:"isSymlink"`
+	Type      string            `json:"type"`
-	Type       string            `json:"type"`
+	Subtitles []string          `json:"subtitles,omitempty"`
-	Subtitles  []string          `json:"subtitles,omitempty"`
+	Content   string            `json:"content,omitempty"`
-	Content    string            `json:"content,omitempty"`
+	Checksums map[string]string `json:"checksums,omitempty"`
-	Checksums  map[string]string `json:"checksums,omitempty"`
-	Token      string            `json:"token,omitempty"`
-	currentDir []os.FileInfo     `json:"-"`
-	Resolution *ImageResolution  `json:"resolution,omitempty"`
 }
 
 // FileOptions are the options when getting a file info.
 type FileOptions struct {
-	Fs         afero.Fs
+	Fs      afero.Fs
-	Path       string
+	Path    string
-	Modify     bool
+	Modify  bool
-	Expand     bool
+	Expand  bool
-	ReadHeader bool
+	Checker rules.Checker
-	CalcImgRes bool
-	Token      string
-	Checker    rules.Checker
-	Content    bool
-}
-
-type ImageResolution struct {
-	Width  int `json:"width"`
-	Height int `json:"height"`
 }
 
 // NewFileInfo creates a File object from a path and a given user. This File
 // object will be automatically filled depending on if it is a directory
 // or a file. If it's a video file, it will also detect any subtitles.
-func NewFileInfo(opts *FileOptions) (*FileInfo, error) {
+func NewFileInfo(opts FileOptions) (*FileInfo, error) {
 	if !opts.Checker.Check(opts.Path) {
 		return nil, os.ErrPermission
 	}
 
-	file, err := stat(opts)
-	if err != nil {
-		return nil, err
-	}
-
-	// Do not expose the name of root directory.
-	if file.Path == "/" {
-		file.Name = ""
-	}
-
-	if opts.Expand {
-		if file.IsDir {
-			if err := file.readListing(opts.Checker, opts.ReadHeader, opts.CalcImgRes); err != nil {
-				return nil, err
-			}
-			return file, nil
-		}
-
-		err = file.detectType(opts.Modify, opts.Content, true, opts.CalcImgRes)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return file, err
-}
-
-func stat(opts *FileOptions) (*FileInfo, error) {
-	var file *FileInfo
-
-	if lstaterFs, ok := opts.Fs.(afero.Lstater); ok {
-		info, _, err := lstaterFs.LstatIfPossible(opts.Path)
-		if err != nil {
-			return nil, err
-		}
-		file = &FileInfo{
-			Fs:        opts.Fs,
-			Path:      opts.Path,
-			Name:      info.Name(),
-			ModTime:   info.ModTime(),
-			Mode:      info.Mode(),
-			IsDir:     info.IsDir(),
-			IsSymlink: IsSymlink(info.Mode()),
-			Size:      info.Size(),
-			Extension: filepath.Ext(info.Name()),
-			Token:     opts.Token,
-		}
-	}
-
-	// regular file
-	if file != nil && !file.IsSymlink {
-		return file, nil
-	}
-
-	// fs doesn't support afero.Lstater interface or the file is a symlink
 	info, err := opts.Fs.Stat(opts.Path)
 	if err != nil {
-		// can't follow symlink
-		if file != nil && file.IsSymlink {
-			return file, nil
-		}
 		return nil, err
 	}
 
-	// set correct file size in case of symlink
+	file := &FileInfo{
-	if file != nil && file.IsSymlink {
-		file.Size = info.Size()
-		file.IsDir = info.IsDir()
-		return file, nil
-	}
-
-	file = &FileInfo{
 		Fs:        opts.Fs,
 		Path:      opts.Path,
 		Name:      info.Name(),
@@ -159,17 +70,27 @@ func stat(opts *FileOptions) (*FileInfo, error) {
 		IsDir:     info.IsDir(),
 		Size:      info.Size(),
 		Extension: filepath.Ext(info.Name()),
-		Token:     opts.Token,
 	}
 
-	return file, nil
+	if opts.Expand {
+		if file.IsDir {
+			return file, file.readListing(opts.Checker)
+		}
+
+		err = file.detectType(opts.Modify, true)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return file, err
 }
 
 // Checksum checksums a given File for a given User, using a specific
 // algorithm. The checksums data is saved on File object.
 func (i *FileInfo) Checksum(algo string) error {
 	if i.IsDir {
-		return fberrors.ErrIsDirectory
+		return errors.ErrIsDirectory
 	}
 
 	if i.Checksums == nil {
@@ -194,7 +115,7 @@ func (i *FileInfo) Checksum(algo string) error {
 	case "sha512":
 		h = sha512.New()
 	default:
-		return fberrors.ErrInvalidOption
+		return errors.ErrInvalidOption
 	}
 
 	_, err = io.Copy(h, reader)
@@ -206,38 +127,30 @@ func (i *FileInfo) Checksum(algo string) error {
 	return nil
 }
 
-func (i *FileInfo) RealPath() string {
+func (i *FileInfo) detectType(modify, saveContent bool) error {
-	if realPathFs, ok := i.Fs.(interface {
-		RealPath(name string) (fPath string, err error)
-	}); ok {
-		realPath, err := realPathFs.RealPath(i.Path)
-		if err == nil {
-			return realPath
-		}
-	}
-
-	return i.Path
-}
-
-func (i *FileInfo) detectType(modify, saveContent, readHeader bool, calcImgRes bool) error {
-	if IsNamedPipe(i.Mode) {
-		i.Type = "blob"
-		return nil
-	}
 	// failing to detect the type should not return error.
 	// imagine the situation where a file in a dir with thousands
 	// of files couldn't be opened: we'd have immediately
 	// a 500 even though it doesn't matter. So we just log it.
+	reader, err := i.Fs.Open(i.Path)
+	if err != nil {
+		log.Print(err)
+		i.Type = "blob"
+		return nil
+	}
+	defer reader.Close()
+
+	buffer := make([]byte, 512)
+	n, err := reader.Read(buffer)
+	if err != nil && err != io.EOF {
+		log.Print(err)
+		i.Type = "blob"
+		return nil
+	}
 
 	mimetype := mime.TypeByExtension(i.Extension)
-
+	if mimetype == "" {
-	var buffer []byte
+		mimetype = http.DetectContentType(buffer[:n])
-	if readHeader {
-		buffer = i.readFirstBytes()
-
-		if mimetype == "" {
-			mimetype = http.DetectContentType(buffer)
-		}
 	}
 
 	switch {
@@ -250,19 +163,11 @@ func (i *FileInfo) detectType(modify, saveContent, readHeader bool, calcImgRes b
 		return nil
 	case strings.HasPrefix(mimetype, "image"):
 		i.Type = "image"
-		if calcImgRes {
-			resolution, err := calculateImageResolution(i.Fs, i.Path)
-			if err != nil {
-				log.Printf("Error calculating image resolution: %v", err)
-			} else {
-				i.Resolution = resolution
-			}
-		}
 		return nil
-	case strings.HasSuffix(mimetype, "pdf"):
+	case isBinary(string(buffer[:n])) || i.Size > 10*1024*1024: // 10 MB
-		i.Type = "pdf"
+		i.Type = "blob"
 		return nil
-	case (strings.HasPrefix(mimetype, "text") || !isBinary(buffer)) && i.Size <= 10*1024*1024: // 10 MB
+	default:
 		i.Type = "text"
 
 		if !modify {
@@ -278,56 +183,11 @@ func (i *FileInfo) detectType(modify, saveContent, readHeader bool, calcImgRes b
 
 			i.Content = string(content)
 		}
-		return nil
-	default:
-		i.Type = "blob"
 	}
 
 	return nil
 }
 
-func calculateImageResolution(fSys afero.Fs, filePath string) (*ImageResolution, error) {
-	file, err := fSys.Open(filePath)
-	if err != nil {
-		return nil, err
-	}
-	defer func() {
-		if cErr := file.Close(); cErr != nil {
-			log.Printf("Failed to close file: %v", cErr)
-		}
-	}()
-
-	config, _, err := image.DecodeConfig(file)
-	if err != nil {
-		return nil, err
-	}
-
-	return &ImageResolution{
-		Width:  config.Width,
-		Height: config.Height,
-	}, nil
-}
-
-func (i *FileInfo) readFirstBytes() []byte {
-	reader, err := i.Fs.Open(i.Path)
-	if err != nil {
-		log.Print(err)
-		i.Type = "blob"
-		return nil
-	}
-	defer reader.Close()
-
-	buffer := make([]byte, 512)
-	n, err := reader.Read(buffer)
-	if err != nil && !errors.Is(err, io.EOF) {
-		log.Print(err)
-		i.Type = "blob"
-		return nil
-	}
-
-	return buffer[:n]
-}
-
 func (i *FileInfo) detectSubtitles() {
 	if i.Type != "video" {
 		return
@@ -336,61 +196,15 @@ func (i *FileInfo) detectSubtitles() {
 	i.Subtitles = []string{}
 	ext := filepath.Ext(i.Path)
 
-	// detect multiple languages. Base*.vtt
+	// TODO: detect multiple languages. Base.Lang.vtt
-	parentDir := strings.TrimRight(i.Path, i.Name)
-	var dir []os.FileInfo
-	if len(i.currentDir) > 0 {
-		dir = i.currentDir
-	} else {
-		var err error
-		dir, err = afero.ReadDir(i.Fs, parentDir)
-		if err != nil {
-			return
-		}
-	}
 
-	base := strings.TrimSuffix(i.Name, ext)
+	path := strings.TrimSuffix(i.Path, ext) + ".vtt"
-	for _, f := range dir {
+	if _, err := i.Fs.Stat(path); err == nil {
-		// load all supported subtitles from subs directories
+		i.Subtitles = append(i.Subtitles, path)
-		// should cover all instances of subtitle distributions
-		// like tv-shows with multiple episodes in single dir
-		if f.IsDir() && reSubDirs.MatchString(f.Name()) {
-			subsDir := path.Join(parentDir, f.Name())
-			i.loadSubtitles(subsDir, base, true)
-		} else if isSubtitleMatch(f, base) {
-			i.addSubtitle(path.Join(parentDir, f.Name()))
-		}
 	}
 }
 
-func (i *FileInfo) loadSubtitles(subsPath, baseName string, recursive bool) {
+func (i *FileInfo) readListing(checker rules.Checker) error {
-	dir, err := afero.ReadDir(i.Fs, subsPath)
-	if err == nil {
-		for _, f := range dir {
-			if isSubtitleMatch(f, "") {
-				i.addSubtitle(path.Join(subsPath, f.Name()))
-			} else if f.IsDir() && recursive && strings.HasPrefix(f.Name(), baseName) {
-				subsDir := path.Join(subsPath, f.Name())
-				i.loadSubtitles(subsDir, baseName, false)
-			}
-		}
-	}
-}
-
-func IsSupportedSubtitle(fileName string) bool {
-	return reSubExts.MatchString(fileName)
-}
-
-func isSubtitleMatch(f fs.FileInfo, baseName string) bool {
-	return !f.IsDir() && strings.HasPrefix(f.Name(), baseName) &&
-		IsSupportedSubtitle(f.Name())
-}
-
-func (i *FileInfo) addSubtitle(fPath string) {
-	i.Subtitles = append(i.Subtitles, fPath)
-}
-
-func (i *FileInfo) readListing(checker rules.Checker, readHeader bool, calcImgRes bool) error {
 	afs := &afero.Afero{Fs: i.Fs}
 	dir, err := afs.ReadDir(i.Path)
 	if err != nil {
@@ -405,45 +219,30 @@ func (i *FileInfo) readListing(checker rules.Checker, readHeader bool, calcImgRe
 
 	for _, f := range dir {
 		name := f.Name()
-		fPath := path.Join(i.Path, name)
+		path := path.Join(i.Path, name)
 
-		if !checker.Check(fPath) {
+		if !checker.Check(path) {
 			continue
 		}
 
-		isSymlink, isInvalidLink := false, false
+		if strings.HasPrefix(f.Mode().String(), "L") {
-		if IsSymlink(f.Mode()) {
-			isSymlink = true
 			// It's a symbolic link. We try to follow it. If it doesn't work,
-			// we stay with the link information instead of the target's.
+			// we stay with the link information instead if the target's.
-			info, err := i.Fs.Stat(fPath)
+			info, err := i.Fs.Stat(path)
 			if err == nil {
 				f = info
-			} else {
-				isInvalidLink = true
 			}
 		}
 
 		file := &FileInfo{
-			Fs:         i.Fs,
+			Fs:        i.Fs,
-			Name:       name,
+			Name:      name,
-			Size:       f.Size(),
+			Size:      f.Size(),
-			ModTime:    f.ModTime(),
+			ModTime:   f.ModTime(),
-			Mode:       f.Mode(),
+			Mode:      f.Mode(),
-			IsDir:      f.IsDir(),
+			IsDir:     f.IsDir(),
-			IsSymlink:  isSymlink,
+			Extension: filepath.Ext(name),
-			Extension:  filepath.Ext(name),
+			Path:      path,
-			Path:       fPath,
-			currentDir: dir,
-		}
-
-		if !file.IsDir && strings.HasPrefix(mime.TypeByExtension(file.Extension), "image/") && calcImgRes {
-			resolution, err := calculateImageResolution(file.Fs, file.Path)
-			if err != nil {
-				log.Printf("Error calculating resolution for image %s: %v", file.Path, err)
-			} else {
-				file.Resolution = resolution
-			}
 		}
 
 		if file.IsDir {
@@ -451,13 +250,9 @@ func (i *FileInfo) readListing(checker rules.Checker, readHeader bool, calcImgRe
 		} else {
 			listing.NumFiles++
 
-			if isInvalidLink {
+			err := file.detectType(true, false)
-				file.Type = "invalid_link"
+			if err != nil {
-			} else {
+				return err
-				err := file.detectType(true, false, readHeader, calcImgRes)
-				if err != nil {
-					return err
-				}
 			}
 		}
 

files/listing.go

@@ -2,7 +2,6 @@ package files
 
 import (
 	"sort"
-	"strings"
 
 	"github.com/maruel/natural"
 )
@@ -62,14 +61,14 @@ func (l byName) Swap(i, j int) {
 // Treat upper and lower case equally
 func (l byName) Less(i, j int) bool {
 	if l.Items[i].IsDir && !l.Items[j].IsDir {
-		return l.Sorting.Asc
+		return true
 	}
 
 	if !l.Items[i].IsDir && l.Items[j].IsDir {
-		return !l.Sorting.Asc
+		return false
 	}
 
-	return natural.Less(strings.ToLower(l.Items[j].Name), strings.ToLower(l.Items[i].Name))
+	return natural.Less(l.Items[i].Name, l.Items[j].Name)
 }
 
 // By Size

files/mime.go

@@ -1,608 +0,0 @@
-package files
-
-// This file contains code primarily sourced from::
-// github.com/kataras/iris
-
-import (
-	"mime"
-)
-
-const (
-	// ContentBinaryHeaderValue header value for binary data.
-	ContentBinaryHeaderValue = "application/octet-stream"
-	// ContentWebassemblyHeaderValue header value for web assembly files.
-	ContentWebassemblyHeaderValue = "application/wasm"
-	// ContentHTMLHeaderValue is the  string of text/html response header's content type value.
-	ContentHTMLHeaderValue = "text/html"
-	// ContentJSONHeaderValue header value for JSON data.
-	ContentJSONHeaderValue = "application/json"
-	// ContentJSONProblemHeaderValue header value for JSON API problem error.
-	// Read more at: https://tools.ietf.org/html/rfc7807
-	ContentJSONProblemHeaderValue = "application/problem+json"
-	// ContentXMLProblemHeaderValue header value for XML API problem error.
-	// Read more at: https://tools.ietf.org/html/rfc7807
-	ContentXMLProblemHeaderValue = "application/problem+xml"
-	// ContentJavascriptHeaderValue header value for JSONP & Javascript data.
-	ContentJavascriptHeaderValue = "text/javascript"
-	// ContentTextHeaderValue header value for Text data.
-	ContentTextHeaderValue = "text/plain"
-	// ContentXMLHeaderValue header value for XML data.
-	ContentXMLHeaderValue = "text/xml"
-	// ContentXMLUnreadableHeaderValue obsolete header value for XML.
-	ContentXMLUnreadableHeaderValue = "application/xml"
-	// ContentMarkdownHeaderValue custom key/content type, the real is the text/html.
-	ContentMarkdownHeaderValue = "text/markdown"
-	// ContentYAMLHeaderValue header value for YAML data.
-	ContentYAMLHeaderValue = "application/x-yaml"
-	// ContentYAMLTextHeaderValue header value for YAML plain text.
-	ContentYAMLTextHeaderValue = "text/yaml"
-	// ContentProtobufHeaderValue header value for Protobuf messages data.
-	ContentProtobufHeaderValue = "application/x-protobuf"
-	// ContentMsgPackHeaderValue header value for MsgPack data.
-	ContentMsgPackHeaderValue = "application/msgpack"
-	// ContentMsgPack2HeaderValue alternative header value for MsgPack data.
-	ContentMsgPack2HeaderValue = "application/x-msgpack"
-	// ContentFormHeaderValue header value for post form data.
-	ContentFormHeaderValue = "application/x-www-form-urlencoded"
-	// ContentFormMultipartHeaderValue header value for post multipart form data.
-	ContentFormMultipartHeaderValue = "multipart/form-data"
-	// ContentMultipartRelatedHeaderValue header value for multipart related data.
-	ContentMultipartRelatedHeaderValue = "multipart/related"
-	// ContentGRPCHeaderValue Content-Type header value for gRPC.
-	ContentGRPCHeaderValue = "application/grpc"
-)
-
-var types = map[string]string{
-	".3dm":       "x-world/x-3dmf",
-	".3dmf":      "x-world/x-3dmf",
-	".7z":        "application/x-7z-compressed",
-	".a":         "application/octet-stream",
-	".aab":       "application/x-authorware-bin",
-	".aam":       "application/x-authorware-map",
-	".aas":       "application/x-authorware-seg",
-	".abc":       "text/vndabc",
-	".ace":       "application/x-ace-compressed",
-	".acgi":      "text/html",
-	".afl":       "video/animaflex",
-	".ai":        "application/postscript",
-	".aif":       "audio/aiff",
-	".aifc":      "audio/aiff",
-	".aiff":      "audio/aiff",
-	".aim":       "application/x-aim",
-	".aip":       "text/x-audiosoft-intra",
-	".alz":       "application/x-alz-compressed",
-	".ani":       "application/x-navi-animation",
-	".aos":       "application/x-nokia-9000-communicator-add-on-software",
-	".aps":       "application/mime",
-	".apk":       "application/vnd.android.package-archive",
-	".arc":       "application/x-arc-compressed",
-	".arj":       "application/arj",
-	".art":       "image/x-jg",
-	".asf":       "video/x-ms-asf",
-	".asm":       "text/x-asm",
-	".asp":       "text/asp",
-	".asx":       "application/x-mplayer2",
-	".au":        "audio/basic",
-	".avi":       "video/x-msvideo",
-	".avs":       "video/avs-video",
-	".bcpio":     "application/x-bcpio",
-	".bin":       "application/mac-binary",
-	".bmp":       "image/bmp",
-	".boo":       "application/book",
-	".book":      "application/book",
-	".boz":       "application/x-bzip2",
-	".bsh":       "application/x-bsh",
-	".bz2":       "application/x-bzip2",
-	".bz":        "application/x-bzip",
-	".c++":       ContentTextHeaderValue,
-	".c":         "text/x-c",
-	".cab":       "application/vnd.ms-cab-compressed",
-	".cat":       "application/vndms-pkiseccat",
-	".cc":        "text/x-c",
-	".ccad":      "application/clariscad",
-	".cco":       "application/x-cocoa",
-	".cdf":       "application/cdf",
-	".cer":       "application/pkix-cert",
-	".cha":       "application/x-chat",
-	".chat":      "application/x-chat",
-	".chrt":      "application/vnd.kde.kchart",
-	".class":     "application/java",
-	".com":       ContentTextHeaderValue,
-	".conf":      ContentTextHeaderValue,
-	".cpio":      "application/x-cpio",
-	".cpp":       "text/x-c",
-	".cpt":       "application/mac-compactpro",
-	".crl":       "application/pkcs-crl",
-	".crt":       "application/pkix-cert",
-	".crx":       "application/x-chrome-extension",
-	".csh":       "text/x-scriptcsh",
-	".css":       "text/css",
-	".csv":       "text/csv",
-	".cxx":       ContentTextHeaderValue,
-	".dar":       "application/x-dar",
-	".dcr":       "application/x-director",
-	".deb":       "application/x-debian-package",
-	".deepv":     "application/x-deepv",
-	".def":       ContentTextHeaderValue,
-	".der":       "application/x-x509-ca-cert",
-	".dif":       "video/x-dv",
-	".dir":       "application/x-director",
-	".divx":      "video/divx",
-	".dl":        "video/dl",
-	".dmg":       "application/x-apple-diskimage",
-	".doc":       "application/msword",
-	".dot":       "application/msword",
-	".dp":        "application/commonground",
-	".drw":       "application/drafting",
-	".dump":      "application/octet-stream",
-	".dv":        "video/x-dv",
-	".dvi":       "application/x-dvi",
-	".dwf":       "drawing/x-dwf=(old)",
-	".dwg":       "application/acad",
-	".dxf":       "application/dxf",
-	".dxr":       "application/x-director",
-	".el":        "text/x-scriptelisp",
-	".elc":       "application/x-bytecodeelisp=(compiled=elisp)",
-	".eml":       "message/rfc822",
-	".env":       "application/x-envoy",
-	".eps":       "application/postscript",
-	".es":        "application/x-esrehber",
-	".etx":       "text/x-setext",
-	".evy":       "application/envoy",
-	".exe":       "application/octet-stream",
-	".f77":       "text/x-fortran",
-	".f90":       "text/x-fortran",
-	".f":         "text/x-fortran",
-	".fdf":       "application/vndfdf",
-	".fif":       "application/fractals",
-	".fli":       "video/fli",
-	".flo":       "image/florian",
-	".flv":       "video/x-flv",
-	".flx":       "text/vndfmiflexstor",
-	".fmf":       "video/x-atomic3d-feature",
-	".for":       "text/x-fortran",
-	".fpx":       "image/vndfpx",
-	".frl":       "application/freeloader",
-	".funk":      "audio/make",
-	".g3":        "image/g3fax",
-	".g":         ContentTextHeaderValue,
-	".gif":       "image/gif",
-	".gl":        "video/gl",
-	".gsd":       "audio/x-gsm",
-	".gsm":       "audio/x-gsm",
-	".gsp":       "application/x-gsp",
-	".gss":       "application/x-gss",
-	".gtar":      "application/x-gtar",
-	".gz":        "application/x-compressed",
-	".gzip":      "application/x-gzip",
-	".h":         "text/x-h",
-	".hdf":       "application/x-hdf",
-	".help":      "application/x-helpfile",
-	".hgl":       "application/vndhp-hpgl",
-	".hh":        "text/x-h",
-	".hlb":       "text/x-script",
-	".hlp":       "application/hlp",
-	".hpg":       "application/vndhp-hpgl",
-	".hpgl":      "application/vndhp-hpgl",
-	".hqx":       "application/binhex",
-	".hta":       "application/hta",
-	".htc":       "text/x-component",
-	".htm":       "text/html",
-	".html":      "text/html",
-	".htmls":     "text/html",
-	".htt":       "text/webviewhtml",
-	".htx":       "text/html",
-	".ice":       "x-conference/x-cooltalk",
-	".ico":       "image/x-icon",
-	".ics":       "text/calendar",
-	".icz":       "text/calendar",
-	".idc":       ContentTextHeaderValue,
-	".ief":       "image/ief",
-	".iefs":      "image/ief",
-	".iges":      "application/iges",
-	".igs":       "application/iges",
-	".ima":       "application/x-ima",
-	".imap":      "application/x-httpd-imap",
-	".inf":       "application/inf",
-	".ins":       "application/x-internett-signup",
-	".ip":        "application/x-ip2",
-	".isu":       "video/x-isvideo",
-	".it":        "audio/it",
-	".iv":        "application/x-inventor",
-	".ivr":       "i-world/i-vrml",
-	".ivy":       "application/x-livescreen",
-	".jam":       "audio/x-jam",
-	".jav":       "text/x-java-source",
-	".java":      "text/x-java-source",
-	".jcm":       "application/x-java-commerce",
-	".jfif-tbnl": "image/jpeg",
-	".jfif":      "image/jpeg",
-	".jnlp":      "application/x-java-jnlp-file",
-	".jpe":       "image/jpeg",
-	".jpeg":      "image/jpeg",
-	".jpg":       "image/jpeg",
-	".jps":       "image/x-jps",
-	".js":        ContentJavascriptHeaderValue,
-	".mjs":       ContentJavascriptHeaderValue,
-	".json":      ContentJSONHeaderValue,
-	".vue":       ContentJavascriptHeaderValue,
-	".jut":       "image/jutvision",
-	".kar":       "audio/midi",
-	".karbon":    "application/vnd.kde.karbon",
-	".kfo":       "application/vnd.kde.kformula",
-	".flw":       "application/vnd.kde.kivio",
-	".kml":       "application/vnd.google-earth.kml+xml",
-	".kmz":       "application/vnd.google-earth.kmz",
-	".kon":       "application/vnd.kde.kontour",
-	".kpr":       "application/vnd.kde.kpresenter",
-	".kpt":       "application/vnd.kde.kpresenter",
-	".ksp":       "application/vnd.kde.kspread",
-	".kwd":       "application/vnd.kde.kword",
-	".kwt":       "application/vnd.kde.kword",
-	".ksh":       "text/x-scriptksh",
-	".la":        "audio/nspaudio",
-	".lam":       "audio/x-liveaudio",
-	".latex":     "application/x-latex",
-	".lha":       "application/lha",
-	".lhx":       "application/octet-stream",
-	".list":      ContentTextHeaderValue,
-	".lma":       "audio/nspaudio",
-	".log":       ContentTextHeaderValue,
-	".lsp":       "text/x-scriptlisp",
-	".lst":       ContentTextHeaderValue,
-	".lsx":       "text/x-la-asf",
-	".ltx":       "application/x-latex",
-	".lzh":       "application/octet-stream",
-	".lzx":       "application/lzx",
-	".m1v":       "video/mpeg",
-	".m2a":       "audio/mpeg",
-	".m2v":       "video/mpeg",
-	".m3u":       "audio/x-mpegurl",
-	".m":         "text/x-m",
-	".man":       "application/x-troff-man",
-	".manifest":  "text/cache-manifest",
-	".map":       "application/x-navimap",
-	".mar":       ContentTextHeaderValue,
-	".mbd":       "application/mbedlet",
-	".mc$":       "application/x-magic-cap-package-10",
-	".mcd":       "application/mcad",
-	".mcf":       "text/mcf",
-	".mcp":       "application/netmc",
-	".me":        "application/x-troff-me",
-	".mht":       "message/rfc822",
-	".mhtml":     "message/rfc822",
-	".mid":       "application/x-midi",
-	".midi":      "application/x-midi",
-	".mif":       "application/x-frame",
-	".mime":      "message/rfc822",
-	".mjf":       "audio/x-vndaudioexplosionmjuicemediafile",
-	".mjpg":      "video/x-motion-jpeg",
-	".mm":        "application/base64",
-	".mme":       "application/base64",
-	".mod":       "audio/mod",
-	".moov":      "video/quicktime",
-	".mov":       "video/quicktime",
-	".movie":     "video/x-sgi-movie",
-	".mp2":       "audio/mpeg",
-	".mp3":       "audio/mpeg",
-	".mp4":       "video/mp4",
-	".mpa":       "audio/mpeg",
-	".mpc":       "application/x-project",
-	".mpe":       "video/mpeg",
-	".mpeg":      "video/mpeg",
-	".mpg":       "video/mpeg",
-	".mpga":      "audio/mpeg",
-	".mpp":       "application/vndms-project",
-	".mpt":       "application/x-project",
-	".mpv":       "application/x-project",
-	".mpx":       "application/x-project",
-	".mrc":       "application/marc",
-	".ms":        "application/x-troff-ms",
-	".mv":        "video/x-sgi-movie",
-	".my":        "audio/make",
-	".mzz":       "application/x-vndaudioexplosionmzz",
-	".nap":       "image/naplps",
-	".naplps":    "image/naplps",
-	".nc":        "application/x-netcdf",
-	".ncm":       "application/vndnokiaconfiguration-message",
-	".nif":       "image/x-niff",
-	".niff":      "image/x-niff",
-	".nix":       "application/x-mix-transfer",
-	".nsc":       "application/x-conference",
-	".nvd":       "application/x-navidoc",
-	".o":         "application/octet-stream",
-	".oda":       "application/oda",
-	".odb":       "application/vnd.oasis.opendocument.database",
-	".odc":       "application/vnd.oasis.opendocument.chart",
-	".odf":       "application/vnd.oasis.opendocument.formula",
-	".odg":       "application/vnd.oasis.opendocument.graphics",
-	".odi":       "application/vnd.oasis.opendocument.image",
-	".odm":       "application/vnd.oasis.opendocument.text-master",
-	".odp":       "application/vnd.oasis.opendocument.presentation",
-	".ods":       "application/vnd.oasis.opendocument.spreadsheet",
-	".odt":       "application/vnd.oasis.opendocument.text",
-	".oga":       "audio/ogg",
-	".ogg":       "audio/ogg",
-	".ogv":       "video/ogg",
-	".omc":       "application/x-omc",
-	".omcd":      "application/x-omcdatamaker",
-	".omcr":      "application/x-omcregerator",
-	".otc":       "application/vnd.oasis.opendocument.chart-template",
-	".otf":       "application/vnd.oasis.opendocument.formula-template",
-	".otg":       "application/vnd.oasis.opendocument.graphics-template",
-	".oth":       "application/vnd.oasis.opendocument.text-web",
-	".oti":       "application/vnd.oasis.opendocument.image-template",
-	".otm":       "application/vnd.oasis.opendocument.text-master",
-	".otp":       "application/vnd.oasis.opendocument.presentation-template",
-	".ots":       "application/vnd.oasis.opendocument.spreadsheet-template",
-	".ott":       "application/vnd.oasis.opendocument.text-template",
-	".p10":       "application/pkcs10",
-	".p12":       "application/pkcs-12",
-	".p7a":       "application/x-pkcs7-signature",
-	".p7c":       "application/pkcs7-mime",
-	".p7m":       "application/pkcs7-mime",
-	".p7r":       "application/x-pkcs7-certreqresp",
-	".p7s":       "application/pkcs7-signature",
-	".p":         "text/x-pascal",
-	".part":      "application/pro_eng",
-	".pas":       "text/pascal",
-	".pbm":       "image/x-portable-bitmap",
-	".pcl":       "application/vndhp-pcl",
-	".pct":       "image/x-pict",
-	".pcx":       "image/x-pcx",
-	".pdb":       "chemical/x-pdb",
-	".pdf":       "application/pdf",
-	".pfunk":     "audio/make",
-	".pgm":       "image/x-portable-graymap",
-	".pic":       "image/pict",
-	".pict":      "image/pict",
-	".pkg":       "application/x-newton-compatible-pkg",
-	".pko":       "application/vndms-pkipko",
-	".pl":        "text/x-scriptperl",
-	".plx":       "application/x-pixclscript",
-	".pm4":       "application/x-pagemaker",
-	".pm5":       "application/x-pagemaker",
-	".pm":        "text/x-scriptperl-module",
-	".png":       "image/png",
-	".pnm":       "application/x-portable-anymap",
-	".pot":       "application/mspowerpoint",
-	".pov":       "model/x-pov",
-	".ppa":       "application/vndms-powerpoint",
-	".ppm":       "image/x-portable-pixmap",
-	".pps":       "application/mspowerpoint",
-	".ppt":       "application/mspowerpoint",
-	".ppz":       "application/mspowerpoint",
-	".pre":       "application/x-freelance",
-	".prt":       "application/pro_eng",
-	".ps":        "application/postscript",
-	".psd":       "application/octet-stream",
-	".pvu":       "paleovu/x-pv",
-	".pwz":       "application/vndms-powerpoint",
-	".py":        "text/x-scriptphyton",
-	".pyc":       "application/x-bytecodepython",
-	".qcp":       "audio/vndqcelp",
-	".qd3":       "x-world/x-3dmf",
-	".qd3d":      "x-world/x-3dmf",
-	".qif":       "image/x-quicktime",
-	".qt":        "video/quicktime",
-	".qtc":       "video/x-qtc",
-	".qti":       "image/x-quicktime",
-	".qtif":      "image/x-quicktime",
-	".ra":        "audio/x-pn-realaudio",
-	".ram":       "audio/x-pn-realaudio",
-	".rar":       "application/x-rar-compressed",
-	".ras":       "application/x-cmu-raster",
-	".rast":      "image/cmu-raster",
-	".rexx":      "text/x-scriptrexx",
-	".rf":        "image/vndrn-realflash",
-	".rgb":       "image/x-rgb",
-	".rm":        "application/vndrn-realmedia",
-	".rmi":       "audio/mid",
-	".rmm":       "audio/x-pn-realaudio",
-	".rmp":       "audio/x-pn-realaudio",
-	".rng":       "application/ringing-tones",
-	".rnx":       "application/vndrn-realplayer",
-	".roff":      "application/x-troff",
-	".rp":        "image/vndrn-realpix",
-	".rpm":       "audio/x-pn-realaudio-plugin",
-	".rt":        "text/vndrn-realtext",
-	".rtf":       "text/richtext",
-	".rtx":       "text/richtext",
-	".rv":        "video/vndrn-realvideo",
-	".s":         "text/x-asm",
-	".s3m":       "audio/s3m",
-	".s7z":       "application/x-7z-compressed",
-	".saveme":    "application/octet-stream",
-	".sbk":       "application/x-tbook",
-	".scm":       "text/x-scriptscheme",
-	".sdml":      ContentTextHeaderValue,
-	".sdp":       "application/sdp",
-	".sdr":       "application/sounder",
-	".sea":       "application/sea",
-	".set":       "application/set",
-	".sgm":       "text/x-sgml",
-	".sgml":      "text/x-sgml",
-	".sh":        "text/x-scriptsh",
-	".shar":      "application/x-bsh",
-	".shtml":     "text/x-server-parsed-html",
-	".sid":       "audio/x-psid",
-	".skd":       "application/x-koan",
-	".skm":       "application/x-koan",
-	".skp":       "application/x-koan",
-	".skt":       "application/x-koan",
-	".sit":       "application/x-stuffit",
-	".sitx":      "application/x-stuffitx",
-	".sl":        "application/x-seelogo",
-	".smi":       "application/smil",
-	".smil":      "application/smil",
-	".snd":       "audio/basic",
-	".sol":       "application/solids",
-	".spc":       "text/x-speech",
-	".spl":       "application/futuresplash",
-	".spr":       "application/x-sprite",
-	".sprite":    "application/x-sprite",
-	".spx":       "audio/ogg",
-	".src":       "application/x-wais-source",
-	".ssi":       "text/x-server-parsed-html",
-	".ssm":       "application/streamingmedia",
-	".sst":       "application/vndms-pkicertstore",
-	".step":      "application/step",
-	".stl":       "application/sla",
-	".stp":       "application/step",
-	".sv4cpio":   "application/x-sv4cpio",
-	".sv4crc":    "application/x-sv4crc",
-	".svf":       "image/vnddwg",
-	".svg":       "image/svg+xml",
-	".svr":       "application/x-world",
-	".swf":       "application/x-shockwave-flash",
-	".t":         "application/x-troff",
-	".talk":      "text/x-speech",
-	".tar":       "application/x-tar",
-	".tbk":       "application/toolbook",
-	".tcl":       "text/x-scripttcl",
-	".tcsh":      "text/x-scripttcsh",
-	".tex":       "application/x-tex",
-	".texi":      "application/x-texinfo",
-	".texinfo":   "application/x-texinfo",
-	".text":      ContentTextHeaderValue,
-	".tgz":       "application/gnutar",
-	".tif":       "image/tiff",
-	".tiff":      "image/tiff",
-	".tr":        "application/x-troff",
-	".tsi":       "audio/tsp-audio",
-	".tsp":       "application/dsptype",
-	".tsv":       "text/tab-separated-values",
-	".turbot":    "image/florian",
-	".txt":       ContentTextHeaderValue,
-	".uil":       "text/x-uil",
-	".uni":       "text/uri-list",
-	".unis":      "text/uri-list",
-	".unv":       "application/i-deas",
-	".uri":       "text/uri-list",
-	".uris":      "text/uri-list",
-	".ustar":     "application/x-ustar",
-	".uu":        "text/x-uuencode",
-	".uue":       "text/x-uuencode",
-	".vcd":       "application/x-cdlink",
-	".vcf":       "text/x-vcard",
-	".vcard":     "text/x-vcard",
-	".vcs":       "text/x-vcalendar",
-	".vda":       "application/vda",
-	".vdo":       "video/vdo",
-	".vew":       "application/groupwise",
-	".viv":       "video/vivo",
-	".vivo":      "video/vivo",
-	".vmd":       "application/vocaltec-media-desc",
-	".vmf":       "application/vocaltec-media-file",
-	".voc":       "audio/voc",
-	".vos":       "video/vosaic",
-	".vox":       "audio/voxware",
-	".vqe":       "audio/x-twinvq-plugin",
-	".vqf":       "audio/x-twinvq",
-	".vql":       "audio/x-twinvq-plugin",
-	".vrml":      "application/x-vrml",
-	".vrt":       "x-world/x-vrt",
-	".vsd":       "application/x-visio",
-	".vst":       "application/x-visio",
-	".vsw":       "application/x-visio",
-	".w60":       "application/wordperfect60",
-	".w61":       "application/wordperfect61",
-	".w6w":       "application/msword",
-	".wav":       "audio/wav",
-	".wb1":       "application/x-qpro",
-	".wbmp":      "image/vnd.wap.wbmp",
-	".web":       "application/vndxara",
-	".wiz":       "application/msword",
-	".wk1":       "application/x-123",
-	".wmf":       "windows/metafile",
-	".wml":       "text/vnd.wap.wml",
-	".wmlc":      "application/vnd.wap.wmlc",
-	".wmls":      "text/vnd.wap.wmlscript",
-	".wmlsc":     "application/vnd.wap.wmlscriptc",
-	".word":      "application/msword",
-	".wp5":       "application/wordperfect",
-	".wp6":       "application/wordperfect",
-	".wp":        "application/wordperfect",
-	".wpd":       "application/wordperfect",
-	".wq1":       "application/x-lotus",
-	".wri":       "application/mswrite",
-	".wrl":       "application/x-world",
-	".wrz":       "model/vrml",
-	".wsc":       "text/scriplet",
-	".wsrc":      "application/x-wais-source",
-	".wtk":       "application/x-wintalk",
-	".x-png":     "image/png",
-	".xbm":       "image/x-xbitmap",
-	".xdr":       "video/x-amt-demorun",
-	".xgz":       "xgl/drawing",
-	".xif":       "image/vndxiff",
-	".xl":        "application/excel",
-	".xla":       "application/excel",
-	".xlb":       "application/excel",
-	".xlc":       "application/excel",
-	".xld":       "application/excel",
-	".xlk":       "application/excel",
-	".xll":       "application/excel",
-	".xlm":       "application/excel",
-	".xls":       "application/excel",
-	".xlt":       "application/excel",
-	".xlv":       "application/excel",
-	".xlw":       "application/excel",
-	".xm":        "audio/xm",
-	".xml":       ContentXMLHeaderValue,
-	".xmz":       "xgl/movie",
-	".xpix":      "application/x-vndls-xpix",
-	".xpm":       "image/x-xpixmap",
-	".xsr":       "video/x-amt-showrun",
-	".xwd":       "image/x-xwd",
-	".xyz":       "chemical/x-pdb",
-	".z":         "application/x-compress",
-	".zip":       "application/zip",
-	".zoo":       "application/octet-stream",
-	".zsh":       "text/x-scriptzsh",
-	".docx":      "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-	".docm":      "application/vnd.ms-word.document.macroEnabled.12",
-	".dotx":      "application/vnd.openxmlformats-officedocument.wordprocessingml.template",
-	".dotm":      "application/vnd.ms-word.template.macroEnabled.12",
-	".xlsx":      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-	".xlsm":      "application/vnd.ms-excel.sheet.macroEnabled.12",
-	".xltx":      "application/vnd.openxmlformats-officedocument.spreadsheetml.template",
-	".xltm":      "application/vnd.ms-excel.template.macroEnabled.12",
-	".xlsb":      "application/vnd.ms-excel.sheet.binary.macroEnabled.12",
-	".xlam":      "application/vnd.ms-excel.addin.macroEnabled.12",
-	".pptx":      "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-	".pptm":      "application/vnd.ms-powerpoint.presentation.macroEnabled.12",
-	".ppsx":      "application/vnd.openxmlformats-officedocument.presentationml.slideshow",
-	".ppsm":      "application/vnd.ms-powerpoint.slideshow.macroEnabled.12",
-	".potx":      "application/vnd.openxmlformats-officedocument.presentationml.template",
-	".potm":      "application/vnd.ms-powerpoint.template.macroEnabled.12",
-	".ppam":      "application/vnd.ms-powerpoint.addin.macroEnabled.12",
-	".sldx":      "application/vnd.openxmlformats-officedocument.presentationml.slide",
-	".sldm":      "application/vnd.ms-powerpoint.slide.macroEnabled.12",
-	".thmx":      "application/vnd.ms-officetheme",
-	".onetoc":    "application/onenote",
-	".onetoc2":   "application/onenote",
-	".onetmp":    "application/onenote",
-	".onepkg":    "application/onenote",
-	".xpi":       "application/x-xpinstall",
-	".wasm":      "application/wasm",
-	".m4a":       "audio/mp4",
-	".flac":      "audio/x-flac",
-	".amr":       "audio/amr",
-	".aac":       "audio/aac",
-	".opus":      "video/ogg",
-	".m4v":       "video/mp4",
-	".mkv":       "video/x-matroska",
-	".caf":       "audio/x-caf",
-	".m3u8":      "application/x-mpegURL",
-	".mpd":       "application/dash+xml",
-	".webp":      "image/webp",
-	".epub":      "application/epub+zip",
-}
-
-func init() {
-	for ext, typ := range types {
-		// skip errors
-		_ = mime.AddExtensionType(ext, typ)
-	}
-}

files/utils.go

@@ -1,59 +1,12 @@
 package files
 
-import (
+func isBinary(content string) bool {
-	"os"
+	for _, b := range content {
-	"unicode/utf8"
+		// 65533 is the unknown char
-)
-
-func isBinary(content []byte) bool {
-	maybeStr := string(content)
-	runeCnt := utf8.RuneCount(content)
-	runeIndex := 0
-	gotRuneErrCnt := 0
-	firstRuneErrIndex := -1
-
-	const (
 		// 8 and below are control chars (e.g. backspace, null, eof, etc)
-		maxControlCharsCode = 8
+		if b <= 8 || b == 65533 {
-		// 0xFFFD(65533) is  the "error" Rune or "Unicode replacement character"
-		// see https://golang.org/pkg/unicode/utf8/#pkg-constants
-		unicodeReplacementChar = 0xFFFD
-	)
-
-	for _, b := range maybeStr {
-		if b <= maxControlCharsCode {
 			return true
 		}
-
-		if b == unicodeReplacementChar {
-			// if it is not the last (utf8.UTFMax - x) rune
-			if runeCnt > utf8.UTFMax && runeIndex < runeCnt-utf8.UTFMax {
-				return true
-			}
-			// else it is the last (utf8.UTFMax - x) rune
-			// there maybe Vxxx, VVxx, VVVx, thus, we may got max 3 0xFFFD rune (assume V is the byte we got)
-			// for Chinese, it can only be Vxx, VVx, we may got max 2 0xFFFD rune
-			gotRuneErrCnt++
-
-			// mark the first time
-			if firstRuneErrIndex == -1 {
-				firstRuneErrIndex = runeIndex
-			}
-		}
-		runeIndex++
-	}
-
-	// if last (utf8.UTFMax - x ) rune has the "error" Rune, but not all
-	if firstRuneErrIndex != -1 && gotRuneErrCnt != runeCnt-firstRuneErrIndex {
-		return true
 	}
 	return false
 }
-
-func IsNamedPipe(mode os.FileMode) bool {
-	return mode&os.ModeNamedPipe != 0
-}
-
-func IsSymlink(mode os.FileMode) bool {
-	return mode&os.ModeSymlink != 0
-}

fileutils/copy.go

@@ -1,7 +1,6 @@
 package fileutils
 
 import (
-	"io/fs"
 	"os"
 	"path"
 
@@ -9,7 +8,7 @@ import (
 )
 
 // Copy copies a file or folder from one place to another.
-func Copy(afs afero.Fs, src, dst string, fileMode, dirMode fs.FileMode) error {
+func Copy(fs afero.Fs, src, dst string) error {
 	if src = path.Clean("/" + src); src == "" {
 		return os.ErrNotExist
 	}
@@ -27,14 +26,14 @@ func Copy(afs afero.Fs, src, dst string, fileMode, dirMode fs.FileMode) error {
 		return os.ErrInvalid
 	}
 
-	info, err := afs.Stat(src)
+	info, err := fs.Stat(src)
 	if err != nil {
 		return err
 	}
 
 	if info.IsDir() {
-		return CopyDir(afs, src, dst, fileMode, dirMode)
+		return CopyDir(fs, src, dst)
 	}
 
-	return CopyFile(afs, src, dst, fileMode, dirMode)
+	return CopyFile(fs, src, dst)
 }

fileutils/dir.go

@@ -2,7 +2,6 @@ package fileutils
 
 import (
 	"errors"
-	"io/fs"
 
 	"github.com/spf13/afero"
 )
@@ -10,20 +9,20 @@ import (
 // CopyDir copies a directory from source to dest and all
 // of its sub-directories. It doesn't stop if it finds an error
 // during the copy. Returns an error if any.
-func CopyDir(afs afero.Fs, source, dest string, fileMode, dirMode fs.FileMode) error {
+func CopyDir(fs afero.Fs, source string, dest string) error {
 	// Get properties of source.
-	srcinfo, err := afs.Stat(source)
+	srcinfo, err := fs.Stat(source)
 	if err != nil {
 		return err
 	}
 
 	// Create the destination directory.
-	err = afs.MkdirAll(dest, srcinfo.Mode())
+	err = fs.MkdirAll(dest, srcinfo.Mode())
 	if err != nil {
 		return err
 	}
 
-	dir, _ := afs.Open(source)
+	dir, _ := fs.Open(source)
 	obs, err := dir.Readdir(-1)
 	if err != nil {
 		return err
@@ -37,13 +36,13 @@ func CopyDir(afs afero.Fs, source, dest string, fileMode, dirMode fs.FileMode) e
 
 		if obj.IsDir() {
 			// Create sub-directories, recursively.
-			err = CopyDir(afs, fsource, fdest, fileMode, dirMode)
+			err = CopyDir(fs, fsource, fdest)
 			if err != nil {
 				errs = append(errs, err)
 			}
 		} else {
 			// Perform the file copy.
-			err = CopyFile(afs, fsource, fdest, fileMode, dirMode)
+			err = CopyFile(fs, fsource, fdest)
 			if err != nil {
 				errs = append(errs, err)
 			}

fileutils/file.go

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

fileutils/file_test.go

@@ -1,46 +0,0 @@
-package fileutils
-
-import "testing"
-
-func TestCommonPrefix(t *testing.T) {
-	testCases := map[string]struct {
-		paths []string
-		want  string
-	}{
-		"same lvl": {
-			paths: []string{
-				"/home/user/file1",
-				"/home/user/file2",
-			},
-			want: "/home/user",
-		},
-		"sub folder": {
-			paths: []string{
-				"/home/user/folder",
-				"/home/user/folder/file",
-			},
-			want: "/home/user/folder",
-		},
-		"relative path": {
-			paths: []string{
-				"/home/user/folder",
-				"/home/user/folder/../folder2",
-			},
-			want: "/home/user",
-		},
-		"no common path": {
-			paths: []string{
-				"/home/user/folder",
-				"/etc/file",
-			},
-			want: "",
-		},
-	}
-	for name, tt := range testCases {
-		t.Run(name, func(t *testing.T) {
-			if got := CommonPrefix('/', tt.paths...); got != tt.want {
-				t.Errorf("CommonPrefix() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}

frontend

@@ -0,0 +1 @@
+Subproject commit 2ed87febcb71c71588f53d5b6ed560cd5c99f526

frontend/.prettierignore

@@ -1,3 +0,0 @@
-# Ignore artifacts:
-dist
-pnpm-lock.yaml

frontend/.prettierrc.json

@@ -1,3 +0,0 @@
-{
-  "trailingComma": "es5"
-}

frontend/assets.go

@@ -1,12 +0,0 @@
-//go:build !dev
-
-package frontend
-
-import "embed"
-
-//go:embed dist/*
-var assets embed.FS
-
-func Assets() embed.FS {
-	return assets
-}

frontend/env.d.ts

@@ -1 +0,0 @@
-/// <reference types="vite/client" />

frontend/eslint.config.js

@@ -1,37 +0,0 @@
-import pluginVue from "eslint-plugin-vue";
-import {
-  defineConfigWithVueTs,
-  vueTsConfigs,
-} from "@vue/eslint-config-typescript";
-import prettierConfig from "@vue/eslint-config-prettier";
-
-export default defineConfigWithVueTs(
-  {
-    name: "app/files-to-lint",
-    files: ["**/*.{ts,mts,tsx,vue}"],
-  },
-  {
-    name: "app/files-to-ignore",
-    ignores: ["**/dist/**", "**/dist-ssr/**", "**/coverage/**"],
-  },
-  pluginVue.configs["flat/essential"],
-  vueTsConfigs.recommended,
-  prettierConfig,
-  {
-    rules: {
-      // Note: you must disable the base rule as it can report incorrect errors
-      "@typescript-eslint/no-unused-expressions": "off",
-      // TODO: theres too many of these from before ts
-      "@typescript-eslint/no-explicit-any": "off",
-      // TODO: finish the ts conversion
-      "vue/block-lang": "off",
-      "vue/multi-word-component-names": "off",
-      "vue/no-mutating-props": [
-        "error",
-        {
-          shallowOnly: true,
-        },
-      ],
-    },
-  }
-);

frontend/index.html

@@ -1,176 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
-    <meta
-      name="viewport"
-      content="width=device-width, initial-scale=1, user-scalable=no"
-    />
-
-    <title>File Browser</title>
-
-    <link rel="icon" type="image/svg+xml" href="/img/icons/favicon.svg" />
-    <link rel="shortcut icon" href="/img/icons/favicon.ico" />
-    <link
-      rel="apple-touch-icon"
-      sizes="180x180"
-      href="/img/icons/apple-touch-icon.png"
-    />
-    <meta name="apple-mobile-web-app-title" content="File Browser" />
-
-    <!-- Add to home screen for Android and modern mobile browsers -->
-    <link
-      rel="manifest"
-      id="manifestPlaceholder"
-      crossorigin="use-credentials"
-    />
-    <meta name="theme-color" content="#2979ff" />
-
-    <!-- Inject Some Variables and generate the manifest json -->
-    <script>
-      // We can assign JSON directly
-      window.FileBrowser = {
-        AuthMethod: "json",
-        BaseURL: "",
-        CSS: false,
-        Color: "",
-        DisableExternal: false,
-        DisableUsedPercentage: false,
-        EnableExec: true,
-        EnableThumbs: true,
-        LogoutPage: "",
-        LoginPage: true,
-        Name: "",
-        NoAuth: false,
-        ReCaptcha: false,
-        ResizePreview: true,
-        Signup: false,
-        StaticURL: "",
-        Theme: "",
-        TusSettings: { chunkSize: 10485760, retryCount: 5 },
-        Version: "(untracked)",
-      };
-      // Global function to prepend static url
-      window.__prependStaticUrl = (url) => {
-        return `${window.FileBrowser.StaticURL}/${url.replace(/^\/+/, "")}`;
-      };
-      var dynamicManifest = {
-        name: window.FileBrowser.Name || "File Browser",
-        short_name: window.FileBrowser.Name || "File Browser",
-        icons: [
-          {
-            src: window.__prependStaticUrl(
-              "/img/icons/android-chrome-192x192.png"
-            ),
-            sizes: "192x192",
-            type: "image/png",
-          },
-          {
-            src: window.__prependStaticUrl(
-              "/img/icons/android-chrome-512x512.png"
-            ),
-            sizes: "512x512",
-            type: "image/png",
-          },
-        ],
-        start_url: window.location.origin + window.FileBrowser.BaseURL,
-        display: "standalone",
-        background_color: "#ffffff",
-        theme_color: window.FileBrowser.Color || "#455a64",
-      };
-
-      const stringManifest = JSON.stringify(dynamicManifest);
-      const blob = new Blob([stringManifest], { type: "application/json" });
-      const manifestURL = URL.createObjectURL(blob);
-      document
-        .querySelector("#manifestPlaceholder")
-        .setAttribute("href", manifestURL);
-    </script>
-
-    <style>
-      #loading {
-        position: fixed;
-        top: 0;
-        left: 0;
-        width: 100%;
-        height: 100%;
-        background: #fff;
-        z-index: 9999;
-        transition: 0.1s ease opacity;
-        -webkit-transition: 0.1s ease opacity;
-      }
-
-      #loading.done {
-        opacity: 0;
-      }
-
-      #loading .spinner {
-        width: 70px;
-        text-align: center;
-        position: fixed;
-        top: 50%;
-        left: 50%;
-        -webkit-transform: translate(-50%, -50%);
-        transform: translate(-50%, -50%);
-      }
-
-      #loading .spinner > div {
-        width: 18px;
-        height: 18px;
-        background-color: #333;
-        border-radius: 100%;
-        display: inline-block;
-        -webkit-animation: sk-bouncedelay 1.4s infinite ease-in-out both;
-        animation: sk-bouncedelay 1.4s infinite ease-in-out both;
-      }
-
-      #loading .spinner .bounce1 {
-        -webkit-animation-delay: -0.32s;
-        animation-delay: -0.32s;
-      }
-
-      #loading .spinner .bounce2 {
-        -webkit-animation-delay: -0.16s;
-        animation-delay: -0.16s;
-      }
-
-      @-webkit-keyframes sk-bouncedelay {
-        0%,
-        80%,
-        100% {
-          -webkit-transform: scale(0);
-        }
-        40% {
-          -webkit-transform: scale(1);
-        }
-      }
-
-      @keyframes sk-bouncedelay {
-        0%,
-        80%,
-        100% {
-          -webkit-transform: scale(0);
-          transform: scale(0);
-        }
-        40% {
-          -webkit-transform: scale(1);
-          transform: scale(1);
-        }
-      }
-    </style>
-  </head>
-  <body>
-    <div id="app"></div>
-
-    <div id="loading">
-      <div class="spinner">
-        <div class="bounce1"></div>
-        <div class="bounce2"></div>
-        <div class="bounce3"></div>
-      </div>
-    </div>
-
-    <script type="module" src="/src/main.ts"></script>
-  </body>
-</html>

frontend/package.json

@@ -1,75 +0,0 @@
-{
-  "name": "filebrowser-frontend",
-  "version": "3.0.0",
-  "private": true,
-  "type": "module",
-  "engines": {
-    "node": ">=24.0.0",
-    "pnpm": ">=10.0.0"
-  },
-  "scripts": {
-    "dev": "vite dev",
-    "build": "pnpm run typecheck && vite build",
-    "clean": "find ./dist -maxdepth 1 -mindepth 1 ! -name '.gitkeep' -exec rm -r {} +",
-    "typecheck": "vue-tsc -p ./tsconfig.app.json --noEmit",
-    "lint": "eslint src/",
-    "lint:fix": "eslint --fix src/",
-    "format": "prettier --write ."
-  },
-  "dependencies": {
-    "@chenfengyuan/vue-number-input": "^2.0.1",
-    "@vueuse/core": "^14.0.0",
-    "@vueuse/integrations": "^14.0.0",
-    "ace-builds": "^1.43.2",
-    "dayjs": "^1.11.13",
-    "dompurify": "^3.2.6",
-    "epubjs": "^0.3.93",
-    "filesize": "^11.0.13",
-    "js-base64": "^3.7.7",
-    "jwt-decode": "^4.0.0",
-    "lodash-es": "^4.17.21",
-    "marked": "^17.0.0",
-    "material-icons": "^1.13.14",
-    "normalize.css": "^8.0.1",
-    "pinia": "^3.0.4",
-    "pretty-bytes": "^7.1.0",
-    "qrcode.vue": "^3.6.0",
-    "tus-js-client": "^4.3.1",
-    "utif": "^3.1.0",
-    "video.js": "^8.23.3",
-    "videojs-hotkeys": "^0.2.28",
-    "videojs-mobile-ui": "^1.1.1",
-    "vue": "^3.5.17",
-    "vue-final-modal": "^4.5.5",
-    "vue-i18n": "^11.1.10",
-    "vue-lazyload": "^3.0.0",
-    "vue-reader": "^1.2.17",
-    "vue-router": "^4.5.1",
-    "vue-toastification": "^2.0.0-rc.5"
-  },
-  "devDependencies": {
-    "@intlify/unplugin-vue-i18n": "^11.0.1",
-    "@tsconfig/node24": "^24.0.2",
-    "@types/lodash-es": "^4.17.12",
-    "@types/node": "^24.10.1",
-    "@typescript-eslint/eslint-plugin": "^8.37.0",
-    "@vitejs/plugin-legacy": "^7.2.1",
-    "@vitejs/plugin-vue": "^6.0.1",
-    "@vue/eslint-config-prettier": "^10.2.0",
-    "@vue/eslint-config-typescript": "^14.6.0",
-    "@vue/tsconfig": "^0.8.1",
-    "autoprefixer": "^10.4.21",
-    "eslint": "^9.31.0",
-    "eslint-config-prettier": "^10.1.5",
-    "eslint-plugin-prettier": "^5.5.1",
-    "eslint-plugin-vue": "^10.5.1",
-    "postcss": "^8.5.6",
-    "prettier": "^3.6.2",
-    "terser": "^5.43.1",
-    "typescript": "^5.9.3",
-    "vite": "^7.2.2",
-    "vite-plugin-compression2": "^2.3.1",
-    "vue-tsc": "^3.1.3"
-  },
-  "packageManager": "pnpm@10.28.0+sha512.05df71d1421f21399e053fde567cea34d446fa02c76571441bfc1c7956e98e363088982d940465fd34480d4d90a0668bc12362f8aa88000a64e83d0b0e47be48"
-}

frontend/postcss.config.cjs

@@ -1,5 +0,0 @@
-module.exports = {
-  plugins: {
-    autoprefixer: {},
-  },
-};