## 1. Project Overview & Quickstart (LycheeOrg/Contribute) ## 1. Project Overview & Quickstart (LycheeOrg/Contribute) # Contribute Open-source repository LycheeOrg/Contribute ### Repository Details - **Repository:** [LycheeOrg/Contribute](https://github.com/LycheeOrg/Contribute) - **Primary Language:** Code *Note: High-volume repository documentation is actively indexed and synchronized by YakaAI.* ## 2. Official Technical Reference & Guides (LycheeOrg/LycheeOrg.github.io) # lycheeorg.dev [ [ ## Dependencies - GNU Make - npm - Python 3 (because I don't like Python 2.7) - git ## Setup - [Install Python 3.x](https://www.python.org/downloads/) - [Install pip](https://pip.pypa.io/en/stable/installing/) - [Install npm](https://nodejs.org/en/download/package-manager) - Install dependencies: ```sh npm install pip install -r requirements.txt ``` ## Local dev In order to get the visual feedback of the website (without docs), you can run a local version: ```sh npm run dev # Open http://localhost:4321/ ``` # Generating Run `make` to generate the HTML files, which can then be found in `dist/`. [build-status-shield]: https://img.shields.io/github/actions/workflow/status/LycheeOrg/LycheeOrg.github.io/CI.yml?branch=master [image-status-shield]: https://img.shields.io/github/actions/workflow/status/LycheeOrg/LycheeOrg.github.io/Docker.yml?branch=master ## 2. Official Technical Reference & Guides (LycheeOrg/LycheeOrg.github.io) ## File: README.md # lycheeorg.dev [ [ ## Dependencies - GNU Make - npm - Python 3 (because I don't like Python 2.7) - git ## Setup - [Install Python 3.x](https://www.python.org/downloads/) - [Install pip](https://pip.pypa.io/en/stable/installing/) - [Install npm](https://nodejs.org/en/download/package-manager) - Install dependencies: ```sh npm install pip install -r requirements.txt ``` ## Local dev In order to get the visual feedback of the website (without docs), you can run a local version: ```sh npm run dev # Open http://localhost:4321/ ``` # Generating Run `make` to generate the HTML files, which can then be found in `dist/`. [build-status-shield]: https://img.shields.io/github/actions/workflow/status/LycheeOrg/LycheeOrg.github.io/CI.yml?branch=master [image-status-shield]: https://img.shields.io/github/actions/workflow/status/LycheeOrg/LycheeOrg.github.io/Docker.yml?branch=master --- ## File: AGENTS.md # AstroWind Agent Instructions ## Project Overview AstroWind is a free, open-source website template built with **Astro v6** and **Tailwind CSS v4**. It generates a fully static site optimized for performance, SEO, and accessibility. **Stack:** Astro v6 | Tailwind CSS v4 | TypeScript 5.9 | MDX | Sharp ## Quick Reference | Command | Purpose | | ----------------- | ----------------------------------- | | `npm run dev` | Start dev server at localhost:4321 | | `npm run build` | Production build to `./dist/` | | `npm run preview` | Preview production build locally | | `npm run check` | Run astro check + ESLint + Prettier | | `npm run fix` | Auto-fix ESLint + Prettier issues | **Node.js requirement:** >= 22.12.0 ## Architecture ### Directory Structure ``` src/ assets/styles/tailwind.css # Tailwind v4 config (themes, utilities, plugins) components/ common/ # Shared: Image, Metadata, Analytics, ToggleTheme ui/ # Primitives: Button, Headline, WidgetWrapper, ItemGrid widgets/ # Page sections: Hero, Features, Pricing, Header, Footer blog/ # Blog: SinglePost, List, Pagination, Tags CustomStyles.astro # CSS variables for colors and fonts content.config.ts # Content Collections schema (Astro v6 location) data/post/ # Blog posts (.md, .mdx) layouts/ # Layout.astro, PageLayout.astro, MarkdownLayout.astro pages/ # File-based routing utils/ # blog.ts, images.ts, permalinks.ts, frontmatter.ts config.yaml # Site configuration (loaded as virtual module) navigation.ts # Navigation structure types.d.ts # TypeScript type definitions vendor/integration/ # Custom Astro integration for config loading ``` ### Path Aliases Use `~/` to import from `src/`: ```typescript import Image from '~/components/common/Image.astro'; import { SITE } from 'astrowind:config'; ``` ### Configuration System Site config lives in `src/config.yaml` and is loaded as a Vite virtual module `astrowind:config` by the custom integration in `vendor/integration/`. Exports: `SITE`, `I18N`, `METADATA`, `APP_BLOG`, `UI`, `ANALYTICS`. ## Tailwind CSS v4 Configuration is CSS-first in `src/assets/styles/tailwind.css`: - **Theme tokens:** `@theme { --color-primary: var(--aw-color-primary); ... }` - **Custom utilities:** `@utility bg-page { ... }` - **Dark mode:** Class-based via `@variant dark (&:where(.dark, .dark *))` - **Plugins:** `@plugin "@tailwindcss/typography"` - **Custom variant:** `@custom-variant intersect (&:not([no-intersect]))` CSS variables for colors/fonts are defined in `src/components/CustomStyles.astro` with light/dark theme variants. The Vite plugin `@tailwindcss/vite` is configured in `astro.config.ts` (not as an Astro integration). ### Class Merging Components use `twMerge` from `tailwind-merge` v3 for conditional class composition. ## Content Collections Defined in `src/content.config.ts` using the Astro v6 Content Layer API with `glob()` loader. Posts are in `src/data/post/` as `.md` or `.mdx` files. Post frontmatter: `title` (required), `publishDate`, `updateDate`, `draft`, `excerpt`, `image`, `category`, `tags`, `author`, `metadata`. ## Component Patterns - Props extend interfaces from `~/types` - Use `class:list` for conditional classes - Use `twMerge()` when accepting className overrides - Use named slots for layout composition - Widget components accept standardized props (see `~/types`) ## Image Handling `src/components/common/Image.astro` supports: - Local images via `astro:assets` (optimized by Sharp) - Remote images via Unpic CDN - Allowed domains (for providers Unpic can't detect, processed by Sharp): `cdn.pixabay.com` Hero images use `loading="eager"` and `fetchpriority="high"`. ## Verification Checklist After changes, always verify: 1. `npm run build` succeeds 2. `npm run check` passes (astro check + ESLint + Prettier) 3. Visual check in browser: homepage, blog, dark mode, mobile menu --- ## File: CLAUDE.md # Claude Code Configuration See [AGENTS.md](./AGENTS.md) for all project documentation and AI agent instructions. --- ## File: LICENSE.md MIT License Copyright (c) 2018-2024 LycheeOrg Copyright (c) 2023 onWidget (for astro parts) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. --- ## File: package.json { "name": "@onwidget/astrowind", "version": "1.0.0-beta.63", "description": "AstroWind: A free template using Astro 6 and Tailwind CSS v4. Astro starter theme.", "type": "module", "private": true, "engines": { "node": ">=22.12.0" }, "scripts": { "dev": "astro dev", "start": "astro dev", "build": "astro build", "preview": "astro preview", "astro": "astro", "check": "npm run check:astro && npm run check:eslint && npm run check:prettier", "check:astro": "astro check", "check:eslint": "eslint .", "check:prettier": "prettier --check .", "fix": "npm run fix:eslint && npm run fix:prettier", "fix:eslint": "eslint --fix .", "fix:prettier": "prettier -w ." }, "dependencies": { "@astrojs/markdown-satteri": "^0.4.2", "@astrojs/rss": "^4.0.19", "@astrojs/sitemap": "^3.7.3", "@astrojs/starlight": "^0.42.5", "@astrojs/starlight-tailwind": "^5.0.0", "@fontsource-variable/inter": "^5.2.8", "astro": "^7.3.3", "astro-embed": "^0.13.0", "astro-icon": "^1.1.5", "astro-seo": "^1.1.0", "limax": "4.2.3", "lodash.merge": "^4.6.2", "prismjs": "^1.30.0", "satteri": "^0.10.5", "unpic": "^4.2.2" }, "devDependencies": { "@astrojs/check": "^0.9.9", "@astrojs/mdx": "^8.0.2", "@astrojs/partytown": "^2.1.7", "@eslint/js": "^10.0.1", "@iconify-json/flat-color-icons": "^1.2.3", "@iconify-json/tabler": "^1.2.35", "@tailwindcss/typography": "^0.5.19", "@tailwindcss/vite": "^4.3.0", "@types/js-yaml": "^4.0.9", "@types/lodash.merge": "^4.6.9", "@types/mdx": "^2.0.13", "@types/prismjs": "^1.26.5", "@typescript-eslint/eslint-plugin": "^8.60.0", "@typescript-eslint/parser": "^8.60.0", "astro-compress": "^2.4.1", "astro-eslint-parser": "^1.4.0", "eslint": "^10.4.0", "eslint-plugin-astro": "^1.7.0", "globals": "^17.6.0", "js-yaml": "^4.3.2", "prettier": "^3.8.3", "prettier-plugin-astro": "^0.14.1", "reading-time": "^1.5.0", "sharp": "0.35.4", "tailwind-merge": "^3.6.0", "tailwindcss": "^4.3.0", "typescript": "^5.9.3", "typescript-eslint": "^8.60.0" }, "overrides": { "yaml": ">=2.8.3" } } --- ## File: sandbox.config.json { "infiniteLoopProtection": true, "hardReloadOnChange": false, "view": "browser", "template": "node", "container": { "port": 3000, "startScript": "start", "node": "18" } } --- ## File: tsconfig.json { "extends": "astro/tsconfigs/base", "compilerOptions": { "strictNullChecks": true, "allowJs": true, "baseUrl": ".", "paths": { "~/*": ["src/*"] } }, "include": [".astro/types.d.ts", "**/*"], "exclude": ["dist/"] } --- ## File: vscode.tailwind.json { "version": 1.1, "atDirectives": [ { "name": "@tailwind", "description": "@tailwind tailwindcss" }, { "name": "@layer", "description": "@layer tailwindcss" }, { "name": "@apply", "description": "@apply tailwindcss" } ] } --- ## File: public/robots.txt User-agent: * Disallow: --- ## File: public/decapcms/config.yml backend: name: github repo: LycheeOrg/LycheeOrg.github.io # Path to your GitHub repository media_folder: 'src/assets/images' public_folder: '/_astro' collections: - name: 'post' label: 'Post' folder: 'src/content/post' create: true fields: - { label: 'Title', name: 'title', widget: 'string' } - { label: 'Excerpt', name: 'excerpt', widget: 'string' } - { label: 'Category', name: 'category', widget: 'string' } - { label: 'Tags', name: 'tags', widget: 'list', allow_add: true, allow_delete: true, collapsed: false, field: { label: 'Tag', name: 'tag', widget: 'string' }, } - { label: 'Image', name: 'image', widget: 'string' } - { label: 'Publish Date', name: 'publishDate', widget: 'datetime', required: false } - { label: 'Author', name: 'author', widget: 'string' } - { label: 'Content', name: 'body', widget: 'markdown' } --- ## File: src/config.yaml site: name: Lychee site: 'https://lycheeorg.dev' base: '/' trailingSlash: ignore # googleSiteVerificationId: orcPxI47GSa-cRvY11tUe6iGg2IO_RPvnA1q95iEM3M # Default SEO metadata metadata: title: default: Lychee template: 'Lychee - %s' robots: index: true follow: true openGraph: site_name: Lychee images: - url: '~/assets/images/og.jpg' width: 1200 height: 628 type: website # twitter: # handle: '@onwidget' # site: '@onwidget' # cardType: summary_large_image i18n: language: en textDirection: ltr apps: blog: isEnabled: true postsPerPage: 10 post: isEnabled: true permalink: '/%slug%' # Variables: %slug%, %year%, %month%, %day%, %hour%, %minute%, %second%, %category% robots: index: true list: isEnabled: true pathname: 'blog' # Blog main path, you can change this to "articles" (/articles) robots: index: true category: isEnabled: true pathname: 'category' # Category main path /category/some-category, you can change this to "group" (/group/some-category) robots: index: true tag: isEnabled: true pathname: 'tag' # Tag main path /tag/some-tag, you can change this to "topics" (/topics/some-category) robots: index: false isRelatedPostsEnabled: true relatedPostsCount: 4 # analytics: # vendors: # googleAnalytics: # id: null # or "G-XXXXXXXXXX" ui: theme: 'system' # Values: "system" | "light" | "dark" | "light:only" | "dark:only" --- ## File: src/content/docs/docs/administration/advanced-setups.md --- title: "Advanced Setups" sidebar: order: 3 --- In this page we describe additional ways to install and potentially to develop on Lychee. ## Separating Data from the Code As described in issue #486, LudovicRousseau proposes a solution to separate your photos from the Lychee code. He splits Lychee itself and the pictures into 2 directories: - `Lychee` with the code of Lychee - `Lychee-data` containing: ``` Lychee-data/ └── public ├── dist │   ├── fonts │   └── resources └── uploads ├── big ├── import ├── medium ├── raw ├── small └── thumb ``` - his `Lychee/.env` contains: ```ini LYCHEE_DIST="/var/www/Lychee-data/public/dist/" LYCHEE_UPLOADS="/var/www/Lychee-data/public/uploads/" ``` :::note Note that the **path needs to be absolute**. ::: The upgrade script when a new version of Lychee is available is simple: ```bash mv Lychee Lychee.old unzip Lychee.zip cp Lychee.old/.env Lychee chmod g+w -R Lychee/storage sudo chgrp www-data -R Lychee/storage cd Lychee php artisan key:generate php artisan migrate ``` It worked fine with the migration from 4.0.4 to 4.0.5 of Lychee. The hierarchy `Lychee-data/public/` is writeable by the group `www-data` so that apache process can modify the files. The files in `Lychee` are read only for apache. No write access needed. ## Other means of distributions In this section we present few out-of-the-box solutions providing Lychee. :::note Please note that we, at LycheeOrg, do not endorse any of the following solutions. ::: We give the reader a link to their websites as they provide our software. **You are free to use their installation, however we will not be providing you support with their solution**. ### With Linuxserver.io (Free) Linuxserver.io is a group of like minded enthusiasts from across the world who build and maintain the largest collection of Docker images on the web, and at our core are the principles behind Free and Open Source Software. Their primary goal is to provide easy-to-use and streamlined Docker images with clear and concise documentation. You can find the corresponding Lychee image [here](https://fleet.linuxserver.io/image?name=linuxserver/lychee). ### With Yunohost (Free) [Yunohost](https://yunohost.org/) is a simple operating system for self-hosting your applications. [Lychee is available from their app store](https://yunohost.org/de/app_lychee) and can be installed by clicking [this installation link](https://install-app.yunohost.org/?app=lychee). You can find the source code of the app under . ### With Cloudron (Paid) Cloudron is a complete solution for running apps on your server and keeping them up-to-date and secure. [](https://cloudron.io/store/com.electerious.lychee.cloudronapp.html) The source code for the package can be found [here](https://git.cloudron.io/cloudron/lychee-app). See their pricing [here](https://cloudron.io/pricing.html). ### With alwaysdata (Paid) alwaysdata.com is a modern hosting platform allowing you to host all your services in one place: files, emails, sites, media, databases, workers, etc. You can use their Marketplace to [install Lychee](https://www.alwaysdata.com/en/marketplace/lychee/) and have your own instance available (with HTTPS) within a minute! See their pricing [here](https://www.alwaysdata.com/en/). ### With Kubernetes (Free) You can use a Community maintained Helmchart to deploy Lychee into your Kubernetes Cluster. Have a look at the [Repository](https://github.com/breuerfelix/lychee-helmchart) for installation instructions. Feel free to open an [Issue](https://github.com/breuerfelix/lychee-helmchart/issues) if you need help. ### With Portainer on Synology (Free~ish) [Marius Bogdan Lixandru](https://mariushosting.com/author/marius/) made a great post of how to set up your Lychee installation on your Synology NAS with Portainer. Read at it [here](https://mariushosting.com/how-to-install-lychee-on-your-synology-nas/). ### With Zenith (Paid) Zenith provides one-click managed hosting for open-source apps, so you can bring up a fully managed Lychee instance in minutes without any server setup. [](https://zenith.hosting/host/lychee) You can find their Lychee offering [here](https://zenith.hosting/host/lychee). ## Implementing Object Storage An S3-compatible object storage solution is designed to store, manage, and access unstructured data in the cloud. Under Object Storage, files (also called objects) are stored in flat data structures (referred to as buckets) alongside their own rich metadata. Due to the nature of Object Storage, it does not require the use of a Compute Instance. Instead, Object Storage gives each object a unique URL with which you can access the data. ### Limitations - Upload file size limit: 5 GB - All recursive tasks including (search, find, ls, etc.) have poor performance due to network latency ### S3 Object Storage Setup The instructions in this guide are based on CentOS/Fedora/RHEL family, but it is easy to replicate the commands into any other distro. **Install s3fs FUSE-base file system** s3fs allows Linux and other OS's to mount an S3 bucket via FUSE (Filesystem in Userspace). s3fs makes you operate files and directories in S3 bucket like a local file system. [s3fs-fuse - Instructions from developer](https://github.com/s3fs-fuse/s3fs-fuse) ```bash sudo dnf install s3fs-fuse sudo echo ACCESS_KEY_ID:SECRET_ACCESS_KEY > /etc/passwd-s3fs sudo chmod 600 /etc/passwd-s3fs ``` **Configure SELinux to allow access to the new filesystem** ```bash setsebool -P httpd_use_fusefs 1 ``` **Setup a permanent mounting point** Create S3 Object mount point: ```bash sudo mkdir /mnt/bucket ``` Edit fstab to create a new mount on boot: Add the following line to: `/etc/fstab` ```bash /mnt/bucket fuse.s3fs _netdev, allow_other, enable_noobj_cache, url=, use_cache="", passwd_file=/etc/passwd-s3fs, mp_umask=0002 0 0 ``` Example: - mybucket (name used in your cloud provider) - https://eu-central-1.linodeobjects.com Parameters are explained below: - `allow_other` Allow other users to access the bucket - `mp_umask` Mask permissions for mount point - `enable_noobj_cache` Performance improvement - Enable when bucket is exclusively used by s3fs - `use_cache=""` Disabled - `use_cache=/var/cache/s3fs` Enabled (to be used with care, because the cache can grow out of control. Also, I haven't noticed much difference using it) Reboot your server to confirm S3 Object Storage is mounted correctly. Create Lychee's mount point: ```bash sudo mkdir /mnt/bucket/uploads ``` ### Create and run Lychee container From now on, Lychee will see the Object Storage mount transparently like any other mount. The container's volume `/uploads` needs to point to the new created mount: ```bash sudo podman run --rm -d --name myphotos -v /mnt/bucket/uploads:/uploads -e PUID=33 -e PGID=1000 ... docker.io/lycheeorg/lychee ``` ### Configure .ENV To avoid latency when clicking Diagnostics, my suggestion is to disable BasicPermissionCheck. Otherwise, depending on the number of photos in your gallery, this task can take hours. ```bash # /var/lib/containers/storage/volumes/lychee-conf/_data/.env SKIP_DIAGNOSTICS_CHECKS=BasicPermissionCheck ``` ### Limitations to be considered As explained before, recursive tasks are penalised in Object Storage, so if you have an existing bucket and the container runs for the first time, it will take long time to review and set the permissions in your mount. Depending on the number of photos, it can take several hours. ## Hosting Lychee in a subpath with Apache To serve Lychee in a subpath, e.g. `https://my.url/photos/`, we can use Apaches's [Alias](https://httpd.apache.org/docs/2.4/mod/mod_alias.html#alias)-directive. In this example we assume the web root to be located at `/var/www/html`, the web user and group to be `www-data`, and install [from the master branch](/docs/getting-started/manual-installation/#from-source). Before getting started, make sure your system qualifies the [Server Requirements](/docs/getting-started/manual-installation/#server-requirements). ### Setup Lychee Clone the repository to outside the web root, e.g. `/var/www/`: ```bash sudo git clone https://www.github.com/LycheeOrg/Lychee /var/www/ ``` Set the file ownership and permissions: ```bash sudo chown -R www-data:www-data /var/www/Lychee sudo chmod -R 2775 /var/www/Lychee ``` Install composer in `/var/www/Lychee` as instructed in [here](https://getcomposer.org/download/). Then, from `/var/www/Lychee`, install the project dependencies: ```bash sudo -u www-data php composer.phar install --no-dev ``` ### Setup Apache Link `https://my.url/photos/` to `/var/www/Lychee/public` by adding the following to your Apache configuration for Aliases. In Apache 2.4 running on Debian, the correct configuration file is `/etc/apache2/mods-available/alias.conf`. ```apache Alias /photos /var/www/Lychee/public Options FollowSymLinks AllowOverride All Require all granted ``` Finally, restart Apache: ```bash sudo service apache2 restart ``` ### Configure Lychee At this point, you should be able to go to `https://my.url/photos/` and run the web installer. During the installation procedure, on top of adding the database credentials to match your setup, set your `APP_URL` to the served subdirectory: ```bash APP_URL=https://my.url/photos/ ``` Done! --- ## File: src/content/docs/docs/administration/api.md --- title: "API" sidebar: order: 6 --- The current API provide the following entry points: See: - [routes/api_v2.php](https://github.com/LycheeOrg/Lychee/blob/master/routes/api_v2.php) - [routes/web-admin-v2.php](https://github.com/LycheeOrg/Lychee/blob/master/routes/web-admin-v2.php) - [routes/web_v2.php](https://github.com/LycheeOrg/Lychee/blob/master/routes/web_v2.php) Note that for all request, **'Accept: application/json' is mandatory** and that without mention of the contrary **'Content-Type: application/json' is also mandatory**. As of version 4.8.1, the api documentation is moved directly inside your own Lychee instance. It is accessible at the url `https://yourLycheeInstance.org/docs/api`. It is also possible to see it on our demo website: [https://demo.lycheeorg.dev/docs/api](https://demo.lycheeorg.dev/docs/api) ## Authentication and CSRF Lychee protects all stateful (cookie/session based) requests with Laravel's standard CSRF protection. This is what your browser uses automatically when you are logged in and is required for `POST`, `PUT`, `PATCH` and `DELETE` requests coming from a session. When you script against the API (e.g. with `curl`, Python, or any external tool) you generally do not have a browser session or the associated CSRF cookie/header, so plain session-based requests will be rejected with a `419` error. To avoid dealing with CSRF for such use cases, Lychee lets you authenticate with a personal **API token** instead. Any request that carries a valid `Authorization: Bearer ` header is treated as token-authenticated and skips CSRF verification entirely, regardless of the HTTP verb used. ### Generating a token 1. Log in to your Lychee instance and open **Settings → Profile**. 2. In the **API Token** section, click **Create token** (or **Reset token** if one already exists). 3. Copy the token immediately — for security reasons it is only ever shown once and cannot be retrieved again later. 4. You can revoke the token at any time from the same dialog with **Disable token**. Resetting the token also invalidates the previous one. ### Using the token Send the token as a Bearer token in the `Authorization` header of your requests: ```bash curl -X POST 'https://yourLycheeInstance.org/api/v2/Albums' \ -H 'Accept: application/json' \ -H 'Content-Type: application/json' \ -H 'Authorization: Bearer ' ``` :::caution An API token grants full access to your account. Treat it like a password: never commit it to source control and revoke it immediately if you suspect it has leaked. ::: --- ## File: src/content/docs/docs/administration/external-tracking.md --- title: "External Tracking" sidebar: order: 4 --- This guide will help you to set up Matomo, Google Analytics or other analytics tools with Lychee. > ⚠️ Make sure to use your actual values for domain and siteId ### Allow loading tracking script Set the following env vars: ```ini SECURITY_HEADER_SCRIPT_SRC_ALLOW=https://analytics.example.com/matomo.js SECURITY_HEADER_CSP_CONNECT_SRC=https://analytics.example.com/matomo.php ``` ### Add custom JavaScript Add the following to Settings > Advanced Customization ```javascript var _paq = window._paq = window._paq || []; _paq.push(['trackPageView']); _paq.push(['enableLinkTracking']); (function () { var u = "https://analytics.example.com/"; _paq.push(['setTrackerUrl', u + 'matomo.php']); _paq.push(['setSiteId', '']); var d = document, g = d.createElement('script'), s = d.getElementsByTagName('script')[0]; g.async = true; g.src = u + 'matomo.js'; s.parentNode.insertBefore(g, s); })(); navigation.addEventListener("navigate", function (e) { _paq.push(['setDocumentTitle', document.title]); _paq.push(['trackPageView']); }); ``` ## Set up for Medama > ⚠️ Make sure to use your actual domain ### Allow loading tracking script Set the following env vars: ```ini SECURITY_HEADER_SCRIPT_SRC_ALLOW=https://analytics.example.com SECURITY_HEADER_CSP_CONNECT_SRC=https://analytics.example.com/script.js ``` ### Add custom JavaScript Add the following to Settings > Advanced Customization ```javascript const script = document.createElement('script'); script.setAttribute('defer', true); script.setAttribute('src', 'https://analytics.example.com/script.js'); document.body.appendChild(script); ``` ## Set up for Google Analytics > ⚠️ Make sure to replace <your-tracking-id> with the actual value ### Allow loading tracking script Set the following env vars: ```ini SECURITY_HEADER_SCRIPT_SRC_ALLOW=https://www.googletagmanager.com/gtag/js?id= SECURITY_HEADER_CSP_CONNECT_SRC=https://www.googletagmanager.com/gtag/js?id= ``` ### Add custom JavaScript Add the following to Settings > Advanced Customization ```javascript (function () { var u = "https://www.googletagmanager.com/gtag/js"; var d = document, g = d.createElement('script'), s = d.getElementsByTagName('script')[0]; g.async = true; g.src = u + '?id='; s.parentNode.insertBefore(g, s); })(); window.dataLayer = window.dataLayer || []; function gtag(){ dataLayer.push(arguments); } function trackPageView() { gtag('event', 'page_view', { page_title: document.title, page_location: window.location }); } gtag('js', new Date()); gtag('config', '', { send_page_view: false }); trackPageView(); navigation.addEventListener("navigate", function (e) { trackPageView() }); ``` ## Set up for Umami Analytics > ⚠️ Make sure to use your actual values for DOMAIN SCRIPT URL and ### Allow loading tracking script Set the following env vars: ```ini SECURITY_HEADER_SCRIPT_SRC_ALLOW=https://umami.example.com/script.js SECURITY_HEADER_CSP_CONNECT_SRC=https://umami.example.com/script.js ``` ### Add custom JavaScript Add the following to Settings > Advanced Customization ```javascript (function() { var d = document, s = d.createElement('script'), g = d.getElementsByTagName('script')[0]; s.defer = true; s.src = 'https://umami.example.com/script.js'; s.setAttribute('data-website-id', ''); g.parentNode.insertBefore(s, g); })(); navigation.addEventListener("navigate", function (e) { if (window.umami && typeof umami.trackView === 'function') { umami.trackView(document.title, window.location.pathname); } }); ``` ## Other tools / custom tracking ### Configuration adjustments To make the frontend load the tracking script you need to change two environment variables: - SECURITY_HEADER_SCRIPT_SRC_ALLOW to modify the header [`CSP: srcript-src`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/script-src) - SECURITY_HEADER_CSP_CONNECT_SRC to modify the header [`CSP: connect-src`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/connect-src) ### Track view changes Add your custom tracking code to Settings > Custom JS As Lychee uses history based routing you need to track page changes on the `navigate event` like this: ```javascript navigation.addEventListener("navigate", function (e) { // track page logic goes here }); ``` --- ## File: src/content/docs/docs/administration/honeypot.md --- title: "Honeypot & Fail2Ban" sidebar: order: 5 --- If you have had a look at your logs, you will notice that you get quite a few requests to pages that do not exists such as `wp-admin.php` _etc._ Those are automatic queries done by vulnerability crawlers. This kind of trafic does not provide any value to the user and does not concern us. For this reason, Lychee provides an honeypot. If a user/robot/script queries one of the selected urls (honey) used by those vulnerability scanners, it will get a 418 response code. This response is logged in Nginx/Apache, and we use [fail2ban](https://www.fail2ban.org/) to get rid of subsequent requests. ## What is Fail2ban? Fail2ban is a small service that can be run on your server to dynamically block clients before a request is executed. It uses firewall rules to do so. After a certain amount of time (e.g. 1 day), the blocking rule is removed. :::note It will also ban you from your own website if you do a bad request. ::: ## Setting up Fail2Ban. :::tip **Fail2ban is not provided with Lychee**. It is an additional software that you will need to [install it yourself](https://www.fail2ban.org/wiki/index.php/Downloads). ::: ### Setup the Filter Create `/etc/fail2ban/filter.d/filter-honeypot.conf` with: ```ini [Definition] failregex = ^.*"(GET|POST).*" (418) .*$ ignoreregex = ``` This defines which regex to use to filter the log files. From this regex, we retrieve the host if the response matches code 418 which is returned by Lychee when the honey is touched. ### Setup the Jail Then we need to create the jail in: `/etc/fail2ban/jail.d/honeypot.conf` If you are using apache then the following will work: ```ini [apache-honeypot] enabled = true filter = filter-honeypot port = http,https logpath = /var/log/apache2/access.log maxretry = 1 ``` In the case of Nginx: ```ini [apache-honeypot] enabled = true filter = filter-honeypot port = http,https logpath = /var/log/nginx/access.log maxretry = 1 ``` `maxretry` is set to 1 because we do not need to second guess those errors. Fail2ban is also used to ban ssh attempts after multiple failures, in such case a higher number of retry is need. As we interact with a honeypot, any behaviour touching it is therefore malicious, there are no false positive in our case and we do not give the benefit of the doubt. --- ## File: src/content/docs/docs/administration/update.md --- title: "Updating Lychee" sidebar: order: 1 --- The way you can update Lychee depends on how you did your installation: * If you used Docker, go to [Using Docker compose](#using-docker-compose) * If you used the release channel (downloading a zip file), go to [Update manually](#update-manually) * If you installed via `git clone`, go to [Update using Git](#update-using-git) - Your system must comply with the latest [system requirements](/docs/getting-started/installation/) of the latest version of Lychee. - Ensure that you are using the version 4 of Lychee. Updates from older version of Lychee are more complex. Don't forget to take a look at the [Changelog](/docs/getting-started/releases/) to see what's new and to check for any actions that may be required. ## Using Docker compose There are two cases. Either you are pinned to a release tag, _e.g._ v5.1.2 or you are using a rolling update tag. :::tip When using docker, a version rollback is difficult to apply: it requires to bash into the container to run the required migrate commands on the new version before dropping the tag to the previous value. ::: #### With Rolling update tag This procedure is for those following one of those tags: - `latest` — the last official release - `edge` or `master` — the last build from the `master` branch Simply run the following. ```bash docker compose down docker compose pull docker compose up -d ``` The database migrations will be applied automatically. #### With version tag. First edit your `docker-compose.yml` to point to the version you would like to migrate to. ```diff - image: lycheeorg/lychee:v5.1.0 + image: lycheeorg/lychee:v5.1.2 ``` Save and run the following. ```bash docker compose down docker compose pull docker compose up -d ``` The migration will be applied automatically and you should be running the requested tagged version. ## Update manually This update will be the one you have to use if you are following the Release channel. 1. Download the [newest Version](https://github.com/LycheeOrg/Lychee/releases) 2. Replace all existing files, excluding `public/uploads/`, `public/dist/user.css` and `.env` (and `database/database.sqlite` if using **SQLite** as your database) 3. Go into the `Diagnostic` page (this will mostly happen automatically) and click on the `Apply migration` button. Note: if using `rsync` to upload stuff to the web server, something like this might be used: ```bash rsync -vrtz --delete --chmod=Du=rwx,Dg=rx,Do=rx,Fu=rw,Fg=r,Fo=r --exclude=public/uploads/ --exclude=public/dist/user.css --exclude=.env --exclude=database/database.sqlite Lychee/ user@web.server.web:~/www/your_path_to/lychee/ ``` ## Update using Git Fully updating Lychee with `git` is the easiest way: ```bash # download the lastst files git pull # update composer dependencies composer install --no-dev # apply the database migration php artisan migrate # update Node.js dependencies npm install # generate frontend assets npm run build ``` If you have the `post-merge` hook set up the following is enough: ```bash git pull ``` --- ## File: src/content/docs/docs/administration/upgrade.md --- title: "Upgrading to version 7" sidebar: order: 2 --- :::note **Critical Breaking Changes**: Version 7 introduces significant architectural changes to the Docker setup. **You must update your docker-compose configuration** when upgrading from v6 to v7. Simply changing the image tag will not work. ::: ### Major Changes in Version 7 Version 7 marks a fundamental shift in Lychee's Docker architecture: 1. **FrankenPHP replaces nginx + PHP-FPM**: The application now runs on FrankenPHP with Laravel Octane for dramatically improved performance 2. **Simplified volume mounts**: Individual directory mounts have been consolidated into cleaner volume structures 3. **Optional worker service**: Background job processing can now be scaled independently 4. **New environment variables**: Worker mode configuration requires specific settings Do note that this change also has consequences in the way Lychee reads your `.env` file. Updating values in the `.env` file will now require a container restart to take effect. ### Port change Version 7 uses FrankenPHP which listens on port `8000` instead of the previous `80` used by nginx. Make sure to update your port mappings accordingly in your `docker-compose.yml`. ### Volume Mount Changes In order to avoid you running into issues while booting version 7, we are blocking the startup of the container if the old volume structure is detected. #### Version 6 Volume Structure (OLD) ```yaml volumes: - ./lychee/conf:/conf - ./lychee/uploads:/uploads - ./lychee/sym:/sym - ./lychee/logs:/logs - ./lychee/tmp:/lychee-tmp ``` #### Version 7 Volume Structure (NEW) ```yaml volumes: - ./lychee/uploads:/app/public/uploads - ./lychee/logs:/app/storage/logs - ./lychee/tmp:/app/storage/tmp # so that uploads are not filling up the memory of the container - ./lychee/storage/app:/app/storage/app # OPTIONAL: for persistent storage of app data - ./conf/user.css:/app/public/dist/user.css # OPTIONAL - ./conf/custom.js:/app/public/dist/custom.js # OPTIONAL ``` :::note Notice the key changes: uploads are now at `/app/public/uploads`, logs at `/app/storage/logs`, tmp at `/app/storage/tmp`, and the `.env` file. ::: The `/sym` volume has been removed as Lychee no longer uses symbolic links for storage. This was a security feature that originated from version 4, but is no longer necessary as the functionality has been removed. **Important:** With multiple volumes under `/app/storage`, you may think you could simplify the configuration by specifying one single volume for `/app/storage` instead. This is incorrect. Doing so will make the app exit with the error "The `/app/bootstrap/cache` directory must be present and writable." ### Service Architecture Changes Version 7 introduces a multi-service architecture with an optional worker service for background job processing. #### Basic Setup (Single Service) For basic installations without background workers: ```yaml services: lychee_api: image: ghcr.io/lycheeorg/lychee:edge container_name: lychee ports: - "${APP_PORT:-8000}:8000" volumes: - ./lychee/uploads:/app/public/uploads - ./lychee/logs:/app/storage/logs - ./lychee/tmp:/app/storage/tmp environment: - DB_CONNECTION=mysql - DB_HOST=lychee_db - DB_PORT=3306 - DB_DATABASE=lychee - DB_USERNAME=lychee - DB_PASSWORD=your_password # ... other environment variables depends_on: - lychee_db networks: - lychee ``` #### Advanced Setup (With Workers) For better performance with background job processing: ```yaml services: lychee_api: image: ghcr.io/lycheeorg/lychee:edge container_name: lychee ports: - "${APP_PORT:-8000}:8000" volumes: - ./lychee/uploads:/app/public/uploads - ./lychee/logs:/app/storage/logs - ./lychee/tmp:/app/storage/tmp environment: - DB_CONNECTION=mysql - DB_HOST=lychee_db - QUEUE_CONNECTION=database # CRITICAL for worker mode # ... other environment variables depends_on: - lychee_db networks: - lychee lychee_worker: image: ghcr.io/lycheeorg/lychee:edge container_name: lychee_worker volumes: - ./lychee/uploads:/app/public/uploads - ./lychee/logs:/app/storage/logs - ./lychee/tmp:/app/storage/tmp environment: - LYCHEE_MODE=worker # CRITICAL: Tells container to run in worker mode - DB_CONNECTION=mysql - DB_HOST=lychee_db - DB_PORT=3306 - DB_DATABASE=lychee - DB_USERNAME=lychee - DB_PASSWORD=your_password - QUEUE_CONNECTION=database # CRITICAL: Must match API service # ... other environment variables depends_on: - lychee_db - lychee_api networks: - lychee ``` :::note **Critical**: When using worker services, you **must** set `QUEUE_CONNECTION=database` (or `redis` if using Redis) in **both** the API and worker services. Without this, jobs will not be processed properly. ::: ### Worker Service Benefits The worker service provides several advantages: - **Parallel Processing**: Scale workers independently by running multiple instances - **Better Performance**: Offload heavy tasks (photo processing, imports) from the main API - **Resource Management**: Allocate different resources to API and workers #### Scaling Workers You can run multiple worker instances for parallel processing: ```yaml lychee_worker: image: ghcr.io/lycheeorg/lychee:edge deploy: replicas: 3 # Run 3 worker instances # ... rest of configuration ``` Or manually with different container names: ```yaml lychee_worker_1: image: ghcr.io/lycheeorg/lychee:edge container_name: lychee_worker_1 environment: - LYCHEE_MODE=worker # ... rest of configuration lychee_worker_2: image: ghcr.io/lycheeorg/lychee:edge container_name: lychee_worker_2 environment: - LYCHEE_MODE=worker # ... rest of configuration ``` ### Migration Steps Follow these steps to migrate from v6 to v7: #### 1. **Backup Everything** ```bash # Backup your database docker exec lychee_db mysqldump -u lychee -p lychee > lychee_backup.sql # Backup your uploads and configuration cp -r ./lychee ./lychee_backup ``` #### 2. **Stop Your Current v6 Services** ```bash docker-compose down ``` #### 3. **Update Your docker-compose.yml** Replace your v6 docker-compose.yml with the v7 configuration. You can find the complete example at: [https://github.com/LycheeOrg/Lychee/blob/master/docker-compose.yaml](https://github.com/LycheeOrg/Lychee/blob/master/docker-compose.yaml) #### 4. **Reorganize Your Volume Data** (if needed) If your current directory structure doesn't match the new volume mounts, reorganize: ```bash # The uploads directory structure should remain compatible # Ensure your uploads are in ./lychee/uploads/ ``` #### 5. **Update Environment Variables** Key changes to your environment configuration: - If using workers: Add `QUEUE_CONNECTION=database` or `QUEUE_CONNECTION=redis` - If using workers: Add `LYCHEE_MODE=worker` to worker service only - Review other environment variables for any deprecated options #### 6. **Start v7 Services** ```bash docker-compose up -d ``` #### 7. **Verify Installation** Check that all services are running: ```bash docker-compose ps ``` Check logs for errors: ```bash docker-compose logs -f lychee ``` #### 8. **Fix the thumbnails** You will notice that after the upgrade, thumbnails are missing. You can regenerate them by running: ```bash docker exec -it lychee php artisan lychee:recompute-album-sizes docker exec -it lychee php artisan lychee:recompute-album-stats ``` or by logging into the web interface and going to Settings ⇒ Maintenance ⇒ Album Precomputed Fields. ### Troubleshooting **Container keeps restarting** - Verify that you have APP_KEY properly set in your `.env` or `docker-compose.yml` if that is not the case you can run `echo "APP_KEY=base64:$(openssl rand -base64 32)"` to create a new one. **Workers not processing jobs** - Verify `QUEUE_CONNECTION=database` is set in both API and worker services - Verify `LYCHEE_MODE=worker` is set in worker service - Check worker logs: `docker-compose logs -f lychee_worker` **Upload issues** - Verify volume mounts point to the correct paths - Check file permissions on host directories - Ensure uploads directory: `./lychee/uploads` exists and is writable **Performance issues** - Consider adding worker services for background processing - Check FrankenPHP is running (should see FrankenPHP in logs, not nginx) - Verify `QUEUE_CONNECTION` is set for async job processing **Database connection errors** - Ensure database service name matches `DB_HOST` value - Verify database credentials are correct - Check database service is healthy: `docker-compose ps lychee_db` For more help, visit our [GitHub Discussions](https://github.com/LycheeOrg/Lychee/discussions) or [Discord server](https://discord.gg/y4aUbnF). ## Migrating from Traditional Installation to Docker Compose This guide helps you migrate an existing Lychee installation from a traditional setup (e.g., `/var/www/html/Lychee`) to a Docker Compose deployment. ### Prerequisites Before starting the migration, make sure you have docker compose installed. You can follow the instructions [here](https://docs.docker.com/compose/install/). ### Migration Steps #### 1. **Backup Your Current Installation** :::note **Critical**: Always create backups before migrating. This ensures you can restore your installation if anything goes wrong. ::: ```bash # Backup the database mysqldump -u your_db_user -p your_db_name > ~/lychee_db_backup.sql # Backup the entire Lychee directory cp -r /var/www/html/Lychee ~/lychee_backup # Backup your .env file specifically cp /var/www/html/Lychee/.env ~/lychee_env_backup ``` #### 2. **Create Docker Compose Directory Structure** Create a directory for your Docker Compose setup: ```bash mkdir -p ~/lychee-docker cd ~/lychee-docker # Create directories for volume mounts mkdir -p lychee/uploads mkdir -p lychee/storage/app mkdir -p lychee/logs mkdir -p lychee/tmp mkdir -p lychee/conf ``` #### 3. **Copy Your Data** Move your existing uploads and configuration: ```bash # Copy uploads (this may take time depending on your photo library size) sudo cp -r /var/www/html/Lychee/public/uploads/* ~/lychee-docker/lychee/uploads/ # Copy your .env configuration sudo cp /var/www/html/Lychee/.env ~/lychee-docker/lychee/conf/.env # If you have custom CSS or JavaScript sudo cp /var/www/html/Lychee/public/dist/user.css ~/lychee-docker/conf/user.css 2>/dev/null || true sudo cp /var/www/html/Lychee/public/dist/custom.js ~/lychee-docker/conf/custom.js 2>/dev/null || true # Set appropriate permissions sudo chown -R $USER:$USER ~/lychee-docker/lychee chmod -R 755 ~/lychee-docker/lychee ``` #### 4. **Create docker-compose.yml** Create a `docker-compose.yml` file in `~/lychee-docker`: ```yaml services: lychee_db: image: mariadb:11 container_name: lychee_db environment: - MYSQL_ROOT_PASSWORD=rootpassword - MYSQL_DATABASE=lychee - MYSQL_USER=lychee - MYSQL_PASSWORD=lychee_password volumes: - ./lychee/lychee_db:/var/lib/mysql networks: - lychee restart: unless-stopped lychee_api: image: ghcr.io/lycheeorg/lychee:latest container_name: lychee ports: - "8000:8000" # Change the first part XXXX:8000 this to your preferred port env_file: - ./lychee/conf/.env volumes: - ./lychee/uploads:/app/public/uploads - ./lychee/storage/app:/app/storage/app - ./lychee/logs:/app/storage/logs - ./lychee/tmp:/app/storage/tmp - ./lychee/conf/.env:/app/.env # Optional: Uncomment if you have custom CSS/JS # - ./conf/user.css:/app/public/dist/user.css # - ./conf/custom.js:/app/public/dist/custom.js environment: - APP_KEY=base64:YOUR_APP_KEY_HERE # Generate it with `openssl rand -base64 32` - DB_CONNECTION=mysql - DB_HOST=lychee_db - DB_PORT=3306 - DB_DATABASE=lychee - DB_USERNAME=lychee - DB_PASSWORD=lychee_password depends_on: - lychee_db networks: - lychee restart: unless-stopped networks: lychee: ``` #### 6. **Update Your .env File** Edit `~/lychee-docker/lychee/conf/.env` to update database connection settings: ```bash # Update these values to match your docker-compose.yml DB_CONNECTION=mysql DB_HOST=lychee_db DB_PORT=3306 DB_DATABASE=lychee DB_USERNAME=lychee DB_PASSWORD=lychee_password # Set the application URL APP_URL=http://your-domain.com:8000 # Update with your domain/IP ``` #### 7. **Import Your Database** Start the database container and import your data: ```bash cd ~/lychee-docker # Start only the database service docker-compose up -d lychee_db # Wait for the database to be ready (about 10-20 seconds) sleep 20 # Import your database backup docker exec -i lychee_db mysql -u lychee -plychee_password lychee < ~/lychee_db_backup.sql ``` #### 8. **Start Lychee** ```bash # Start all services docker-compose up -d # Check logs to ensure everything started correctly docker-compose logs -f lychee ``` Press `Ctrl+C` to exit log viewing. #### 9. **Configure Reverse Proxy (Optional)** If you're using a reverse proxy (recommended for production), configure it to forward to the Docker container. **Nginx Example:** ```nginx server { listen 80; server_name your-domain.com; location / { proxy_pass http://localhost:8000; proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header X-Forwarded-Proto $scheme; # For large photo uploads client_max_body_size 100M; } } ``` **Apache Example:** ```apache ServerName your-domain.com ProxyPreserveHost On ProxyPass / http://localhost:8000/ ProxyPassReverse / http://localhost:8000/ # For large photo uploads LimitRequestBody 104857600 ``` Enable required modules and restart: ```bash # For Apache sudo a2enmod proxy proxy_http sudo systemctl restart apache2 # For Nginx sudo systemctl restart nginx ``` #### 10. **Verify Migration** 1. Access Lychee at `http://your-domain.com` (or `http://your-domain.com:8000` if not using reverse proxy) 2. Log in with your existing credentials 3. Verify your photos and albums are displayed correctly 4. Check Settings ⇒ Diagnostics to ensure everything is working #### 11. **Optional: Add Worker Service** For better performance with large photo libraries, consider adding a worker service: ```yaml lychee_worker: image: ghcr.io/lycheeorg/lychee:latest container_name: lychee_worker volumes: - ./lychee/uploads:/app/public/uploads - ./lychee/storage/app:/app/storage/app - ./lychee/logs:/app/storage/logs - ./lychee/tmp:/app/storage/tmp - ./lychee/conf/.env:/app/.env:ro environment: - LYCHEE_MODE=worker - DB_CONNECTION=mysql - DB_HOST=lychee_db - DB_PORT=3306 - DB_DATABASE=lychee - DB_USERNAME=lychee - DB_PASSWORD=lychee_password - QUEUE_CONNECTION=database depends_on: - lychee_db - lychee_api networks: - lychee restart: unless-stopped ``` Also add `QUEUE_CONNECTION=database` to the `lychee_api` service environment variables, then restart: ```bash docker-compose up -d ``` ### Post-Migration Cleanup After confirming everything works correctly: ```bash # Disable the old web server from starting on boot sudo systemctl disable apache2 # or nginx # You can remove the old installation (keep the backup!) # sudo rm -rf /var/www/html/Lychee # Only after thorough testing! ``` ### Troubleshooting **Cannot access Lychee** - Check if containers are running: `docker ps` - Check logs: `docker logs lychee` - Verify port 8000 is not blocked by firewall - If using reverse proxy, check proxy configuration **Photos not showing** - Verify uploads were copied correctly: `ls -la ~/lychee-docker/lychee/uploads/` - Check volume mount permissions - Verify file paths in database match new structure **Database connection errors** - Confirm database container is running: `docker ps lychee_db` - Verify credentials in `.env` match `docker-compose.yml` - Check database logs: `docker logs lychee_db` **Permission errors** - Fix ownership: `sudo chown -R 33:33 ~/lychee-docker/lychee/` (33 is www-data UID/GID but can also be 82 for alpine) - Or make directories writable: `chmod -R 777 ~/lychee-docker/lychee/` (less secure) For additional help, visit our [GitHub Discussions](https://github.com/LycheeOrg/Lychee/discussions) or [Discord server](https://discord.gg/y4aUbnF). ## Upgrading from Lychee v3 to v4 ### Checking requirements Check that the server satisfies the [requirements](/docs/getting-started/manual-installation/#web-server-configuration). In particular pay attention the PHP extensions. You can display installed PHP extensions using `phpinfo()`. ### Preparing the files Assuming the following tree: ``` /var/ |- www/ |- html/ |- Lychee/ |- ``` Rename Lychee into Lychee-v3: ```bash mv Lychee Lychee-v3 ``` Install Lychee files by either uploading the content of the released zip or cloning the repository: ```bash git clone https://github.com/LycheeOrg/Lychee Lychee ``` Move the pictures from the version 3 to the newly created installation: ```bash mv Lychee-v3/uploads/big/* Lychee/public/uploads/big/ mv Lychee-v3/uploads/medium/* Lychee/public/uploads/medium/ mv Lychee-v3/uploads/small/* Lychee/public/uploads/small/ mv Lychee-v3/uploads/thumb/* Lychee/public/uploads/thumb/ ``` ### Preparing the server :::note The big difference between Lychee version 3 and Lychee version 4 is the served directory, i.e. where you web server needs to point to. ::: - In the version 3, this was the root `.` of Lychee. - In the version 4, this is the `public` directory inside Lychee. #### Using Apache **Make sure you have the module rewrite available and enabled: `a2enmod rewrite`**. Modify your `/etc/apache2/apache2.conf` to allow `.htaccess` to set up the rewrite rules: ```apache Options Indexes FollowSymLinks AllowOverride All Require all granted ``` Modify or create `example.com.conf` in `/etc/apache2/sites-available/` to point out the served directory: ```apache ServerName example.com DocumentRoot /var/www/html/Lychee/public ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined ``` Enable the site: ```bash a2ensite `example.com.conf` ``` Restart apache2: ```bash systemctl restart apache2 ``` #### Using Nginx If you are using Nginx, an example configuration can be found [here](/docs/getting-started/manual-installation/#web-server-configuration). #### Run the migrations Make sure you have `DB_OLD_LYCHEE_PREFIX` set in your `.env` to correspond the table prefix of your old database, then run `php artisan migrate`. --- ## File: src/content/docs/docs/faq/general.md --- title: "General FAQ" sidebar: order: 1 --- ### Which browsers are supported? Lychee should work with any modern, standards-compliant web browser (note that having JavaScript enabled is a hard dependency). Lychee does take advantage of several HTML5 features, such as the `