refactor: update Vite application structure and dependencies

- Removed the `index.html` file as part of the transition to a new routing system.
- Updated `package.json` scripts to streamline development commands using `concurrently`.
- Enhanced dependency management by adding new packages and updating existing ones in `package.json`.
- Introduced a new server function for branding and session management, improving API interactions.
- Refactored routing to utilize TanStack Start, ensuring better integration with the existing Dokploy architecture.
- Improved static file handling and server response management in the custom Node.js server.
- Updated README to reflect changes in architecture and development processes.

.claude/settings.json

@@ -1,22 +0,0 @@
-{
-	"worktree": {
-		"baseRef": "fresh"
-	},
-	"hooks": {
-		"PostToolUse": [
-			{
-				"matcher": "EnterWorktree",
-				"hooks": [
-					{
-						"type": "command",
-						"command": "\"$CLAUDE_PROJECT_DIR/scripts/install-worktree-deps.sh\""
-					},
-					{
-						"type": "command",
-						"command": "\"$CLAUDE_PROJECT_DIR/scripts/assign-worktree-port.sh\""
-					}
-				]
-			}
-		]
-	}
-}

.claude/skills/fix-issue/SKILL.md

@@ -1,55 +0,0 @@
----
-name: fix-issue
-description: Implement a GitHub issue with reproduction and verification
-allowed-tools: Bash, Edit, Write, Read, Glob, Grep, mcp__playwright__*, mcp__dokploy__*
----
-
-The issue number is passed as $1.
-
-## Instance
-
-No instance is running yet — start your own, isolated to this worktree:
-
-1. Check `apps/dokploy/.env` for `PORT` (assigned per-worktree already).
-2. If nothing is listening on that port, start it: `pnpm dokploy:dev` in the
-   background, then poll `curl -s -o /dev/null -w '%{http_code}' http://localhost:$PORT`
-   until it answers (usually ~10-15s).
-3. Use `http://localhost:$PORT` as the base URL for Playwright navigation.
-
-Note: `mcp__dokploy__*` resolves its URL from
-`$DOKPLOY_BASE_URL` once, at session startup — it cannot pick up a port
-discovered mid-session. If those tools are unavailable or point at the wrong
-instance, fall back to `curl`/`gh api` for API-level checks, or ask the user
-to relaunch with `DOKPLOY_BASE_URL` exported first.
-
-## Tools
-
-- `mcp__dokploy__*` — the Dokploy API of the running instance. Use it to set up
-  state (create a project, an app, an env var) and to verify backend behavior.
-  Search for the tool you need; they are not all loaded upfront.
-- `mcp__playwright__*` — the browser at $DOKPLOY_BASE_URL. Use it for anything
-  a user would see or click.
-
-Pick by where the bug lives, not by convenience:
-
-- Bug in the UI (rendering, forms, navigation, state) → reproduce in Playwright.
-  The API returning correct data proves nothing here.
-- Bug in the API, deploy logic, or data → reproduce with the Dokploy MCP.
-  A green screenshot proves nothing here.
-- Unclear → do both.
-
-Use the MCP to reach the state you need quickly, then verify in the UI. Do not
-click through ten screens to create a project the API can create in one call.
-
-## Steps
-
-1. Run `gh issue view $1` and read the full issue, including comments.
-2. Reproduce the bug with the appropriate tool. If you cannot reproduce it,
-   comment on the issue explaining what you tried and STOP.
-   Do not implement anything.
-3. Implement the fix. Keep the change minimal and scoped to the issue.
-4. Run `pnpm test`, then re-run the same reproduction from step 2.
-5. Only if both pass: commit and run `gh pr create`. The PR description must
-   include the before/after reproduction steps and reference the issue.
-
-Never skip step 2. A fix you cannot reproduce and then verify is not a fix.

.dockerignore

@@ -2,4 +2,8 @@ node_modules
 .git
 .gitignore
 *.md
-dist
+dist
+**/.next
+**/dist
+**/dist-server
+**/.env

.github/workflows/format.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
-        uses: actions/checkout@v5
+        uses: actions/checkout@v4
 
       - name: Setup biomeJs
         uses: biomejs/setup-biome@v2  
@@ -19,4 +19,4 @@ jobs:
       - name: Run Biome formatter
         run:  biome format --write
 
-      - uses: autofix-ci/action@c5b2d67aa2274e7b5a18224e8171550871fc7e4a # v1.3.4
+      - uses: autofix-ci/action@635ffb0c9798bd160680f18fd73371e355b85f27 # v1.3.2

.github/workflows/hotfix-cherry-pick.yml

@@ -34,16 +34,3 @@ jobs:
           fi
           git commit --amend -m "$(git log -1 --format=%B)" -m "[skip ci]"
           git push origin main
-
-      - name: Sync cherry-pick back into canary
-        run: |
-          git config user.name "Dokploy Bot"
-          git config user.email "bot@dokploy.com"
-          git fetch origin canary main
-          git checkout -B canary origin/canary
-          if ! git merge origin/main -m "chore: sync hotfix from main into canary [skip ci]"; then
-            git merge --abort
-            echo "::error::Could not auto-sync the hotfix into canary (real conflict, not just history divergence). Merge main into canary manually to avoid a conflict on the next release PR."
-            exit 1
-          fi
-          git push origin canary

.github/workflows/pull-request.yml

@@ -14,9 +14,9 @@ jobs:
       matrix:
         job: [build, test, typecheck]
     steps:
-      - uses: actions/checkout@v5
-      - uses: pnpm/action-setup@v5
-      - uses: actions/setup-node@v5
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
         with:
           node-version: 24.4.0
           cache: "pnpm"

.github/workflows/upgrade-integration-test.yml

@@ -1,437 +0,0 @@
-# Upgrade Integration Test
-#
-# Tests that Dokploy can upgrade from version A to version B while keeping
-# user projects (Postgres, MongoDB, two web apps, one static site) alive.
-#
-# Generates upgrade pairs: each stable tag in [floor_version, target_version)
-# is paired with target_version. If target_version is empty, the highest tag
-# available on Docker Hub is used as the target.
-#
-# Only triggered manually to avoid burning Actions minutes.
-
-name: Upgrade Integration Test
-
-on:
-  workflow_dispatch:
-    inputs:
-      floor_version:
-        description: 'Oldest version tag to include in pairs (e.g. v0.29.4)'
-        required: false
-        default: 'v0.29.4'
-      target_version:
-        description: 'Target version to upgrade to (version B). Leave empty to use the highest available.'
-        required: false
-        default: ''
-
-env:
-  DOKPLOY_IMAGE:   dokploy/dokploy
-  DOKPLOY_SERVICE: dokploy
-  DOKPLOY_PORT:    3000
-
-# ──────────────────────────────────────────────────────────────────────────────
-jobs:
-
-  # ── 1. Build the matrix ─────────────────────────────────────────────────────
-  build-matrix:
-    name: Build upgrade pair matrix
-    runs-on: ubuntu-latest
-    outputs:
-      pairs: ${{ steps.pairs.outputs.pairs }}
-
-    steps:
-      - name: Generate pairs
-        id: pairs
-        env:
-          FLOOR:  ${{ inputs.floor_version }}
-          TARGET: ${{ inputs.target_version }}
-        run: |
-          set -euo pipefail
-
-          # semver "a >= b" comparison helper (vX.Y.Z, strips leading v)
-          ge() {
-            [ "$(printf '%s\n%s\n' "${1#v}" "${2#v}" | sort -V | tail -n1)" = "${1#v}" ]
-          }
-
-          # Fetch all semver tags from Docker Hub (dokploy/dokploy)
-          ALL_TAGS=$(curl -fsSL \
-            "https://hub.docker.com/v2/repositories/dokploy/dokploy/tags?page_size=100" | \
-            jq -r '.results[].name' | \
-            grep -E '^v[0-9]+\.[0-9]+\.[0-9]+$' | \
-            sort -V)
-
-          echo "All tags found:"
-          echo "$ALL_TAGS"
-
-          # Target version (version B): explicit input, else highest available.
-          if [ -n "$TARGET" ]; then
-            TO="$TARGET"
-            echo "Using user-supplied target version: $TO"
-          else
-            TO=$(echo "$ALL_TAGS" | tail -n1)
-            echo "No target supplied; using highest available: $TO"
-          fi
-
-          # Floor semver components
-          FLOOR_CLEAN="${FLOOR#v}"
-          IFS='.' read -r F_MAJ F_MIN F_PAT <<< "$FLOOR_CLEAN"
-
-          # Each tag in [FLOOR, TO) → TO
-          PAIRS='[]'
-          while read -r TAG; do
-            [ -z "$TAG" ] && continue
-            # skip tags above-or-equal to the target (incl. the target itself)
-            ge "$TAG" "$TO" && continue
-            TAG_CLEAN="${TAG#v}"
-            IFS='.' read -r T_MAJ T_MIN T_PAT <<< "$TAG_CLEAN"
-            if [ "$T_MAJ" -gt "$F_MAJ" ] || \
-               { [ "$T_MAJ" -eq "$F_MAJ" ] && [ "$T_MIN" -gt "$F_MIN" ]; } || \
-               { [ "$T_MAJ" -eq "$F_MAJ" ] && [ "$T_MIN" -eq "$F_MIN" ] && [ "$T_PAT" -ge "$F_PAT" ]; }; then
-              PAIRS=$(echo "$PAIRS" | jq -c \
-                --arg f "$TAG" --arg t "$TO" \
-                '. + [{"from":$f,"to":$t}]')
-            fi
-          done <<< "$ALL_TAGS"
-
-          COUNT=$(echo "$PAIRS" | jq 'length')
-          echo "Total pairs: $COUNT"
-          echo "$PAIRS" | jq -r '.[] | "  \(.from) → \(.to)"'
-
-          echo "pairs=$PAIRS" >> "$GITHUB_OUTPUT"
-
-
-  # ── 2. Run one upgrade test per pair ────────────────────────────────────────
-  upgrade-test:
-    name: "${{ matrix.pair.from }} → ${{ matrix.pair.to }}"
-    needs: build-matrix
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        pair: ${{ fromJSON(needs.build-matrix.outputs.pairs) }}
-
-    steps:
-
-      # ── Environment setup ──────────────────────────────────────────────────
-      - name: Free disk space
-        run: |
-          sudo rm -rf \
-            /usr/share/dotnet /opt/ghc /usr/local/share/boost \
-            "$AGENT_TOOLSDIRECTORY" /usr/local/lib/android \
-            /usr/local/share/chromium /opt/hostedtoolcache
-          docker system prune -af --volumes
-          df -h
-
-      # ── Install Dokploy directly at VERSION A ──────────────────────────────
-      # install.sh:
-      #   • requires root (run via sudo bash)
-      #   • respects DOKPLOY_VERSION → installs that tag directly
-      #     (so we don't need a separate "downgrade" step that would risk
-      #     running B's migrations on A's expected schema)
-      #   • respects ADVERTISE_ADDR → skip the external IP lookup
-      #   • initializes Docker Swarm + dokploy-network itself
-      - name: Install Dokploy at VERSION A (${{ matrix.pair.from }})
-        run: |
-          curl -fsSL https://dokploy.com/install.sh -o /tmp/install.sh
-          chmod +x /tmp/install.sh
-          sudo -E env \
-            DOKPLOY_VERSION="${{ matrix.pair.from }}" \
-            ADVERTISE_ADDR="127.0.0.1" \
-            bash /tmp/install.sh
-
-      - name: Wait for dokploy service to converge on ${{ matrix.pair.from }}
-        run: |
-          echo "Waiting for 'dokploy' Swarm service to reach 1/1..."
-          timeout 240 bash -c '
-            until docker service ls --filter name=dokploy \
-                    --format "{{.Name}} {{.Replicas}}" \
-                  | grep "^dokploy " | grep -q " 1/1"; do
-              sleep 4
-            done
-          '
-          docker service ls
-          echo "✅ Service running on ${{ matrix.pair.from }}"
-
-      - name: Wait for Dokploy API to accept requests
-        run: |
-          timeout 180 bash -c '
-            until curl -sf -o /dev/null \
-                       "http://localhost:${{ env.DOKPLOY_PORT }}"; do
-              sleep 3
-            done
-          '
-          echo "✅ Dokploy API is up"
-
-      # ── Bootstrap admin user ───────────────────────────────────────────────
-      - name: Register first admin user
-        id: auth
-        run: |
-          COOKIE_JAR="$RUNNER_TEMP/dokploy-cookies.txt"
-          : > "$COOKIE_JAR"
-          chmod 600 "$COOKIE_JAR"
-          echo "cookie_jar=$COOKIE_JAR" >> "$GITHUB_OUTPUT"
-
-          # better-auth: sign-up/email (allowed only before any owner exists)
-          set -x
-          curl -sS -i -X POST \
-            "http://localhost:${{ env.DOKPLOY_PORT }}/api/auth/sign-up/email" \
-            -H "Content-Type: application/json" \
-            -c "$COOKIE_JAR" -b "$COOKIE_JAR" \
-            -d '{"name":"CI Admin","email":"ci@dokploy.test","password":"CiTest1234!"}' \
-            | tee /tmp/signup.out
-          set +x
-
-          # Verify we got a session cookie
-          if ! grep -qE '(better-auth|auth)\.session' "$COOKIE_JAR"; then
-            echo "⚠️  No session cookie matched expected name; jar contents:"
-            cat "$COOKIE_JAR"
-          fi
-
-      # ── Create test resources ──────────────────────────────────────────────
-      - name: Create project, databases and applications
-        id: create
-        env:
-          BASE:   "http://localhost:${{ env.DOKPLOY_PORT }}"
-          COOKIE: ${{ steps.auth.outputs.cookie_jar }}
-        run: |
-          set -euo pipefail
-
-          # --- tRPC POST helper ---
-          trpc_mut() {
-            curl -sf -X POST "$BASE/api/trpc/$1" \
-              -H "Content-Type: application/json" \
-              -b "$COOKIE" -c "$COOKIE" \
-              -d "{\"json\":$2}"
-          }
-
-          # --- Project ---
-          PROJECT=$(trpc_mut project.create \
-            '{"name":"ci-upgrade-test","description":"CI upgrade integration test"}')
-          echo "project.create → $PROJECT"
-
-          # project.create in v0.29+ returns nested {project:{projectId}, environment:{environmentId}}
-          PROJECT_ID=$(echo "$PROJECT" | jq -r \
-            '.result.data.json.project.projectId // .result.data.json.projectId // empty')
-          ENV_ID=$(echo "$PROJECT" | jq -r \
-            '.result.data.json.environment.environmentId // empty')
-
-          if [ -z "$PROJECT_ID" ] || [ "$PROJECT_ID" = "null" ]; then
-            echo "❌ Could not extract projectId from project.create response:"
-            echo "$PROJECT" | jq .
-            exit 1
-          fi
-          if [ -z "$ENV_ID" ] || [ "$ENV_ID" = "null" ]; then
-            echo "❌ Could not extract environmentId — this version may not support environments."
-            echo "   project.create response: $PROJECT"
-            exit 1
-          fi
-
-          echo "project_id=$PROJECT_ID" >> "$GITHUB_OUTPUT"
-          echo "env_id=$ENV_ID"         >> "$GITHUB_OUTPUT"
-          echo "Detected PROJECT_ID=$PROJECT_ID  ENV_ID=$ENV_ID"
-
-          # --- PostgreSQL 15 ---
-          PG=$(trpc_mut postgres.create \
-            "{\"name\":\"ci-pg\",\"appName\":\"ci-pg-db\",\
-              \"databaseName\":\"cidb\",\"databaseUser\":\"ciuser\",\
-              \"databasePassword\":\"CiPg1pass\",\
-              \"dockerImage\":\"postgres:15\",\"environmentId\":\"$ENV_ID\"}")
-          echo "postgres.create → $PG"
-          PG_ID=$(echo "$PG" | jq -r '.result.data.json.postgresId')
-          # deploy (not start) — deploy creates the Swarm service; start only
-          # scales an already-deployed service and 500s on a fresh resource.
-          trpc_mut postgres.deploy "{\"postgresId\":\"$PG_ID\"}" > /dev/null
-          echo "pg_id=$PG_ID" >> "$GITHUB_OUTPUT"
-
-          # --- MongoDB 7.0 ---
-          MG=$(trpc_mut mongo.create \
-            "{\"name\":\"ci-mongo\",\"appName\":\"ci-mongo-db\",\
-              \"databaseName\":\"cidb\",\"databaseUser\":\"ciuser\",\
-              \"databasePassword\":\"CiMg1pass\",\
-              \"dockerImage\":\"mongo:7.0\",\"environmentId\":\"$ENV_ID\"}")
-          echo "mongo.create → $MG"
-          MG_ID=$(echo "$MG" | jq -r '.result.data.json.mongoId')
-          trpc_mut mongo.deploy "{\"mongoId\":\"$MG_ID\"}" > /dev/null
-          echo "mg_id=$MG_ID" >> "$GITHUB_OUTPUT"
-
-          # --- Docker-image application helper ---
-          make_app() {
-            local DISP_NAME=$1 APP_NAME=$2 IMAGE=$3
-            APP=$(trpc_mut application.create \
-              "{\"name\":\"$DISP_NAME\",\"appName\":\"$APP_NAME\",\"environmentId\":\"$ENV_ID\"}")
-            APP_ID=$(echo "$APP" | jq -r '.result.data.json.applicationId')
-            trpc_mut application.saveDockerProvider \
-              "{\"applicationId\":\"$APP_ID\",\"dockerImage\":\"$IMAGE\",\
-                \"username\":\"\",\"password\":\"\",\"registryUrl\":\"\"}" \
-              > /dev/null
-            trpc_mut application.deploy "{\"applicationId\":\"$APP_ID\"}" \
-              > /dev/null
-            echo "$APP_ID"
-          }
-
-          # Static site (nginx)
-          APP_STATIC=$(make_app "ci-static" "ci-static-app" "nginx:alpine")
-          echo "app_static_id=$APP_STATIC" >> "$GITHUB_OUTPUT"
-
-          # Node.js hello-world (echo server image — small, no args needed)
-          APP_NODE=$(make_app "ci-node" "ci-node-app" "ealen/echo-server:latest")
-          echo "app_node_id=$APP_NODE" >> "$GITHUB_OUTPUT"
-
-          # Go HTTP server (traefik/whoami is a tiny Go binary, port 80)
-          APP_GO=$(make_app "ci-go" "ci-go-app" "traefik/whoami:latest")
-          echo "app_go_id=$APP_GO" >> "$GITHUB_OUTPUT"
-
-          echo "✅ All resources created"
-
-      # ── Pre-upgrade health check ───────────────────────────────────────────
-      - name: Wait for all services → 'done' (pre-upgrade)
-        env:
-          BASE:          "http://localhost:${{ env.DOKPLOY_PORT }}"
-          COOKIE:        ${{ steps.auth.outputs.cookie_jar }}
-          PG_ID:         ${{ steps.create.outputs.pg_id }}
-          MG_ID:         ${{ steps.create.outputs.mg_id }}
-          APP_STATIC_ID: ${{ steps.create.outputs.app_static_id }}
-          APP_NODE_ID:   ${{ steps.create.outputs.app_node_id }}
-          APP_GO_ID:     ${{ steps.create.outputs.app_go_id }}
-        run: |
-          wait_done() {
-            local NAME=$1 ENDPOINT=$2 ID_KEY=$3 ID=$4 STATUS_KEY=$5
-            echo "Waiting for $NAME to reach 'done'..."
-            timeout 360 bash -c "
-              until [ \"\$(curl -sf -G '$BASE/api/trpc/$ENDPOINT' \
-                        --data-urlencode 'input={\"json\":{\"$ID_KEY\":\"$ID\"}}' \
-                        -b '$COOKIE' | \
-                        jq -r '.result.data.json.$STATUS_KEY // \"unknown\"')\" \
-                      = 'done' ]; do
-                sleep 5
-              done
-            "
-            echo "✅ $NAME is done"
-          }
-
-          wait_done postgres  postgres.one    postgresId    "$PG_ID"         applicationStatus
-          wait_done mongo     mongo.one       mongoId       "$MG_ID"         applicationStatus
-          wait_done static    application.one applicationId "$APP_STATIC_ID" applicationStatus
-          wait_done node-app  application.one applicationId "$APP_NODE_ID"   applicationStatus
-          wait_done go-app    application.one applicationId "$APP_GO_ID"     applicationStatus
-
-      - name: Assert Docker Swarm services healthy (pre-upgrade)
-        run: |
-          echo "=== docker service ls ==="
-          docker service ls
-
-          FAIL=$(docker service ls --format '{{.Name}} {{.Replicas}}' | \
-            grep -E '^ci-' | grep -v ' 1/1' || true)
-          if [ -n "$FAIL" ]; then
-            echo "❌ User services not healthy before upgrade:"
-            echo "$FAIL"
-            exit 1
-          fi
-          echo "✅ All user services healthy before upgrade"
-
-      # ── Upgrade ────────────────────────────────────────────────────────────
-      - name: Upgrade Dokploy to VERSION B (${{ matrix.pair.to }})
-        run: |
-          docker service update \
-            --image "${{ env.DOKPLOY_IMAGE }}:${{ matrix.pair.to }}" \
-            --force \
-            "${{ env.DOKPLOY_SERVICE }}"
-
-          echo "Waiting for service to converge on ${{ matrix.pair.to }}..."
-          timeout 240 bash -c '
-            until ! docker service inspect dokploy \
-                    --format "{{.UpdateStatus.State}}" 2>/dev/null \
-                  | grep -q "^updating$"; do
-              sleep 4
-            done
-            until docker service ls --filter name=dokploy \
-                    --format "{{.Name}} {{.Replicas}}" \
-                  | grep "^dokploy " | grep -q " 1/1"; do
-              sleep 4
-            done
-          '
-          echo "✅ Service running on ${{ matrix.pair.to }}"
-
-      - name: Wait for Dokploy API to respond post-upgrade
-        run: |
-          timeout 180 bash -c '
-            until curl -sf -o /dev/null \
-                       "http://localhost:${{ env.DOKPLOY_PORT }}"; do
-              sleep 3
-            done
-          '
-          echo "✅ Dokploy API is up after upgrade"
-
-      # ── Post-upgrade health check ──────────────────────────────────────────
-      - name: Verify all services still healthy (post-upgrade)
-        env:
-          BASE:          "http://localhost:${{ env.DOKPLOY_PORT }}"
-          COOKIE:        ${{ steps.auth.outputs.cookie_jar }}
-          PG_ID:         ${{ steps.create.outputs.pg_id }}
-          MG_ID:         ${{ steps.create.outputs.mg_id }}
-          APP_STATIC_ID: ${{ steps.create.outputs.app_static_id }}
-          APP_NODE_ID:   ${{ steps.create.outputs.app_node_id }}
-          APP_GO_ID:     ${{ steps.create.outputs.app_go_id }}
-        run: |
-          check_status() {
-            local NAME=$1 ENDPOINT=$2 ID_KEY=$3 ID=$4 STATUS_KEY=$5
-            STATUS=$(curl -sf -G "$BASE/api/trpc/$ENDPOINT" \
-              --data-urlencode "input={\"json\":{\"$ID_KEY\":\"$ID\"}}" \
-              -b "$COOKIE" | \
-              jq -r ".result.data.json.$STATUS_KEY // \"unknown\"")
-            if [ "$STATUS" != "done" ]; then
-              echo "❌ $NAME status after upgrade: $STATUS"
-              return 1
-            fi
-            echo "✅ $NAME: $STATUS"
-          }
-
-          check_status postgres  postgres.one    postgresId    "$PG_ID"         applicationStatus
-          check_status mongo     mongo.one       mongoId       "$MG_ID"         applicationStatus
-          check_status static    application.one applicationId "$APP_STATIC_ID" applicationStatus
-          check_status node-app  application.one applicationId "$APP_NODE_ID"   applicationStatus
-          check_status go-app    application.one applicationId "$APP_GO_ID"     applicationStatus
-
-          echo "=== docker service ls (post-upgrade) ==="
-          docker service ls
-
-          FAIL=$(docker service ls --format '{{.Name}} {{.Replicas}}' | \
-            grep -E '^ci-' | grep -v ' 1/1' || true)
-          if [ -n "$FAIL" ]; then
-            echo "❌ User services not healthy after upgrade:"
-            echo "$FAIL"
-            exit 1
-          fi
-          echo "✅ All services healthy after upgrade to ${{ matrix.pair.to }}"
-
-      # ── Diagnostics on failure ─────────────────────────────────────────────
-      - name: Dump state on failure
-        if: failure()
-        run: |
-          echo "=== docker service ls ===" && docker service ls || true
-          echo "=== dokploy service tasks ===" && \
-            docker service ps "${{ env.DOKPLOY_SERVICE }}" --no-trunc || true
-          echo "=== dokploy logs (last 200) ===" && \
-            docker service logs "${{ env.DOKPLOY_SERVICE }}" --tail 200 2>&1 || true
-          echo "=== install.sh tail ===" && \
-            tail -100 /tmp/install.sh 2>&1 || true
-          echo "=== signup response ===" && \
-            cat /tmp/signup.out 2>&1 || true
-          echo "=== disk usage ===" && df -h
-
-      # ── Job summary ────────────────────────────────────────────────────────
-      - name: Write job summary
-        if: always()
-        run: |
-          STATUS="${{ job.status }}"
-          ICON="✅"; [ "$STATUS" != "success" ] && ICON="❌"
-          cat >> "$GITHUB_STEP_SUMMARY" <<EOF
-          ## ${ICON} ${{ matrix.pair.from }} → ${{ matrix.pair.to }}: ${STATUS^^}
-
-          | Service | Image |
-          |---------|-------|
-          | ci-pg-db | postgres:15 |
-          | ci-mongo-db | mongo:7.0 |
-          | ci-static-app | nginx:alpine (static site) |
-          | ci-node-app | ealen/echo-server (Node.js hello-world) |
-          | ci-go-app | traefik/whoami (Go HTTP server) |
-          EOF

.gitignore

@@ -46,4 +46,8 @@ yarn-error.log*
 .db
 
 .playwright-*
-.credentials
+.credentials
+dist/
+dist-server/
+.tanstack
+.env.*

.worktreeinclude

@@ -1,2 +0,0 @@
-.env
-.env.local

CLAUDE.md

@@ -1,6 +0,0 @@
-## Code style
-- Don't write comments that restate what the code already says.
-- Comment only the "why" when something isn't obvious: workarounds,
-  counterintuitive decisions, constraints from an external API.
-- No section-divider comments like `// --- Helpers ---`.
-- Don't leave comments describing the change you just made.

CONTRIBUTING.md

@@ -120,20 +120,12 @@ pnpm run docker:push
 
 ## Password Reset
 
-In the case you lost your password, you can reset the owner's password using the following command
+In the case you lost your password, you can reset it using the following command
 
 ```bash
-pnpm --filter=dokploy run reset-password
+pnpm run reset-password
 ```
 
-To reset the password of a specific user instead, pass their email as an argument
-
-```bash
-pnpm --filter=dokploy run reset-password user@example.com
-```
-
-Both commands print the new randomly generated password to the console.
-
 If you want to test the webhooks on development mode using localtunnel, make sure to install [`localtunnel`](https://localtunnel.app/)
 
 ```bash

Dockerfile

@@ -31,7 +31,7 @@ WORKDIR /app
 # Set production
 ENV NODE_ENV=production
 
-RUN apt-get update && apt-get install -y tini curl unzip zip apache2-utils iproute2 rsync git-lfs && git lfs install && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y curl unzip zip apache2-utils iproute2 rsync git-lfs && git lfs install && rm -rf /var/lib/apt/lists/*
 
 # Copy only the necessary files
 COPY --from=build /prod/dokploy/.next ./.next
@@ -69,8 +69,5 @@ EXPOSE 3000
 HEALTHCHECK --interval=30s --timeout=5s --start-period=60s --retries=5 \
   CMD curl -fs http://localhost:3000/api/trpc/settings.health || exit 1
 
-# tini reaps HEALTHCHECK child processes that Node (as PID 1) leaves defunct.
-ENTRYPOINT ["/usr/bin/tini", "--"]
-
 # Ejecutar node directamente: pnpm como wrapper queda residente (~100MB RSS)
   CMD ["sh", "-c", "node -r dotenv/config dist/wait-for-postgres.mjs && node -r dotenv/config dist/migration.mjs && exec node -r dotenv/config dist/server.mjs"]

Dockerfile.vite

@@ -0,0 +1,54 @@
+# syntax=docker/dockerfile:1
+FROM node:24.4.0-slim AS base
+ENV PNPM_HOME="/pnpm"
+ENV PATH="$PNPM_HOME:$PATH"
+RUN corepack enable
+RUN corepack prepare pnpm@10.22.0 --activate
+
+FROM base AS build
+COPY . /usr/src/app
+WORKDIR /usr/src/app
+
+RUN apt-get update && apt-get install -y python3 make g++ git pkg-config libsecret-1-dev && rm -rf /var/lib/apt/lists/*
+
+RUN --mount=type=cache,id=pnpm,target=/pnpm/store pnpm install --no-frozen-lockfile
+
+ENV NODE_ENV=production
+RUN pnpm --filter=dokploy-vite build
+RUN pnpm --filter=dokploy-vite build:server
+
+RUN pnpm --filter=dokploy-vite --prod deploy --legacy /prod/vite
+
+# Drop auto-installed optional peers that are never used at runtime
+# (better-auth peers next/prisma adapters; drizzle peers pglite/sqlite; prisma pulls effect/sharp)
+RUN cd /prod/vite/node_modules && rm -rf \
+	.pnpm/next@* .pnpm/@next+swc* \
+	.pnpm/prisma@* .pnpm/@prisma+* \
+	.pnpm/effect@* .pnpm/@electric-sql+* \
+	.pnpm/better-sqlite3@* \
+	.pnpm/sharp@* .pnpm/@img+* \
+	.pnpm/typescript@* \
+	next prisma typescript better-sqlite3 sharp
+
+FROM base AS runtime
+WORKDIR /app
+ENV NODE_ENV=production
+
+RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*
+
+# For a full production replacement of the official image, add the same
+# tooling block as ./Dockerfile (docker cli, nixpacks, railpack, pack, rclone)
+# — required for builds/deployments, not for serving the panel.
+
+COPY --from=build /prod/vite/node_modules ./node_modules
+COPY --from=build /prod/vite/package.json ./package.json
+COPY --from=build /usr/src/app/apps/vite/dist ./dist
+COPY --from=build /usr/src/app/apps/vite/dist-server ./dist-server
+COPY --from=build /usr/src/app/apps/dokploy/drizzle ./drizzle
+
+EXPOSE 3000
+
+HEALTHCHECK --interval=30s --timeout=5s --start-period=30s --retries=5 \
+	CMD curl -fs http://localhost:3000/api/health || exit 1
+
+CMD ["sh", "-c", "node dist-server/wait-for-postgres.mjs && node dist-server/migration.mjs && exec node dist-server/server.mjs"]

apps/api/README.md

@@ -6,13 +6,3 @@ npm run dev
 ```
 open http://localhost:3000
 ```
-
-## Inngest
-
-This service uses Inngest to queue deployments. Run the local dev server in a separate terminal:
-
-```
-npm run dev:inngest
-```
-
-It syncs with the app at `http://localhost:4000/api/inngest` and serves its dashboard at `http://localhost:8288`.

apps/api/package.json

@@ -4,7 +4,6 @@
 	"type": "module",
 	"scripts": {
 		"dev": "PORT=4000 tsx watch src/index.ts",
-		"dev:inngest": "npx --yes inngest-cli@1.9.0 dev -u http://localhost:4000/api/inngest --no-discovery",
 		"build": "rimraf dist && tsc --project tsconfig.json",
 		"start": "node dist/index.js",
 		"typecheck": "tsc --noEmit"
@@ -29,7 +28,7 @@
 		"@types/react-dom": "^19.2.0",
 		"rimraf": "6.1.3",
 		"tsx": "^4.22.4",
-		"typescript": "^7.0.2"
+		"typescript": "^5.8.3"
 	},
 	"packageManager": "pnpm@10.22.0",
 	"engines": {

apps/api/tsconfig.json

@@ -2,12 +2,13 @@
 	"compilerOptions": {
 		"target": "ESNext",
 		"module": "ESNext",
-		"moduleResolution": "bundler",
+		"moduleResolution": "Node",
 		"strict": true,
 		"skipLibCheck": true,
 		"outDir": "dist",
-		"rootDir": "./src",
 		"jsx": "react-jsx",
+		"jsxImportSource": "hono/jsx",
+		"baseUrl": ".",
 		"paths": {
 			"@/*": ["./*"],
 			"@dokploy/server/*": ["../../packages/server/src/*"]

apps/dokploy/__test__/api/session-management.test.ts

@@ -1,23 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { z } from "zod";
-
-const revokeSessionSchema = z.object({
-	sessionId: z.string(),
-});
-
-describe("revokeSession input validation", () => {
-	it("accepts a valid session id", () => {
-		const result = revokeSessionSchema.safeParse({ sessionId: "abc123" });
-		expect(result.success).toBe(true);
-	});
-
-	it("rejects missing sessionId", () => {
-		const result = revokeSessionSchema.safeParse({});
-		expect(result.success).toBe(false);
-	});
-
-	it("rejects non-string sessionId", () => {
-		const result = revokeSessionSchema.safeParse({ sessionId: 123 });
-		expect(result.success).toBe(false);
-	});
-});

apps/dokploy/__test__/backups/volume-backup-restart.test.ts

@@ -1,82 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { createRestartSafeBackupCommand } from "@dokploy/server/utils/volume-backups/backup";
-import { describe, expect, it } from "vitest";
-
-const runCommand = (command: string) =>
-	spawnSync("bash", ["-c", command], {
-		encoding: "utf8",
-	});
-
-const outputLines = (stdout: string) =>
-	stdout
-		.trim()
-		.split("\n")
-		.filter((line) => line.length > 0);
-
-describe("createRestartSafeBackupCommand", () => {
-	it("restarts the service and preserves the backup error status", () => {
-		const result = runCommand(
-			createRestartSafeBackupCommand({
-				stopCommand: 'echo "stop"',
-				backupCommand: 'echo "backup"; exit 23',
-				startCommand: 'echo "start"',
-				uploadCommand: 'echo "upload"',
-			}),
-		);
-
-		expect(result.status).toBe(23);
-		expect(outputLines(result.stdout)).toEqual(["stop", "backup", "start"]);
-	});
-
-	it("preserves the backup error status when the restart also fails", () => {
-		const result = runCommand(
-			createRestartSafeBackupCommand({
-				stopCommand: 'echo "stop"',
-				backupCommand: 'echo "backup"; exit 23',
-				startCommand: 'echo "start"; exit 17',
-				uploadCommand: 'echo "upload"',
-			}),
-		);
-
-		expect(result.status).toBe(23);
-		expect(outputLines(result.stdout)).toEqual([
-			"stop",
-			"backup",
-			"start",
-			"Service restart also failed with exit code 17",
-		]);
-	});
-
-	it("returns the restart error status when the backup succeeds", () => {
-		const result = runCommand(
-			createRestartSafeBackupCommand({
-				stopCommand: 'echo "stop"',
-				backupCommand: 'echo "backup"',
-				startCommand: 'echo "start"; exit 17',
-				uploadCommand: 'echo "upload"',
-			}),
-		);
-
-		expect(result.status).toBe(17);
-		expect(outputLines(result.stdout)).toEqual(["stop", "backup", "start"]);
-	});
-
-	it("uploads only after a successful backup and service restart", () => {
-		const result = runCommand(
-			createRestartSafeBackupCommand({
-				stopCommand: 'echo "stop"',
-				backupCommand: 'echo "backup"',
-				startCommand: 'echo "start"',
-				uploadCommand: 'echo "upload"',
-			}),
-		);
-
-		expect(result.status).toBe(0);
-		expect(outputLines(result.stdout)).toEqual([
-			"stop",
-			"backup",
-			"start",
-			"upload",
-		]);
-	});
-});

apps/dokploy/__test__/compose/compose-project-directory.test.ts

@@ -1,123 +0,0 @@
-import { createCommand } from "@dokploy/server/utils/builders/compose";
-import { describe, expect, it } from "vitest";
-
-const base = {
-	composeType: "docker-compose" as const,
-	appName: "compose-app",
-	sourceType: "github" as const,
-	command: "",
-};
-
-describe("compose createCommand --project-directory", () => {
-	it("pins --project-directory to the code dir when composePath is nested", () => {
-		const cmd = createCommand(
-			{ ...base, composePath: "./deploy/docker-compose.yml" } as any,
-			"/etc/dokploy/compose/compose-app/code",
-		);
-
-		expect(cmd).toContain(
-			"--project-directory /etc/dokploy/compose/compose-app/code",
-		);
-		expect(cmd).toContain("-f ./deploy/docker-compose.yml");
-	});
-
-	it("omits --project-directory when no projectPath is passed", () => {
-		const cmd = createCommand({
-			...base,
-			composePath: "./deploy/docker-compose.yml",
-		} as any);
-
-		expect(cmd).not.toContain("--project-directory");
-	});
-
-	it("does not add --project-directory to stack deploy (unsupported flag)", () => {
-		const cmd = createCommand(
-			{
-				...base,
-				composeType: "stack",
-				composePath: "./deploy/docker-compose.yml",
-			} as any,
-			"/etc/dokploy/compose/compose-app/code",
-		);
-
-		expect(cmd).not.toContain("--project-directory");
-		expect(cmd.startsWith("stack deploy")).toBe(true);
-	});
-
-	it("keeps raw sourceType resolving from the code dir (root docker-compose.yml)", () => {
-		const cmd = createCommand(
-			{ ...base, sourceType: "raw", composePath: "docker-compose.yml" } as any,
-			"/etc/dokploy/compose/compose-app/code",
-		);
-
-		expect(cmd).toContain(
-			"--project-directory /etc/dokploy/compose/compose-app/code",
-		);
-		expect(cmd).toContain("-f docker-compose.yml");
-	});
-
-	it("resolves build.context against the compose file's own directory when there are no mounts", () => {
-		const cmd = createCommand({
-			...base,
-			composePath: "./backend/docker-compose.yml",
-		} as any);
-
-		expect(cmd).not.toContain("--project-directory");
-		expect(cmd).toContain("-f ./backend/docker-compose.yml");
-	});
-});
-
-describe("compose createCommand --env-file", () => {
-	it("points --env-file at the generated .env next to a nested compose file", () => {
-		const cmd = createCommand(
-			{
-				...base,
-				composePath: "./deploy/docker-compose.yml",
-				createEnvFile: true,
-			} as any,
-			"/etc/dokploy/compose/compose-app/code",
-		);
-
-		expect(cmd).toContain("--env-file deploy/.env");
-		expect(cmd).toContain(
-			"--project-directory /etc/dokploy/compose/compose-app/code",
-		);
-	});
-
-	it("omits --env-file when createEnvFile is disabled", () => {
-		const cmd = createCommand(
-			{ ...base, composePath: "./deploy/docker-compose.yml" } as any,
-			"/etc/dokploy/compose/compose-app/code",
-		);
-
-		expect(cmd).not.toContain("--env-file");
-	});
-
-	it("uses the code-root .env for raw sourceType", () => {
-		const cmd = createCommand(
-			{
-				...base,
-				sourceType: "raw",
-				composePath: "docker-compose.yml",
-				createEnvFile: true,
-			} as any,
-			"/etc/dokploy/compose/compose-app/code",
-		);
-
-		expect(cmd).toContain("--env-file .env");
-	});
-
-	it("does not add --env-file to stack deploy (unsupported flag)", () => {
-		const cmd = createCommand(
-			{
-				...base,
-				composeType: "stack",
-				composePath: "./deploy/docker-compose.yml",
-				createEnvFile: true,
-			} as any,
-			"/etc/dokploy/compose/compose-app/code",
-		);
-
-		expect(cmd).not.toContain("--env-file");
-	});
-});

apps/dokploy/__test__/compose/domain-command-injection.test.ts

@@ -33,7 +33,6 @@ const makeDomain = (serviceName: string) =>
 		https: false,
 		uniqueConfigKey: 1,
 		port: 3000,
-		enabled: true,
 	}) as any;
 
 // If the returned shell fragment is safe, parse() yields only string tokens.

apps/dokploy/__test__/compose/domain/enabled-filter.test.ts

@@ -1,306 +0,0 @@
-import type { Compose } from "@dokploy/server/services/compose";
-import type { Domain } from "@dokploy/server/services/domain";
-import { addDomainToCompose } from "@dokploy/server/utils/docker/domain";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-// With sourceType "raw", addDomainToCompose parses compose.composeFile
-// directly instead of reading from disk, so baseCompose exposes it as a
-// getter that always reflects the current composeYaml for each test case.
-const baseComposeYaml = `
-services:
-  frigate:
-    image: frigate
-`;
-let composeYaml = baseComposeYaml;
-
-const baseCompose = {
-	appName: "test-app",
-	composeType: "docker-compose",
-	composePath: "docker-compose.yml",
-	sourceType: "raw",
-	serverId: null,
-	isolatedDeployment: false,
-	randomize: false,
-	suffix: "",
-	get composeFile() {
-		return composeYaml;
-	},
-} as unknown as Compose;
-
-const baseDomain: Domain = {
-	host: "frigate.example.com",
-	port: 8971,
-	customEntrypoint: null,
-	https: false,
-	uniqueConfigKey: 1,
-	customCertResolver: null,
-	certificateType: "none",
-	applicationId: "",
-	composeId: "compose-id",
-	domainType: "compose",
-	serviceName: "frigate",
-	domainId: "domain-id",
-	path: "/",
-	createdAt: "",
-	previewDeploymentId: "",
-	internalPath: "/",
-	stripPath: false,
-	middlewares: null,
-	forwardAuthEnabled: false,
-	enabled: true,
-};
-
-const serviceLabels = (
-	result: Awaited<ReturnType<typeof addDomainToCompose>>,
-) => (result?.services?.frigate?.labels as string[] | undefined) ?? [];
-
-describe("addDomainToCompose enabled filtering", () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
-		composeYaml = baseComposeYaml;
-	});
-
-	it("generates traefik labels for an enabled domain", async () => {
-		const result = await addDomainToCompose(baseCompose, [
-			{ ...baseDomain, enabled: true },
-		]);
-
-		const labels = serviceLabels(result);
-		expect(labels).toContain("traefik.enable=true");
-		expect(labels.some((l) => l.includes("Host(`frigate.example.com`)"))).toBe(
-			true,
-		);
-	});
-
-	it("skips a disabled domain entirely (no traefik labels)", async () => {
-		const result = await addDomainToCompose(baseCompose, [
-			{ ...baseDomain, enabled: false },
-		]);
-
-		const labels = serviceLabels(result);
-		expect(labels).not.toContain("traefik.enable=true");
-		expect(labels.some((l) => l.includes("Host(`frigate.example.com`)"))).toBe(
-			false,
-		);
-	});
-
-	it.each([
-		[
-			"docker-compose",
-			`services:
-  frigate:
-    image: frigate
-    labels:
-      - traefik.enable=true
-      - traefik.http.routers.test-app-1-web.rule=Host(\`frigate.example.com\`)
-      - traefik.http.services.test-app-1-web.loadbalancer.server.port=8971
-      - traefik.http.middlewares.stripprefix-test-app-1.stripprefix.prefixes=/api
-      - custom.label=preserved
-`,
-		],
-		[
-			"stack",
-			`services:
-  frigate:
-    image: frigate
-    deploy:
-      labels:
-        - traefik.enable=true
-        - traefik.http.routers.test-app-1-web.rule=Host(\`frigate.example.com\`)
-        - traefik.http.services.test-app-1-web.loadbalancer.server.port=8971
-        - traefik.http.middlewares.stripprefix-test-app-1.stripprefix.prefixes=/api
-        - custom.label=preserved
-`,
-		],
-	] as const)(
-		"removes stale labels for a disabled domain from %s rebuilds",
-		async (composeType, staleComposeYaml) => {
-			composeYaml = staleComposeYaml;
-
-			const result = await addDomainToCompose({ ...baseCompose, composeType }, [
-				{ ...baseDomain, enabled: false },
-			]);
-
-			const service = result?.services?.frigate;
-			const labels =
-				composeType === "docker-compose"
-					? service?.labels
-					: service?.deploy?.labels;
-			expect(labels).toContain("custom.label=preserved");
-			expect(
-				(labels as string[]).some((label) => label.includes("test-app-1")),
-			).toBe(false);
-		},
-	);
-
-	it.each([
-		[
-			"docker-compose",
-			`services:
-  legacy:
-    image: frigate
-    labels:
-      - traefik.http.routers.test-app-1-web.rule=Host(\`frigate.example.com\`)
-      - traefik.http.services.test-app-1-web.loadbalancer.server.port=8971
-      - custom.label=preserved
-  frigate:
-    image: frigate
-`,
-		],
-		[
-			"stack",
-			`services:
-  legacy:
-    image: frigate
-    deploy:
-      labels:
-        - traefik.http.routers.test-app-1-web.rule=Host(\`frigate.example.com\`)
-        - traefik.http.services.test-app-1-web.loadbalancer.server.port=8971
-        - custom.label=preserved
-  frigate:
-    image: frigate
-`,
-		],
-	] as const)(
-		"removes stale labels from the previous %s service after reassignment",
-		async (composeType, staleComposeYaml) => {
-			composeYaml = staleComposeYaml;
-
-			const result = await addDomainToCompose({ ...baseCompose, composeType }, [
-				{ ...baseDomain, serviceName: "frigate", enabled: false },
-			]);
-
-			const previousService = result?.services?.legacy;
-			const labels =
-				composeType === "docker-compose"
-					? previousService?.labels
-					: previousService?.deploy?.labels;
-			expect(labels).toContain("custom.label=preserved");
-			expect(
-				(labels as string[]).some((label) => label.includes("test-app-1")),
-			).toBe(false);
-		},
-	);
-
-	it.each([
-		[
-			"docker-compose",
-			`services:
-  frigate:
-    image: frigate
-    labels:
-      traefik.enable: "true"
-      traefik.http.routers.test-app-1-web.rule: Host(\`frigate.example.com\`)
-      traefik.http.services.test-app-1-web.loadbalancer.server.port: 8971
-      traefik.http.middlewares.stripprefix-test-app-1.stripprefix.prefixes: /api
-      custom.label: preserved
-`,
-		],
-		[
-			"stack",
-			`services:
-  frigate:
-    image: frigate
-    deploy:
-      labels:
-        traefik.enable: "true"
-        traefik.http.routers.test-app-1-web.rule: Host(\`frigate.example.com\`)
-        traefik.http.services.test-app-1-web.loadbalancer.server.port: 8971
-        traefik.http.middlewares.stripprefix-test-app-1.stripprefix.prefixes: /api
-        custom.label: preserved
-`,
-		],
-	] as const)(
-		"removes stale mapping labels for a disabled domain from %s rebuilds",
-		async (composeType, staleComposeYaml) => {
-			composeYaml = staleComposeYaml;
-
-			const result = await addDomainToCompose({ ...baseCompose, composeType }, [
-				{ ...baseDomain, enabled: false },
-			]);
-
-			const service = result?.services?.frigate;
-			const labels =
-				composeType === "docker-compose"
-					? service?.labels
-					: service?.deploy?.labels;
-			expect(labels).toMatchObject({ "custom.label": "preserved" });
-			expect(
-				Object.keys(labels ?? {}).some((label) => label.includes("test-app-1")),
-			).toBe(false);
-		},
-	);
-
-	it.each([
-		[
-			"docker-compose",
-			`services:
-  frigate:
-    image: frigate
-    labels:
-      traefik.enable: "true"
-      traefik.http.routers.test-app-1-web.rule: Host(\`old.example.com\`)
-      traefik.http.services.test-app-1-web.loadbalancer.server.port: 8971
-      custom.label: preserved
-`,
-			"traefik.docker.network",
-		],
-		[
-			"stack",
-			`services:
-  frigate:
-    image: frigate
-    deploy:
-      labels:
-        traefik.enable: "true"
-        traefik.http.routers.test-app-1-web.rule: Host(\`old.example.com\`)
-        traefik.http.services.test-app-1-web.loadbalancer.server.port: 8971
-        custom.label: preserved
-`,
-			"traefik.swarm.network",
-		],
-	] as const)(
-		"regenerates routing in mapping labels for an enabled domain in %s",
-		async (composeType, mappingComposeYaml, networkLabel) => {
-			composeYaml = mappingComposeYaml;
-
-			const result = await addDomainToCompose({ ...baseCompose, composeType }, [
-				{ ...baseDomain, enabled: true },
-			]);
-
-			const service = result?.services?.frigate;
-			const labels =
-				composeType === "docker-compose"
-					? service?.labels
-					: service?.deploy?.labels;
-			expect(labels).toMatchObject({
-				"custom.label": "preserved",
-				"traefik.enable": "true",
-				[networkLabel]: "dokploy-network",
-				"traefik.http.routers.test-app-1-web.rule":
-					"Host(`frigate.example.com`)",
-				"traefik.http.services.test-app-1-web.loadbalancer.server.port": "8971",
-			});
-		},
-	);
-
-	it("emits labels only for the enabled domain when both are present", async () => {
-		const result = await addDomainToCompose(baseCompose, [
-			{ ...baseDomain, host: "enabled.example.com", enabled: true },
-			{
-				...baseDomain,
-				host: "disabled.example.com",
-				uniqueConfigKey: 2,
-				enabled: false,
-			},
-		]);
-
-		const labels = serviceLabels(result);
-		expect(labels.some((l) => l.includes("Host(`enabled.example.com`)"))).toBe(
-			true,
-		);
-		expect(labels.some((l) => l.includes("Host(`disabled.example.com`)"))).toBe(
-			false,
-		);
-	});
-});

apps/dokploy/__test__/compose/domain/host-rule-format.test.ts

@@ -35,7 +35,6 @@ describe("Host rule format regression tests", () => {
 		customEntrypoint: null,
 		middlewares: null,
 		forwardAuthEnabled: false,
-		enabled: true,
 	};
 
 	describe("Host rule format validation", () => {

apps/dokploy/__test__/compose/domain/labels.test.ts

@@ -24,7 +24,6 @@ describe("createDomainLabels", () => {
 		stripPath: false,
 		middlewares: null,
 		forwardAuthEnabled: false,
-		enabled: true,
 	};
 
 	it("should create basic labels for web entrypoint", async () => {

apps/dokploy/__test__/compose/domain/raw-compose.test.ts

@@ -1,59 +0,0 @@
-import { addDomainToCompose } from "@dokploy/server/utils/docker/domain";
-import { execAsyncRemote } from "@dokploy/server/utils/process/execAsync";
-import { describe, expect, it, vi } from "vitest";
-
-vi.mock("@dokploy/server/utils/process/execAsync", async (importOriginal) => ({
-	...(await importOriginal<
-		typeof import("@dokploy/server/utils/process/execAsync")
-	>()),
-	execAsyncRemote: vi.fn(),
-}));
-
-describe("raw remote compose conversion (#4794)", () => {
-	it("uses the saved raw source and preserves supported mount syntax", async () => {
-		vi.mocked(execAsyncRemote).mockResolvedValue({
-			stdout: "services:\n  test:\n    image: alpine:latest\n",
-			stderr: "",
-		});
-
-		const compose = {
-			appName: "raw-stack",
-			composeFile: `
-services:
-  test:
-    image: alpine:latest
-    volumes:
-      - type: tmpfs
-        target: /scratch
-      - type: volume
-        source: test-data
-        target: /data
-    tmpfs:
-      - /cache
-volumes:
-  test-data:
-`,
-			composePath: "./docker-compose.yml",
-			composeType: "stack",
-			isolatedDeployment: false,
-			isolatedDeploymentsVolume: false,
-			randomize: false,
-			serverId: "remote-server",
-			sourceType: "raw",
-			suffix: "",
-		} as unknown as Parameters<typeof addDomainToCompose>[0];
-
-		const converted = await addDomainToCompose(compose, []);
-
-		expect(converted?.services?.test?.volumes).toEqual([
-			{ type: "tmpfs", target: "/scratch" },
-			{
-				type: "volume",
-				source: "test-data",
-				target: "/data",
-			},
-		]);
-		expect(converted?.services?.test?.tmpfs).toEqual(["/cache"]);
-		expect(execAsyncRemote).not.toHaveBeenCalled();
-	});
-});

apps/dokploy/__test__/compose/env-file-literals.test.ts

@@ -32,9 +32,6 @@ const cases: Record<string, string> = {
 	APOSTROPHE: "it's a test",
 	UNICODE: "héllo wörld 日本語 🚀",
 	MULTILINE_PEM: "-----BEGIN KEY-----\nabc123\n-----END KEY-----",
-	APP_URL: "https://example.com",
-	ASSET_URL: "https://example.com",
-	DB_HOST: "localhost",
 };
 
 // How each value must be typed in the UI so the (unchanged) dotenv input
@@ -49,21 +46,9 @@ const inputEncoding: Record<string, string> = {
 	APOSTROPHE: "it's a test",
 	UNICODE: "héllo wörld 日本語 🚀",
 	MULTILINE_PEM: '"-----BEGIN KEY-----\nabc123\n-----END KEY-----"',
-	APP_URL: "https://example.com",
-	ASSET_URL: '"${APP_URL}"',
-	DB_HOST: '"${UNDEFINED_HOST:-localhost}"',
 };
 
-const hasDocker = () => {
-	try {
-		execFileSync("docker", ["info"], { stdio: "ignore" });
-		return true;
-	} catch {
-		return false;
-	}
-};
-
-describe.skipIf(!hasDocker())("getCreateEnvFileCommand", () => {
+describe("getCreateEnvFileCommand", () => {
 	it("writes special environment values that Docker Compose reads back literally", () => {
 		mkdirSync(codePath, { recursive: true });
 

apps/dokploy/__test__/deploy/github-webhook-handler.test.ts

@@ -12,8 +12,6 @@ const mocks = vi.hoisted(() => ({
 	queueAdd: vi.fn(),
 	verify: vi.fn(),
 	shouldDeploy: vi.fn(),
-	createPreviewDeployment: vi.fn(),
-	findPreviewDeploymentByApplicationId: vi.fn(),
 }));
 
 vi.mock("drizzle-orm", () => ({
@@ -66,11 +64,10 @@ vi.mock("@dokploy/server", () => ({
 	IS_CLOUD: false,
 	shouldDeploy: mocks.shouldDeploy,
 	checkUserRepositoryPermissions: vi.fn(),
-	createPreviewDeployment: mocks.createPreviewDeployment,
+	createPreviewDeployment: vi.fn(),
 	createSecurityBlockedComment: vi.fn(),
 	findGithubById: vi.fn(),
-	findPreviewDeploymentByApplicationId:
-		mocks.findPreviewDeploymentByApplicationId,
+	findPreviewDeploymentByApplicationId: vi.fn(),
 	findPreviewDeploymentsByPullRequestId: vi.fn(),
 	getBitbucketHeaders: vi.fn(() => ({})),
 	removePreviewDeployment: vi.fn(),
@@ -324,157 +321,3 @@ describe("GitHub app webhook auto-deploy", () => {
 		expect(res.json).toHaveBeenCalledWith({ message: "No apps to deploy" });
 	});
 });
-
-describe("GitHub app webhook preview deployments", () => {
-	const createApplication = (
-		overrides: Record<string, unknown> = {},
-	): Record<string, unknown> => ({
-		applicationId: "application-id",
-		name: "my-app",
-		serverId: null,
-		previewLabels: [],
-		previewLimit: 3,
-		previewDeployments: [],
-		previewRequireCollaboratorPermissions: false,
-		...overrides,
-	});
-
-	const createPreviewDeployments = (total: number) =>
-		Array.from({ length: total }, (_, index) => ({
-			previewDeploymentId: `existing-preview-${index}`,
-		}));
-
-	const createPullRequestRequest = (action: string) =>
-		({
-			headers: {
-				"x-hub-signature-256": "sha256=test-signature",
-				"x-github-event": "pull_request",
-			},
-			body: {
-				installation: {
-					id: 12345,
-				},
-				action,
-				pull_request: {
-					id: 987,
-					number: 42,
-					title: "feat: add preview",
-					html_url: "https://github.com/agentHits/dokploy/pull/42",
-					labels: [],
-					user: {
-						login: "agentHits",
-					},
-					head: {
-						ref: "feature",
-						sha: "abc123",
-					},
-					base: {
-						ref: "main",
-					},
-				},
-				repository: {
-					name: "dokploy",
-					owner: {
-						login: "agentHits",
-					},
-				},
-			},
-		}) as unknown as NextApiRequest;
-
-	beforeEach(() => {
-		vi.clearAllMocks();
-		mocks.githubFindFirst.mockResolvedValue({
-			githubId: "github-provider-id",
-			githubInstallationId: 12345,
-			githubWebhookSecret: "webhook-secret",
-		});
-		mocks.verify.mockResolvedValue(true);
-		mocks.queueAdd.mockResolvedValue({ id: "job-id" });
-		mocks.createPreviewDeployment.mockResolvedValue({
-			previewDeploymentId: "new-preview-id",
-		});
-		mocks.findPreviewDeploymentByApplicationId.mockResolvedValue(undefined);
-	});
-
-	it("redeploys an existing preview even when the limit is reached", async () => {
-		mocks.applicationsFindMany.mockResolvedValue([
-			createApplication({
-				previewLimit: 2,
-				previewDeployments: createPreviewDeployments(3),
-			}),
-		]);
-		mocks.findPreviewDeploymentByApplicationId.mockResolvedValue({
-			previewDeploymentId: "existing-preview-0",
-		});
-		const res = createResponse();
-
-		await handler(createPullRequestRequest("synchronize"), res);
-
-		expect(mocks.createPreviewDeployment).not.toHaveBeenCalled();
-		expect(mocks.queueAdd).toHaveBeenCalledWith(
-			"deployments",
-			expect.objectContaining({
-				applicationId: "application-id",
-				applicationType: "application-preview",
-				previewDeploymentId: "existing-preview-0",
-				type: "deploy",
-			}),
-			expect.objectContaining({
-				removeOnComplete: true,
-				removeOnFail: true,
-			}),
-		);
-		expect(res.status).toHaveBeenCalledWith(200);
-	});
-
-	it("does not create a new preview once the limit is reached", async () => {
-		mocks.applicationsFindMany.mockResolvedValue([
-			createApplication({
-				previewLimit: 2,
-				previewDeployments: createPreviewDeployments(2),
-			}),
-		]);
-		const res = createResponse();
-
-		await handler(createPullRequestRequest("opened"), res);
-
-		expect(mocks.createPreviewDeployment).not.toHaveBeenCalled();
-		expect(mocks.queueAdd).not.toHaveBeenCalled();
-		expect(res.status).toHaveBeenCalledWith(200);
-	});
-
-	it("falls back to the default limit when none is configured", async () => {
-		mocks.applicationsFindMany.mockResolvedValue([
-			createApplication({
-				previewLimit: null,
-				previewDeployments: createPreviewDeployments(2),
-			}),
-		]);
-		const res = createResponse();
-
-		await handler(createPullRequestRequest("opened"), res);
-
-		expect(mocks.createPreviewDeployment).toHaveBeenCalledWith(
-			expect.objectContaining({
-				applicationId: "application-id",
-				branch: "feature",
-				pullRequestId: 987,
-				pullRequestNumber: 42,
-			}),
-		);
-		expect(mocks.queueAdd).toHaveBeenCalledWith(
-			"deployments",
-			expect.objectContaining({
-				applicationId: "application-id",
-				applicationType: "application-preview",
-				previewDeploymentId: "new-preview-id",
-				type: "deploy",
-			}),
-			expect.objectContaining({
-				removeOnComplete: true,
-				removeOnFail: true,
-			}),
-		);
-		expect(res.status).toHaveBeenCalledWith(200);
-	});
-});

apps/dokploy/__test__/deploy/railpack.command.test.ts

@@ -50,15 +50,6 @@ describe("getRailpackCommand", () => {
 		expect(command).toContain("--build-arg cache-key=");
 	});
 
-	it("installs Railpack through sudo for non-root users", () => {
-		const command = getRailpackCommand(createApplication());
-
-		expect(command).toContain(
-			'$SUDO_CMD bash -c "$(curl -fsSL https://railpack.com/install.sh)"',
-		);
-		expect(command).toContain("sudo -n true 2>/dev/null");
-	});
-
 	it("changes secrets-hash when an environment value changes", () => {
 		const firstCommand = getRailpackCommand(
 			createApplication({

apps/dokploy/__test__/deploy/should-deploy.test.ts

@@ -16,30 +16,6 @@ describe("shouldDeploy", () => {
 		expect(shouldDeploy(["src/**"], ["docs/readme.md"])).toBe(false);
 	});
 
-	it("should apply multiple negated watch paths as one pattern set", () => {
-		const watchPaths = ["!CHANGELOG.md", "!VERSION", "!tests/**"];
-
-		expect(shouldDeploy(watchPaths, ["CHANGELOG.md"])).toBe(false);
-		expect(shouldDeploy(watchPaths, ["VERSION"])).toBe(false);
-		expect(shouldDeploy(watchPaths, ["tests/unit/example.test.ts"])).toBe(
-			false,
-		);
-	});
-
-	it("should deploy when a changed file remains after exclusions", () => {
-		const watchPaths = ["!CHANGELOG.md", "!VERSION", "!tests/**"];
-
-		expect(shouldDeploy(watchPaths, ["VERSION", "src/index.ts"])).toBe(true);
-	});
-
-	it("should combine positive and negated watch paths", () => {
-		const watchPaths = ["src/**", "!src/**/*.test.ts"];
-
-		expect(shouldDeploy(watchPaths, ["src/index.ts"])).toBe(true);
-		expect(shouldDeploy(watchPaths, ["src/index.test.ts"])).toBe(false);
-		expect(shouldDeploy(watchPaths, ["docs/readme.md"])).toBe(false);
-	});
-
 	it("should not throw when modified files contain non-string values", () => {
 		expect(() =>
 			shouldDeploy(["src/**"], ["src/index.ts", undefined, null] as any),

apps/dokploy/__test__/dns/cloudflare.test.ts

@@ -1,453 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const mockFetch = vi.fn();
-global.fetch = mockFetch as typeof fetch;
-
-import { cloudflareClient } from "@dokploy/server/utils/dns/cloudflare";
-
-const jsonResponse = (body: unknown, ok = true, status = 200) =>
-	({
-		ok,
-		status,
-		json: async () => body,
-	}) as Response;
-
-const cfSuccess = (result: unknown) =>
-	jsonResponse({ success: true, errors: [], result });
-
-const cfError = (message: string, status = 400) =>
-	jsonResponse(
-		{ success: false, errors: [{ code: 1, message }] },
-		false,
-		status,
-	);
-
-const config = { providerType: "cloudflare" as const, apiToken: "cf-token" };
-
-beforeEach(() => {
-	mockFetch.mockReset();
-});
-
-describe("cloudflareClient.listZones", () => {
-	it("returns a single page of zones", async () => {
-		mockFetch.mockResolvedValue(cfSuccess([{ id: "z1", name: "example.com" }]));
-
-		const zones = await cloudflareClient.listZones(config);
-
-		expect(zones).toEqual([{ id: "z1", name: "example.com" }]);
-		expect(mockFetch).toHaveBeenCalledTimes(1);
-		const [url] = mockFetch.mock.calls[0] as [string];
-		expect(url).toContain("/zones?per_page=50&page=1");
-	});
-
-	it("paginates until a short page is returned", async () => {
-		const page = (count: number) =>
-			cfSuccess(
-				Array.from({ length: count }, (_, i) => ({
-					id: `z${i}`,
-					name: `zone${i}.com`,
-				})),
-			);
-		mockFetch.mockResolvedValueOnce(page(50)).mockResolvedValueOnce(page(3));
-
-		const zones = await cloudflareClient.listZones(config);
-
-		expect(zones).toHaveLength(53);
-		expect(mockFetch).toHaveBeenCalledTimes(2);
-		expect(mockFetch.mock.calls[1]?.[0]).toContain("page=2");
-	});
-});
-
-describe("cloudflareClient.listRecords", () => {
-	it("lists records for a zone", async () => {
-		mockFetch.mockResolvedValue(
-			cfSuccess([
-				{
-					id: "r1",
-					type: "A",
-					name: "app.example.com",
-					content: "1.2.3.4",
-					ttl: 1,
-				},
-			]),
-		);
-
-		const records = await cloudflareClient.listRecords(config, "zone-1");
-
-		expect(records).toEqual([
-			{
-				id: "r1",
-				type: "A",
-				name: "app.example.com",
-				content: "1.2.3.4",
-				ttl: 1,
-			},
-		]);
-		expect(mockFetch.mock.calls[0]?.[0]).toContain("/zones/zone-1/dns_records");
-	});
-});
-
-describe("cloudflareClient MX priority", () => {
-	it("inlines the priority into the content when listing", async () => {
-		mockFetch.mockResolvedValue(
-			cfSuccess([
-				{
-					id: "mx-1",
-					type: "MX",
-					name: "example.com",
-					content: "mail.example.com",
-					ttl: 300,
-					priority: 20,
-				},
-			]),
-		);
-
-		const records = await cloudflareClient.listRecords(config, "zone-1");
-
-		expect(records[0]?.content).toBe("20 mail.example.com");
-	});
-
-	it("splits the priority back out when writing", async () => {
-		mockFetch
-			.mockResolvedValueOnce(cfSuccess([]))
-			.mockResolvedValueOnce(cfSuccess({ id: "mx-1" }));
-
-		await cloudflareClient.upsertRecord(config, {
-			zoneId: "zone-1",
-			type: "MX",
-			name: "example.com",
-			content: "20 mail.example.com",
-		});
-
-		const [, init] = mockFetch.mock.calls[1] as [string, RequestInit];
-		expect(JSON.parse(init.body as string)).toMatchObject({
-			content: "mail.example.com",
-			priority: 20,
-		});
-	});
-
-	it("falls back to priority 10 when the content has no leading number", async () => {
-		mockFetch
-			.mockResolvedValueOnce(cfSuccess([]))
-			.mockResolvedValueOnce(cfSuccess({ id: "mx-1" }));
-
-		await cloudflareClient.upsertRecord(config, {
-			zoneId: "zone-1",
-			type: "MX",
-			name: "example.com",
-			content: "mail.example.com",
-		});
-
-		const [, init] = mockFetch.mock.calls[1] as [string, RequestInit];
-		expect(JSON.parse(init.body as string)).toMatchObject({
-			content: "mail.example.com",
-			priority: 10,
-		});
-	});
-
-	it("leaves non-MX content untouched", async () => {
-		mockFetch
-			.mockResolvedValueOnce(cfSuccess([]))
-			.mockResolvedValueOnce(cfSuccess({ id: "txt-1" }));
-
-		await cloudflareClient.upsertRecord(config, {
-			zoneId: "zone-1",
-			type: "TXT",
-			name: "example.com",
-			content: "10 not-a-priority",
-		});
-
-		const [, init] = mockFetch.mock.calls[1] as [string, RequestInit];
-		const body = JSON.parse(init.body as string);
-		expect(body.content).toBe("10 not-a-priority");
-		expect(body.priority).toBeUndefined();
-	});
-});
-
-describe("cloudflareClient structured records", () => {
-	const stubCreate = () =>
-		mockFetch
-			.mockResolvedValueOnce(cfSuccess([]))
-			.mockResolvedValueOnce(cfSuccess({ id: "rec-1" }));
-
-	it("sends SRV values as structured data", async () => {
-		stubCreate();
-
-		await cloudflareClient.upsertRecord(config, {
-			zoneId: "zone-1",
-			type: "SRV",
-			name: "_sip._tcp.example.com",
-			content: "1 10 5269 talk.example.com",
-		});
-
-		const [, init] = mockFetch.mock.calls[1] as [string, RequestInit];
-		const body = JSON.parse(init.body as string);
-		expect(body.data).toEqual({
-			priority: 1,
-			weight: 10,
-			port: 5269,
-			target: "talk.example.com",
-		});
-		expect(body.content).toBeUndefined();
-	});
-
-	it("sends CAA values as structured data and drops the quotes", async () => {
-		stubCreate();
-
-		await cloudflareClient.upsertRecord(config, {
-			zoneId: "zone-1",
-			type: "CAA",
-			name: "example.com",
-			content: '0 issue "letsencrypt.org"',
-		});
-
-		const [, init] = mockFetch.mock.calls[1] as [string, RequestInit];
-		const body = JSON.parse(init.body as string);
-		expect(body.data).toEqual({
-			flags: 0,
-			tag: "issue",
-			value: "letsencrypt.org",
-		});
-		expect(body.content).toBeUndefined();
-	});
-
-	it("rejects an SRV value that is missing a part", async () => {
-		await expect(
-			cloudflareClient.upsertRecord(config, {
-				zoneId: "zone-1",
-				type: "SRV",
-				name: "_sip._tcp.example.com",
-				content: "1 10 5269",
-			}),
-		).rejects.toThrow(/SRV value/);
-	});
-
-	it("rejects a CAA value that has no tag", async () => {
-		await expect(
-			cloudflareClient.upsertRecord(config, {
-				zoneId: "zone-1",
-				type: "CAA",
-				name: "example.com",
-				content: "0",
-			}),
-		).rejects.toThrow(/CAA value/);
-	});
-});
-
-describe("cloudflareClient proxy status", () => {
-	it("sends the proxy status for proxiable types", async () => {
-		mockFetch
-			.mockResolvedValueOnce(cfSuccess([]))
-			.mockResolvedValueOnce(cfSuccess({ id: "a-1" }));
-
-		await cloudflareClient.upsertRecord(config, {
-			zoneId: "zone-1",
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-			proxied: true,
-		});
-
-		const [, init] = mockFetch.mock.calls[1] as [string, RequestInit];
-		expect(JSON.parse(init.body as string).proxied).toBe(true);
-	});
-
-	it("omits the proxy status for types Cloudflare cannot proxy", async () => {
-		mockFetch
-			.mockResolvedValueOnce(cfSuccess([]))
-			.mockResolvedValueOnce(cfSuccess({ id: "txt-1" }));
-
-		await cloudflareClient.upsertRecord(config, {
-			zoneId: "zone-1",
-			type: "TXT",
-			name: "example.com",
-			content: "hello",
-			proxied: true,
-		});
-
-		const [, init] = mockFetch.mock.calls[1] as [string, RequestInit];
-		expect(JSON.parse(init.body as string).proxied).toBeUndefined();
-	});
-
-	it("leaves the proxy status untouched when the caller does not set it", async () => {
-		mockFetch
-			.mockResolvedValueOnce(cfSuccess([]))
-			.mockResolvedValueOnce(cfSuccess({ id: "a-1" }));
-
-		await cloudflareClient.upsertRecord(config, {
-			zoneId: "zone-1",
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-		});
-
-		const [, init] = mockFetch.mock.calls[1] as [string, RequestInit];
-		expect("proxied" in JSON.parse(init.body as string)).toBe(false);
-	});
-
-	it("returns the proxy status when listing records", async () => {
-		mockFetch.mockResolvedValue(
-			cfSuccess([
-				{
-					id: "a-1",
-					type: "A",
-					name: "app.example.com",
-					content: "1.2.3.4",
-					ttl: 1,
-					proxied: true,
-				},
-			]),
-		);
-
-		const records = await cloudflareClient.listRecords(config, "zone-1");
-
-		expect(records[0]?.proxied).toBe(true);
-	});
-});
-
-describe("cloudflareClient.upsertRecord", () => {
-	it("creates a record when none exists for the name/type", async () => {
-		mockFetch
-			.mockResolvedValueOnce(cfSuccess([]))
-			.mockResolvedValueOnce(cfSuccess({ id: "new-1" }));
-
-		const result = await cloudflareClient.upsertRecord(config, {
-			zoneId: "zone-1",
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-		});
-
-		expect(result).toEqual({ id: "new-1" });
-		const [, createInit] = mockFetch.mock.calls[1] as [string, RequestInit];
-		expect(createInit.method).toBe("POST");
-	});
-
-	it("updates the existing record when content matches", async () => {
-		mockFetch
-			.mockResolvedValueOnce(
-				cfSuccess([{ id: "existing-1", type: "A", content: "5.6.7.8" }]),
-			)
-			.mockResolvedValueOnce(cfSuccess({ id: "existing-1" }));
-
-		const result = await cloudflareClient.upsertRecord(config, {
-			zoneId: "zone-1",
-			type: "A",
-			name: "app.example.com",
-			content: "5.6.7.8",
-		});
-
-		expect(result).toEqual({ id: "existing-1" });
-		const [updateUrl, updateInit] = mockFetch.mock.calls[1] as [
-			string,
-			RequestInit,
-		];
-		expect(updateUrl).toContain("/dns_records/existing-1");
-		expect(updateInit.method).toBe("PUT");
-	});
-
-	it("creates a new record when content differs from existing", async () => {
-		mockFetch
-			.mockResolvedValueOnce(
-				cfSuccess([{ id: "existing-1", type: "A", content: "1.1.1.1" }]),
-			)
-			.mockResolvedValueOnce(cfSuccess({ id: "new-2" }));
-
-		const result = await cloudflareClient.upsertRecord(config, {
-			zoneId: "zone-1",
-			type: "A",
-			name: "app.example.com",
-			content: "5.6.7.8",
-		});
-
-		expect(result).toEqual({ id: "new-2" });
-		const [, createInit] = mockFetch.mock.calls[1] as [string, RequestInit];
-		expect(createInit.method).toBe("POST");
-	});
-
-	it("defaults ttl to 1 (automatic) when not provided", async () => {
-		mockFetch
-			.mockResolvedValueOnce(cfSuccess([]))
-			.mockResolvedValueOnce(cfSuccess({ id: "new-1" }));
-
-		await cloudflareClient.upsertRecord(config, {
-			zoneId: "zone-1",
-			type: "CNAME",
-			name: "www.example.com",
-			content: "example.com",
-		});
-
-		const [, createInit] = mockFetch.mock.calls[1] as [string, RequestInit];
-		const body = JSON.parse(createInit.body as string);
-		expect(body.ttl).toBe(1);
-	});
-});
-
-describe("cloudflareClient.updateRecord", () => {
-	it("PUTs directly to the given record id", async () => {
-		mockFetch.mockResolvedValue(cfSuccess({ id: "r1" }));
-
-		const result = await cloudflareClient.updateRecord(config, "zone-1", "r1", {
-			type: "A",
-			name: "app.example.com",
-			content: "9.9.9.9",
-			ttl: 300,
-		});
-
-		expect(result).toEqual({ id: "r1" });
-		const [url, init] = mockFetch.mock.calls[0] as [string, RequestInit];
-		expect(url).toContain("/zones/zone-1/dns_records/r1");
-		expect(init.method).toBe("PUT");
-		expect(JSON.parse(init.body as string)).toEqual({
-			type: "A",
-			name: "app.example.com",
-			content: "9.9.9.9",
-			ttl: 300,
-		});
-	});
-});
-
-describe("cloudflareClient.deleteRecord", () => {
-	it("DELETEs the given record id", async () => {
-		mockFetch.mockResolvedValue(cfSuccess({}));
-
-		await cloudflareClient.deleteRecord(config, "zone-1", "r1");
-
-		const [url, init] = mockFetch.mock.calls[0] as [string, RequestInit];
-		expect(url).toContain("/zones/zone-1/dns_records/r1");
-		expect(init.method).toBe("DELETE");
-	});
-});
-
-describe("cloudflareClient.testConnection", () => {
-	it("succeeds when the token can list zones", async () => {
-		mockFetch.mockResolvedValue(cfSuccess([]));
-		await expect(
-			cloudflareClient.testConnection(config),
-		).resolves.toBeUndefined();
-	});
-
-	it("surfaces Cloudflare's error message on an invalid token", async () => {
-		mockFetch.mockResolvedValue(cfError("Invalid API Token"));
-
-		await expect(cloudflareClient.testConnection(config)).rejects.toThrow(
-			"Invalid API Token",
-		);
-	});
-});
-
-describe("cloudflareClient auth header", () => {
-	it("trims whitespace pasted into the token", async () => {
-		mockFetch.mockResolvedValue(cfSuccess([]));
-
-		await cloudflareClient.testConnection({
-			providerType: "cloudflare",
-			apiToken: "  cf-token\n",
-		});
-
-		const [, init] = mockFetch.mock.calls[0] as [string, RequestInit];
-		expect((init.headers as Record<string, string>).Authorization).toBe(
-			"Bearer cf-token",
-		);
-	});
-});

apps/dokploy/__test__/dns/dns-provider-service.test.ts

@@ -1,116 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-vi.mock("@dokploy/server/db", () => ({
-	db: {
-		query: { dnsProvider: { findFirst: vi.fn(), findMany: vi.fn() } },
-		insert: vi.fn(),
-		update: vi.fn(),
-		delete: vi.fn(),
-	},
-}));
-
-import {
-	DNS_SECRET_MASK,
-	maskDnsProviderConfig,
-	mergeDnsProviderConfig,
-} from "@dokploy/server/services/dns-provider";
-
-describe("maskDnsProviderConfig", () => {
-	it("masks the apiToken for a cloudflare config", () => {
-		const masked = maskDnsProviderConfig({
-			providerType: "cloudflare",
-			apiToken: "real-token",
-		});
-
-		expect(masked).toEqual({
-			providerType: "cloudflare",
-			apiToken: DNS_SECRET_MASK,
-		});
-	});
-
-	it("masks only the secretAccessKey for a route53 config, keeping accessKeyId visible", () => {
-		const masked = maskDnsProviderConfig({
-			providerType: "route53",
-			accessKeyId: "AKIA_VISIBLE",
-			secretAccessKey: "shh",
-		});
-
-		expect(masked).toEqual({
-			providerType: "route53",
-			accessKeyId: "AKIA_VISIBLE",
-			secretAccessKey: DNS_SECRET_MASK,
-		});
-	});
-
-	it("leaves an empty sensitive field untouched instead of masking a blank value", () => {
-		const masked = maskDnsProviderConfig({
-			providerType: "cloudflare",
-			apiToken: "",
-		});
-
-		expect(masked).toEqual({ providerType: "cloudflare", apiToken: "" });
-	});
-});
-
-describe("mergeDnsProviderConfig", () => {
-	it("restores the real secret when the incoming config still has the mask placeholder", () => {
-		const existing = {
-			providerType: "cloudflare" as const,
-			apiToken: "real-token",
-		};
-		const incoming = {
-			providerType: "cloudflare" as const,
-			apiToken: DNS_SECRET_MASK,
-		};
-
-		expect(mergeDnsProviderConfig(incoming, existing)).toEqual(existing);
-	});
-
-	it("keeps a freshly entered secret instead of the stored one", () => {
-		const existing = {
-			providerType: "cloudflare" as const,
-			apiToken: "old-token",
-		};
-		const incoming = {
-			providerType: "cloudflare" as const,
-			apiToken: "new-token",
-		};
-
-		expect(mergeDnsProviderConfig(incoming, existing)).toEqual(incoming);
-	});
-
-	it("throws when switching provider type while the field is still masked", () => {
-		const existing = {
-			providerType: "cloudflare" as const,
-			apiToken: "real-token",
-		};
-		const incoming = {
-			providerType: "route53" as const,
-			accessKeyId: "AKIA",
-			secretAccessKey: DNS_SECRET_MASK,
-		};
-
-		expect(() => mergeDnsProviderConfig(incoming, existing)).toThrow(
-			"Credentials must be re-entered",
-		);
-	});
-
-	it("does not require re-entry for fields that are not sensitive", () => {
-		const existing = {
-			providerType: "route53" as const,
-			accessKeyId: "AKIA_OLD",
-			secretAccessKey: "old-secret",
-		};
-		const incoming = {
-			providerType: "route53" as const,
-			accessKeyId: "AKIA_NEW",
-			secretAccessKey: DNS_SECRET_MASK,
-		};
-
-		expect(mergeDnsProviderConfig(incoming, existing)).toEqual({
-			providerType: "route53",
-			accessKeyId: "AKIA_NEW",
-			secretAccessKey: "old-secret",
-		});
-	});
-});

apps/dokploy/__test__/dns/infomaniak.test.ts

@@ -1,486 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const mockFetch = vi.fn();
-global.fetch = mockFetch as typeof fetch;
-
-import { infomaniakClient } from "@dokploy/server/utils/dns/infomaniak";
-
-const jsonResponse = (body: unknown, ok = true, status = 200) =>
-	({
-		ok,
-		status,
-		json: async () => body,
-	}) as Response;
-
-const ikSuccess = (data: unknown) => jsonResponse({ result: "success", data });
-
-const ikPage = (data: unknown, page: number, pages: number) =>
-	jsonResponse({ result: "success", data, page, pages });
-
-const ikError = (description: string, status = 400) =>
-	jsonResponse(
-		{ result: "error", error: { code: "not_authorized", description } },
-		false,
-		status,
-	);
-
-const config = {
-	providerType: "infomaniak" as const,
-	apiToken: "ik_test_token",
-};
-
-const lastCall = () =>
-	mockFetch.mock.calls.at(-1) as [string, RequestInit & { method?: string }];
-
-const lastBody = () => JSON.parse(lastCall()[1].body as string);
-
-beforeEach(() => {
-	mockFetch.mockReset();
-});
-
-describe("infomaniakClient.listZones", () => {
-	it("exposes each domain product as a zone keyed by its name", async () => {
-		mockFetch.mockResolvedValue(
-			ikPage(
-				[
-					{ id: 1, customer_name: "example.com" },
-					{ id: 2, customer_name: "example.ch" },
-				],
-				1,
-				1,
-			),
-		);
-
-		const zones = await infomaniakClient.listZones(config);
-
-		expect(zones).toEqual([
-			{ id: "example.com", name: "example.com" },
-			{ id: "example.ch", name: "example.ch" },
-		]);
-		const [url, init] = lastCall();
-		// The documented endpoint is the plural one; the singular is legacy and
-		// returns no pagination metadata at all.
-		expect(url).toContain("/1/products?service_name=domain");
-		expect(url).toContain("page=1");
-		expect(init.headers).toMatchObject({
-			Authorization: "Bearer ik_test_token",
-		});
-	});
-
-	it("walks every page so accounts with many domains keep all their zones", async () => {
-		mockFetch
-			.mockResolvedValueOnce(ikPage([{ id: 1, customer_name: "a.com" }], 1, 3))
-			.mockResolvedValueOnce(ikPage([{ id: 2, customer_name: "b.com" }], 2, 3))
-			.mockResolvedValueOnce(ikPage([{ id: 3, customer_name: "c.com" }], 3, 3));
-
-		const zones = await infomaniakClient.listZones(config);
-
-		expect(zones.map((zone) => zone.name)).toEqual(["a.com", "b.com", "c.com"]);
-		expect(mockFetch).toHaveBeenCalledTimes(3);
-		expect((mockFetch.mock.calls[2] as [string])[0]).toContain("page=3");
-	});
-
-	it("stops after a single page when the response has no pagination", async () => {
-		mockFetch.mockResolvedValue(ikSuccess([{ id: 1, customer_name: "a.com" }]));
-
-		const zones = await infomaniakClient.listZones(config);
-
-		expect(zones).toEqual([{ id: "a.com", name: "a.com" }]);
-		expect(mockFetch).toHaveBeenCalledTimes(1);
-	});
-
-	it("propagates the API error description", async () => {
-		mockFetch.mockResolvedValue(ikError("Authorization required", 401));
-
-		await expect(infomaniakClient.listZones(config)).rejects.toThrow(
-			"Authorization required",
-		);
-	});
-});
-
-describe("infomaniakClient.listRecords", () => {
-	it("rebuilds the fqdn from the relative source", async () => {
-		mockFetch.mockResolvedValue(
-			ikSuccess([
-				{ id: 10, type: "A", source: "app", target: "1.2.3.4", ttl: 300 },
-				{ id: 11, type: "A", source: "", target: "5.6.7.8", ttl: 600 },
-			]),
-		);
-
-		const records = await infomaniakClient.listRecords(config, "example.com");
-
-		expect(records).toEqual([
-			{
-				id: "10",
-				type: "A",
-				name: "app.example.com",
-				content: "1.2.3.4",
-				ttl: 300,
-			},
-			{
-				id: "11",
-				type: "A",
-				name: "example.com",
-				content: "5.6.7.8",
-				ttl: 600,
-			},
-		]);
-		expect(lastCall()[0]).toBe(
-			"https://api.infomaniak.com/2/zones/example.com/records?with=records_description",
-		);
-	});
-
-	it.each([".", "", "@"])("treats a %s source as the apex", async (source) => {
-		mockFetch.mockResolvedValue(
-			ikSuccess([{ id: 12, type: "A", source, target: "1.2.3.4", ttl: 300 }]),
-		);
-
-		const records = await infomaniakClient.listRecords(config, "example.com");
-
-		expect(records[0]?.name).toBe("example.com");
-	});
-
-	it("unquotes TXT targets", async () => {
-		mockFetch.mockResolvedValue(
-			ikSuccess([
-				{
-					id: 13,
-					type: "TXT",
-					source: "_acme-challenge",
-					target: '"token-value"',
-					ttl: 300,
-				},
-			]),
-		);
-
-		const records = await infomaniakClient.listRecords(config, "example.com");
-
-		expect(records[0]?.content).toBe("token-value");
-	});
-
-	it("leaves a CAA target untouched", async () => {
-		mockFetch.mockResolvedValue(
-			ikSuccess([
-				{
-					id: 14,
-					type: "CAA",
-					source: "",
-					target: '0 issue "letsencrypt.org"',
-					ttl: 300,
-				},
-			]),
-		);
-
-		const records = await infomaniakClient.listRecords(config, "example.com");
-
-		expect(records[0]?.content).toBe('0 issue "letsencrypt.org"');
-	});
-});
-
-describe("infomaniakClient.upsertRecord", () => {
-	it("creates the record when no matching source and type exists", async () => {
-		mockFetch
-			.mockResolvedValueOnce(ikSuccess([]))
-			.mockResolvedValueOnce(ikSuccess({ id: 42 }));
-
-		const result = await infomaniakClient.upsertRecord(config, {
-			zoneId: "example.com",
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-			ttl: 600,
-		});
-
-		expect(result).toEqual({ id: "42" });
-		const [url, init] = lastCall();
-		expect(url).toBe("https://api.infomaniak.com/2/zones/example.com/records");
-		expect(init.method).toBe("POST");
-		expect(lastBody()).toEqual({
-			type: "A",
-			source: "app",
-			target: "1.2.3.4",
-			ttl: 600,
-		});
-	});
-
-	it("updates the existing record when content matches", async () => {
-		mockFetch
-			.mockResolvedValueOnce(
-				ikSuccess([
-					{ id: 7, type: "A", source: "app", target: "1.2.3.4", ttl: 300 },
-				]),
-			)
-			.mockResolvedValueOnce(ikSuccess({ id: 7 }));
-
-		const result = await infomaniakClient.upsertRecord(config, {
-			zoneId: "example.com",
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-		});
-
-		expect(result).toEqual({ id: "7" });
-		const [url, init] = lastCall();
-		expect(url).toBe(
-			"https://api.infomaniak.com/2/zones/example.com/records/7",
-		);
-		expect(init.method).toBe("PUT");
-		expect(lastBody().ttl).toBe(300);
-	});
-
-	it("creates a new record when content differs from existing", async () => {
-		mockFetch
-			.mockResolvedValueOnce(
-				ikSuccess([
-					{ id: 7, type: "A", source: "app", target: "1.1.1.1", ttl: 300 },
-				]),
-			)
-			.mockResolvedValueOnce(ikSuccess({ id: 50 }));
-
-		const result = await infomaniakClient.upsertRecord(config, {
-			zoneId: "example.com",
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-		});
-
-		expect(result).toEqual({ id: "50" });
-		const [url, init] = lastCall();
-		expect(url).toBe("https://api.infomaniak.com/2/zones/example.com/records");
-		expect(init.method).toBe("POST");
-	});
-
-	it("writes a root dot as the source for an apex record and strips the trailing dot", async () => {
-		mockFetch
-			.mockResolvedValueOnce(ikSuccess([]))
-			.mockResolvedValueOnce(ikSuccess({ id: 43 }));
-
-		await infomaniakClient.upsertRecord(config, {
-			zoneId: "example.com",
-			type: "A",
-			name: "example.com.",
-			content: "1.2.3.4",
-		});
-
-		expect(lastBody().source).toBe(".");
-	});
-
-	it.each([".", "", "@"])(
-		"matches an existing apex record stored with a %s source",
-		async (source) => {
-			mockFetch
-				.mockResolvedValueOnce(
-					ikSuccess([
-						{ id: 8, type: "A", source, target: "1.2.3.4", ttl: 3600 },
-					]),
-				)
-				.mockResolvedValueOnce(ikSuccess({ id: 8 }));
-
-			const result = await infomaniakClient.upsertRecord(config, {
-				zoneId: "example.com",
-				type: "A",
-				name: "example.com",
-				content: "1.2.3.4",
-			});
-
-			expect(result).toEqual({ id: "8" });
-			expect(lastCall()[1].method).toBe("PUT");
-		},
-	);
-
-	it("matches the existing apex record instead of creating a duplicate", async () => {
-		mockFetch
-			.mockResolvedValueOnce(
-				ikSuccess([
-					{
-						id: 8,
-						type: "TXT",
-						source: ".",
-						target: '"v=spf1 -all"',
-						ttl: 3600,
-					},
-				]),
-			)
-			.mockResolvedValueOnce(ikSuccess({ id: 8 }));
-
-		const result = await infomaniakClient.upsertRecord(config, {
-			zoneId: "example.com",
-			type: "TXT",
-			name: "example.com",
-			content: "v=spf1 -all",
-		});
-
-		expect(result).toEqual({ id: "8" });
-		const [url, init] = lastCall();
-		expect(init.method).toBe("PUT");
-		expect(url).toBe(
-			"https://api.infomaniak.com/2/zones/example.com/records/8",
-		);
-		expect(lastBody().target).toBe('"v=spf1 -all"');
-	});
-
-	it("quotes a TXT target on write", async () => {
-		mockFetch
-			.mockResolvedValueOnce(ikSuccess([]))
-			.mockResolvedValueOnce(ikSuccess({ id: 44 }));
-
-		await infomaniakClient.upsertRecord(config, {
-			zoneId: "example.com",
-			type: "TXT",
-			name: "_acme-challenge.example.com",
-			content: "token-value",
-		});
-
-		expect(lastBody().target).toBe('"token-value"');
-	});
-
-	it("does not double-quote a TXT target that is already quoted", async () => {
-		mockFetch
-			.mockResolvedValueOnce(ikSuccess([]))
-			.mockResolvedValueOnce(ikSuccess({ id: 45 }));
-
-		await infomaniakClient.upsertRecord(config, {
-			zoneId: "example.com",
-			type: "TXT",
-			name: "_acme-challenge.example.com",
-			content: '"token-value"',
-		});
-
-		expect(lastBody().target).toBe('"token-value"');
-	});
-
-	it("queries the API with a source and type filter instead of the whole zone", async () => {
-		mockFetch
-			.mockResolvedValueOnce(ikSuccess([]))
-			.mockResolvedValueOnce(ikSuccess({ id: 50 }));
-
-		await infomaniakClient.upsertRecord(config, {
-			zoneId: "example.com",
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-		});
-
-		const [url] = mockFetch.mock.calls[0] as [string];
-		expect(url).toContain("filter%5Bsource%5D=app");
-		expect(url).toContain("filter%5Btypes%5D%5B%5D=A");
-	});
-
-	it("ignores a partial filter hit rather than overwriting a different record", async () => {
-		// filter[source] matches substrings: asking for "auto" also returns
-		// "autoconfig" and "autodiscover". Trusting it would overwrite one of them.
-		mockFetch
-			.mockResolvedValueOnce(
-				ikSuccess([
-					{
-						id: 61,
-						type: "CNAME",
-						source: "autoconfig",
-						target: "a.example.net",
-						ttl: 300,
-					},
-					{
-						id: 62,
-						type: "CNAME",
-						source: "autodiscover",
-						target: "b.example.net",
-						ttl: 300,
-					},
-				]),
-			)
-			.mockResolvedValueOnce(ikSuccess({ id: 63 }));
-
-		const result = await infomaniakClient.upsertRecord(config, {
-			zoneId: "example.com",
-			type: "CNAME",
-			name: "auto.example.com",
-			content: "c.example.net",
-		});
-
-		expect(result).toEqual({ id: "63" });
-		expect(lastCall()[1].method).toBe("POST");
-	});
-});
-
-describe("infomaniakClient.updateRecord", () => {
-	it("updates the record and keeps its id", async () => {
-		mockFetch.mockResolvedValue(ikSuccess({ id: 7 }));
-
-		const result = await infomaniakClient.updateRecord(
-			config,
-			"example.com",
-			"7",
-			{
-				type: "CNAME",
-				name: "www.example.com",
-				content: "example.com",
-				ttl: 900,
-			},
-		);
-
-		expect(result).toEqual({ id: "7" });
-		const [url, init] = lastCall();
-		expect(url).toBe(
-			"https://api.infomaniak.com/2/zones/example.com/records/7",
-		);
-		expect(init.method).toBe("PUT");
-		expect(lastBody()).toEqual({
-			type: "CNAME",
-			source: "www",
-			target: "example.com",
-			ttl: 900,
-		});
-	});
-
-	it("falls back to the default ttl when none is provided", async () => {
-		mockFetch.mockResolvedValue(ikSuccess({ id: 7 }));
-
-		await infomaniakClient.updateRecord(config, "example.com", "7", {
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-		});
-
-		expect(lastBody().ttl).toBe(300);
-	});
-});
-
-describe("infomaniakClient.deleteRecord", () => {
-	it("deletes the record", async () => {
-		mockFetch.mockResolvedValue(ikSuccess(null));
-
-		await infomaniakClient.deleteRecord(config, "example.com", "7");
-
-		const [url, init] = lastCall();
-		expect(url).toBe(
-			"https://api.infomaniak.com/2/zones/example.com/records/7",
-		);
-		expect(init.method).toBe("DELETE");
-	});
-
-	it("propagates a delete failure", async () => {
-		mockFetch.mockResolvedValue(ikError("Record not found", 404));
-
-		await expect(
-			infomaniakClient.deleteRecord(config, "example.com", "7"),
-		).rejects.toThrow("Record not found");
-	});
-});
-
-describe("infomaniakClient.testConnection", () => {
-	it("resolves when the domain listing succeeds", async () => {
-		mockFetch.mockResolvedValue(ikSuccess([]));
-
-		await expect(
-			infomaniakClient.testConnection(config),
-		).resolves.toBeUndefined();
-	});
-
-	it("rejects on an invalid token", async () => {
-		mockFetch.mockResolvedValue(ikError("Authorization required", 401));
-
-		await expect(infomaniakClient.testConnection(config)).rejects.toThrow(
-			"Infomaniak: request to /1/products?service_name=domain&per_page=1 failed: Authorization required",
-		);
-	});
-});

apps/dokploy/__test__/dns/ovh.test.ts

@@ -1,581 +0,0 @@
-import { createHash } from "node:crypto";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const mockFetch = vi.fn();
-global.fetch = mockFetch as typeof fetch;
-
-import { ovhClient } from "@dokploy/server/utils/dns/ovh";
-
-const textResponse = (body: string, ok = true, status = 200) =>
-	({
-		ok,
-		status,
-		text: async () => body,
-	}) as Response;
-
-const ovhSuccess = (data: unknown) =>
-	textResponse(data === undefined ? "" : JSON.stringify(data));
-
-const ovhError = (message: string, status = 403) =>
-	textResponse(JSON.stringify({ message }), false, status);
-
-const SERVER_TIME = 1788268225;
-
-const config = {
-	providerType: "ovh" as const,
-	endpoint: "ovh-eu" as const,
-	applicationKey: "app-key",
-	applicationSecret: "app-secret",
-	consumerKey: "consumer-key",
-};
-
-// Each test uses a distinct endpoint so the module-level clock-skew cache, which
-// is keyed by base url, never leaks a measurement between them.
-let endpointCursor = 0;
-const endpoints = [
-	"ovh-eu",
-	"ovh-ca",
-	"ovh-us",
-	"kimsufi-eu",
-	"kimsufi-ca",
-	"soyoustart-eu",
-	"soyoustart-ca",
-] as const;
-const baseUrls: Record<(typeof endpoints)[number], string> = {
-	"ovh-eu": "https://eu.api.ovh.com/1.0",
-	"ovh-ca": "https://ca.api.ovh.com/1.0",
-	"ovh-us": "https://api.us.ovhcloud.com/1.0",
-	"kimsufi-eu": "https://eu.api.kimsufi.com/1.0",
-	"kimsufi-ca": "https://ca.api.kimsufi.com/1.0",
-	"soyoustart-eu": "https://eu.api.soyoustart.com/1.0",
-	"soyoustart-ca": "https://ca.api.soyoustart.com/1.0",
-};
-
-/** A config on a not-yet-used endpoint, so the first call always fetches /auth/time. */
-const freshConfig = () => {
-	const endpoint = endpoints[
-		endpointCursor % endpoints.length
-	] as (typeof endpoints)[number];
-	endpointCursor += 1;
-	return { ...config, endpoint, baseUrl: baseUrls[endpoint] };
-};
-
-/** Replies to /auth/time, then to each queued API response in order. */
-const mockApi = (...responses: Response[]) => {
-	let call = 0;
-	mockFetch.mockImplementation((url: string) => {
-		if (url.endsWith("/auth/time")) {
-			return Promise.resolve(textResponse(String(SERVER_TIME)));
-		}
-		const response = responses[call];
-		call += 1;
-		return Promise.resolve(response ?? ovhSuccess(null));
-	});
-};
-
-const apiCalls = () =>
-	mockFetch.mock.calls.filter(
-		([url]) => !(url as string).endsWith("/auth/time"),
-	) as [string, RequestInit][];
-
-beforeEach(() => {
-	mockFetch.mockReset();
-});
-
-describe("ovhClient request signing", () => {
-	it("signs the request with the API server clock, not the local one", async () => {
-		const { baseUrl, ...cfg } = freshConfig();
-		mockApi(ovhSuccess(["example.com"]));
-		vi.spyOn(Date, "now").mockReturnValue((SERVER_TIME - 120) * 1000);
-
-		await ovhClient.listZones(cfg);
-
-		const [url, init] = apiCalls()[0] as [string, RequestInit];
-		const headers = init.headers as Record<string, string>;
-		expect(url).toBe(`${baseUrl}/domain/zone`);
-		expect(headers["X-Ovh-Timestamp"]).toBe(String(SERVER_TIME));
-		expect(headers["X-Ovh-Application"]).toBe("app-key");
-		expect(headers["X-Ovh-Consumer"]).toBe("consumer-key");
-
-		const expected = createHash("sha1")
-			.update(
-				["app-secret", "consumer-key", "GET", url, "", SERVER_TIME].join("+"),
-			)
-			.digest("hex");
-		expect(headers["X-Ovh-Signature"]).toBe(`$1$${expected}`);
-
-		vi.restoreAllMocks();
-	});
-
-	it("signs a request body when one is sent", async () => {
-		const { baseUrl, ...cfg } = freshConfig();
-		mockApi(ovhSuccess([]), ovhSuccess({ id: 5 }), ovhSuccess(null));
-		vi.spyOn(Date, "now").mockReturnValue(SERVER_TIME * 1000);
-
-		await ovhClient.upsertRecord(cfg, {
-			zoneId: "example.com",
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-		});
-
-		const [url, init] = apiCalls()[1] as [string, RequestInit];
-		const headers = init.headers as Record<string, string>;
-		const body = init.body as string;
-		expect(body).not.toBe("");
-		const expected = createHash("sha1")
-			.update(
-				["app-secret", "consumer-key", "POST", url, body, SERVER_TIME].join(
-					"+",
-				),
-			)
-			.digest("hex");
-		expect(headers["X-Ovh-Signature"]).toBe(`$1$${expected}`);
-
-		vi.restoreAllMocks();
-	});
-});
-
-describe("ovhClient.listZones", () => {
-	it("maps each zone name to a zone", async () => {
-		const cfg = freshConfig();
-		mockApi(ovhSuccess(["example.com", "example.fr"]));
-
-		const zones = await ovhClient.listZones(cfg);
-
-		expect(zones).toEqual([
-			{ id: "example.com", name: "example.com" },
-			{ id: "example.fr", name: "example.fr" },
-		]);
-	});
-
-	it("names the missing root right when OVH refuses the zone listing", async () => {
-		const cfg = freshConfig();
-		mockApi(ovhError("This call has not been granted", 403));
-
-		// A `GET /domain/zone/*` rule does not cover the bare `GET /domain/zone`,
-		// so the raw OVH message would send users looking in the wrong place.
-		await expect(ovhClient.listZones(cfg)).rejects.toThrow(
-			/missing the `GET \/domain\/zone` right/,
-		);
-	});
-
-	it("propagates the API error message", async () => {
-		const cfg = freshConfig();
-		mockApi(ovhError("Invalid signature", 403));
-
-		await expect(ovhClient.listZones(cfg)).rejects.toThrow("Invalid signature");
-	});
-});
-
-describe("ovhClient.listRecords", () => {
-	it("resolves each id into a full record", async () => {
-		const cfg = freshConfig();
-		mockApi(
-			ovhSuccess([1, 2]),
-			ovhSuccess({
-				id: 1,
-				zone: "example.com",
-				fieldType: "A",
-				subDomain: "app",
-				target: "1.2.3.4",
-				ttl: 600,
-			}),
-			ovhSuccess({
-				id: 2,
-				zone: "example.com",
-				fieldType: "A",
-				subDomain: null,
-				target: "5.6.7.8",
-				ttl: null,
-			}),
-		);
-
-		const records = await ovhClient.listRecords(cfg, "example.com");
-
-		expect(records).toEqual([
-			{
-				id: "1",
-				type: "A",
-				name: "app.example.com",
-				content: "1.2.3.4",
-				ttl: 600,
-			},
-			{
-				id: "2",
-				type: "A",
-				name: "example.com",
-				content: "5.6.7.8",
-				ttl: 0,
-			},
-		]);
-	});
-
-	it("keeps the records in the order of the returned ids", async () => {
-		const cfg = freshConfig();
-		const record = (id: number, subDomain: string) => ({
-			id,
-			zone: "example.com",
-			fieldType: "A",
-			subDomain,
-			target: `10.0.0.${id}`,
-			ttl: 60,
-		});
-		mockApi(
-			ovhSuccess([1, 2, 3, 4, 5]),
-			...[1, 2, 3, 4, 5].map((id) => ovhSuccess(record(id, `host${id}`))),
-		);
-
-		const records = await ovhClient.listRecords(cfg, "example.com");
-
-		expect(records.map((r) => r.id)).toEqual(["1", "2", "3", "4", "5"]);
-	});
-});
-
-describe("ovhClient.upsertRecord", () => {
-	it("creates the record then refreshes the zone", async () => {
-		const cfg = freshConfig();
-		mockApi(ovhSuccess([]), ovhSuccess({ id: 9 }), ovhSuccess(null));
-
-		const result = await ovhClient.upsertRecord(cfg, {
-			zoneId: "example.com",
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-			ttl: 600,
-		});
-
-		expect(result).toEqual({ id: "9" });
-		const calls = apiCalls();
-		expect(calls[0]?.[0]).toContain(
-			"/domain/zone/example.com/record?fieldType=A&subDomain=app",
-		);
-		expect(calls[1]?.[1].method).toBe("POST");
-		expect(JSON.parse(calls[1]?.[1].body as string)).toEqual({
-			fieldType: "A",
-			subDomain: "app",
-			target: "1.2.3.4",
-			ttl: 600,
-		});
-		expect(calls[2]?.[0]).toContain("/domain/zone/example.com/refresh");
-		expect(calls[2]?.[1].method).toBe("POST");
-	});
-
-	it("updates the existing record when content matches", async () => {
-		const cfg = freshConfig();
-		mockApi(
-			ovhSuccess([4]),
-			ovhSuccess({
-				id: 4,
-				zone: "example.com",
-				fieldType: "A",
-				subDomain: "app",
-				target: "1.2.3.4",
-				ttl: 60,
-			}),
-			ovhSuccess(null),
-			ovhSuccess(null),
-		);
-
-		const result = await ovhClient.upsertRecord(cfg, {
-			zoneId: "example.com",
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-		});
-
-		expect(result).toEqual({ id: "4" });
-		const calls = apiCalls();
-		expect(calls[2]?.[0]).toContain("/domain/zone/example.com/record/4");
-		expect(calls[2]?.[1].method).toBe("PUT");
-		expect(calls[3]?.[0]).toContain("/refresh");
-	});
-
-	it("creates a new record when content differs from existing", async () => {
-		const cfg = freshConfig();
-		mockApi(
-			ovhSuccess([4]),
-			ovhSuccess({
-				id: 4,
-				zone: "example.com",
-				fieldType: "A",
-				subDomain: "app",
-				target: "1.1.1.1",
-				ttl: 60,
-			}),
-			ovhSuccess({ id: 10 }),
-			ovhSuccess(null),
-		);
-
-		const result = await ovhClient.upsertRecord(cfg, {
-			zoneId: "example.com",
-			type: "A",
-			name: "app.example.com",
-			content: "5.6.7.8",
-		});
-
-		expect(result).toEqual({ id: "10" });
-		const calls = apiCalls();
-		expect(calls[2]?.[1].method).toBe("POST");
-		expect(calls[3]?.[0]).toContain("/refresh");
-	});
-
-	it("omits the ttl so OVH applies the zone default", async () => {
-		const cfg = freshConfig();
-		mockApi(ovhSuccess([]), ovhSuccess({ id: 9 }), ovhSuccess(null));
-
-		await ovhClient.upsertRecord(cfg, {
-			zoneId: "example.com",
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-		});
-
-		expect(JSON.parse(apiCalls()[1]?.[1].body as string)).not.toHaveProperty(
-			"ttl",
-		);
-	});
-
-	it("writes an empty subDomain for the apex and strips the trailing dot", async () => {
-		const cfg = freshConfig();
-		mockApi(ovhSuccess([]), ovhSuccess({ id: 9 }), ovhSuccess(null));
-
-		await ovhClient.upsertRecord(cfg, {
-			zoneId: "example.com",
-			type: "A",
-			name: "example.com.",
-			content: "1.2.3.4",
-		});
-
-		expect(apiCalls()[0]?.[0]).toContain("subDomain=");
-		expect(JSON.parse(apiCalls()[1]?.[1].body as string).subDomain).toBe("");
-	});
-});
-
-describe("ovhClient.updateRecord", () => {
-	it("updates in place when the type is unchanged", async () => {
-		const cfg = freshConfig();
-		mockApi(
-			ovhSuccess({
-				id: 4,
-				zone: "example.com",
-				fieldType: "A",
-				subDomain: "app",
-				target: "1.1.1.1",
-				ttl: 60,
-			}),
-			ovhSuccess(null),
-			ovhSuccess(null),
-		);
-
-		const result = await ovhClient.updateRecord(cfg, "example.com", "4", {
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-			ttl: 300,
-		});
-
-		expect(result).toEqual({ id: "4" });
-		const calls = apiCalls();
-		expect(calls[1]?.[1].method).toBe("PUT");
-		expect(JSON.parse(calls[1]?.[1].body as string)).toEqual({
-			subDomain: "app",
-			target: "1.2.3.4",
-			ttl: 300,
-		});
-		expect(calls[2]?.[0]).toContain("/refresh");
-	});
-
-	it("replaces the record when the type changes, since PUT carries no fieldType", async () => {
-		const cfg = freshConfig();
-		mockApi(
-			ovhSuccess({
-				id: 4,
-				zone: "example.com",
-				fieldType: "A",
-				subDomain: "app",
-				target: "1.1.1.1",
-				ttl: 60,
-			}),
-			ovhSuccess(null),
-			ovhSuccess({ id: 11 }),
-			ovhSuccess(null),
-		);
-
-		const result = await ovhClient.updateRecord(cfg, "example.com", "4", {
-			type: "CNAME",
-			name: "app.example.com",
-			content: "example.com",
-		});
-
-		expect(result).toEqual({ id: "11" });
-		const calls = apiCalls();
-		expect(calls[1]?.[1].method).toBe("DELETE");
-		expect(calls[2]?.[1].method).toBe("POST");
-		expect(JSON.parse(calls[2]?.[1].body as string).fieldType).toBe("CNAME");
-		expect(calls[3]?.[0]).toContain("/refresh");
-	});
-
-	it("restores the original record when the replacement fails", async () => {
-		const cfg = freshConfig();
-		const original = {
-			id: 4,
-			zone: "example.com",
-			fieldType: "A",
-			subDomain: "app",
-			target: "1.1.1.1",
-			ttl: 60,
-		};
-		mockApi(
-			ovhSuccess(original),
-			ovhSuccess(null),
-			ovhError("Invalid target", 400),
-			ovhSuccess({ id: 12 }),
-			ovhSuccess(null),
-		);
-
-		await expect(
-			ovhClient.updateRecord(cfg, "example.com", "4", {
-				type: "CNAME",
-				name: "app.example.com",
-				content: "not a valid target",
-			}),
-		).rejects.toThrow("Invalid target");
-
-		const calls = apiCalls();
-		expect(calls[1]?.[1].method).toBe("DELETE");
-		expect(calls[2]?.[1].method).toBe("POST");
-		// The original record is put back with its own type, target and ttl.
-		expect(JSON.parse(calls[3]?.[1].body as string)).toEqual({
-			fieldType: "A",
-			subDomain: "app",
-			target: "1.1.1.1",
-			ttl: 60,
-		});
-		expect(calls[4]?.[0]).toContain("/refresh");
-	});
-
-	it("reports the lost record when the restore also fails", async () => {
-		const cfg = freshConfig();
-		mockApi(
-			ovhSuccess({
-				id: 4,
-				zone: "example.com",
-				fieldType: "A",
-				subDomain: "app",
-				target: "1.1.1.1",
-				ttl: 60,
-			}),
-			ovhSuccess(null),
-			ovhError("Invalid target", 400),
-			ovhError("Service unavailable", 503),
-		);
-
-		await expect(
-			ovhClient.updateRecord(cfg, "example.com", "4", {
-				type: "CNAME",
-				name: "app.example.com",
-				content: "not a valid target",
-			}),
-		).rejects.toThrow(
-			/Recreate it manually: A app\.example\.com -> 1\.1\.1\.1/,
-		);
-	});
-
-	it("says the change was applied when only the zone refresh fails", async () => {
-		const cfg = freshConfig();
-		mockApi(
-			ovhSuccess({
-				id: 4,
-				zone: "example.com",
-				fieldType: "A",
-				subDomain: "app",
-				target: "1.1.1.1",
-				ttl: 60,
-			}),
-			ovhSuccess(null),
-			ovhSuccess({ id: 11 }),
-			ovhError("Service unavailable", 503),
-		);
-
-		// The replacement succeeded, so the record exists at the provider — only
-		// publishing failed. Rolling back would destroy correct state.
-		await expect(
-			ovhClient.updateRecord(cfg, "example.com", "4", {
-				type: "CNAME",
-				name: "app.example.com",
-				content: "example.com",
-			}),
-		).rejects.toThrow(/was applied, but refreshing zone "example\.com" failed/);
-	});
-
-	it("does not tell the user to recreate a record that was restored but not published", async () => {
-		const cfg = freshConfig();
-		mockApi(
-			ovhSuccess({
-				id: 4,
-				zone: "example.com",
-				fieldType: "A",
-				subDomain: "app",
-				target: "1.1.1.1",
-				ttl: 60,
-			}),
-			ovhSuccess(null), // DELETE de l'ancien
-			ovhError("Invalid target", 400), // POST de remplacement -> échec
-			ovhSuccess({ id: 12 }), // POST de restauration -> succès
-			ovhError("Service unavailable", 503), // refresh -> échec
-		);
-
-		const attempt = ovhClient.updateRecord(cfg, "example.com", "4", {
-			type: "CNAME",
-			name: "app.example.com",
-			content: "not a valid target",
-		});
-
-		// L'enregistrement existe de nouveau chez OVH : le recréer le dupliquerait.
-		await expect(attempt).rejects.toThrow(/was restored, but refreshing zone/);
-		await expect(attempt).rejects.not.toThrow(/Recreate it manually/);
-	});
-});
-
-describe("ovhClient.deleteRecord", () => {
-	it("deletes the record then refreshes the zone", async () => {
-		const cfg = freshConfig();
-		mockApi(ovhSuccess(null), ovhSuccess(null));
-
-		await ovhClient.deleteRecord(cfg, "example.com", "4");
-
-		const calls = apiCalls();
-		expect(calls[0]?.[0]).toContain("/domain/zone/example.com/record/4");
-		expect(calls[0]?.[1].method).toBe("DELETE");
-		expect(calls[1]?.[0]).toContain("/domain/zone/example.com/refresh");
-	});
-
-	it("does not refresh the zone when the delete fails", async () => {
-		const cfg = freshConfig();
-		mockApi(ovhError("This object does not exist", 404));
-
-		await expect(
-			ovhClient.deleteRecord(cfg, "example.com", "4"),
-		).rejects.toThrow("This object does not exist");
-		expect(apiCalls()).toHaveLength(1);
-	});
-});
-
-describe("ovhClient.testConnection", () => {
-	it("resolves when the zone listing succeeds", async () => {
-		const cfg = freshConfig();
-		mockApi(ovhSuccess([]));
-
-		await expect(ovhClient.testConnection(cfg)).resolves.toBeUndefined();
-	});
-
-	it("rejects on invalid credentials", async () => {
-		const cfg = freshConfig();
-		mockApi(ovhError("Invalid signature", 403));
-
-		await expect(ovhClient.testConnection(cfg)).rejects.toThrow(
-			"Invalid signature",
-		);
-	});
-});

apps/dokploy/__test__/dns/porkbun.test.ts

@@ -1,237 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const mockFetch = vi.fn();
-global.fetch = mockFetch as typeof fetch;
-
-import { porkbunClient } from "@dokploy/server/utils/dns/porkbun";
-
-const jsonResponse = (body: unknown, ok = true, status = 200) =>
-	({
-		ok,
-		status,
-		json: async () => body,
-	}) as Response;
-
-const pbSuccess = (result: Record<string, unknown> = {}) =>
-	jsonResponse({ status: "SUCCESS", ...result });
-
-const pbError = (message: string, status = 400) =>
-	jsonResponse({ status: "ERROR", message }, false, status);
-
-const config = {
-	providerType: "porkbun" as const,
-	apiKey: "pk1_test",
-	secretApiKey: "sk1_test",
-};
-
-beforeEach(() => {
-	mockFetch.mockReset();
-});
-
-describe("porkbunClient.listZones", () => {
-	it("lists all domains as zones", async () => {
-		mockFetch.mockResolvedValue(
-			pbSuccess({ domains: [{ domain: "example.com" }] }),
-		);
-
-		const zones = await porkbunClient.listZones(config);
-
-		expect(zones).toEqual([{ id: "example.com", name: "example.com" }]);
-		const [url, init] = mockFetch.mock.calls[0] as [string, RequestInit];
-		expect(url).toContain("/domain/listAll");
-		const body = JSON.parse(init.body as string);
-		expect(body).toMatchObject({
-			apikey: "pk1_test",
-			secretapikey: "sk1_test",
-		});
-	});
-});
-
-describe("porkbunClient.listRecords", () => {
-	it("lists records for a domain", async () => {
-		mockFetch.mockResolvedValue(
-			pbSuccess({
-				records: [
-					{
-						id: "1",
-						type: "A",
-						name: "app.example.com",
-						content: "1.2.3.4",
-						ttl: "600",
-						prio: "0",
-						notes: "",
-					},
-				],
-			}),
-		);
-
-		const records = await porkbunClient.listRecords(config, "example.com");
-
-		expect(records).toEqual([
-			{
-				id: "1",
-				type: "A",
-				name: "app.example.com",
-				content: "1.2.3.4",
-				ttl: 600,
-			},
-		]);
-		expect(mockFetch.mock.calls[0]?.[0]).toContain("/dns/retrieve/example.com");
-	});
-});
-
-describe("porkbunClient.upsertRecord", () => {
-	it("creates a record when none exists for the name/type", async () => {
-		mockFetch
-			.mockResolvedValueOnce(pbSuccess({ records: [] }))
-			.mockResolvedValueOnce(pbSuccess({ id: "new-1" }));
-
-		const result = await porkbunClient.upsertRecord(config, {
-			zoneId: "example.com",
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-		});
-
-		expect(result).toEqual({ id: "new-1" });
-		const [lookupUrl] = mockFetch.mock.calls[0] as [string];
-		expect(lookupUrl).toContain("/dns/retrieveByNameType/example.com/A/app");
-		const [createUrl, createInit] = mockFetch.mock.calls[1] as [
-			string,
-			RequestInit,
-		];
-		expect(createUrl).toContain("/dns/create/example.com");
-		const body = JSON.parse(createInit.body as string);
-		expect(body).toMatchObject({ name: "app", type: "A", content: "1.2.3.4" });
-	});
-
-	it("resolves the apex domain to an empty subdomain", async () => {
-		mockFetch
-			.mockResolvedValueOnce(pbSuccess({ records: [] }))
-			.mockResolvedValueOnce(pbSuccess({ id: "new-2" }));
-
-		await porkbunClient.upsertRecord(config, {
-			zoneId: "example.com",
-			type: "A",
-			name: "example.com",
-			content: "1.2.3.4",
-		});
-
-		const [lookupUrl] = mockFetch.mock.calls[0] as [string];
-		expect(lookupUrl).toContain("/dns/retrieveByNameType/example.com/A/");
-	});
-
-	it("edits the existing record when content matches", async () => {
-		mockFetch
-			.mockResolvedValueOnce(
-				pbSuccess({ records: [{ id: "existing-1", content: "5.6.7.8" }] }),
-			)
-			.mockResolvedValueOnce(pbSuccess({}));
-
-		const result = await porkbunClient.upsertRecord(config, {
-			zoneId: "example.com",
-			type: "A",
-			name: "app.example.com",
-			content: "5.6.7.8",
-		});
-
-		expect(result).toEqual({ id: "existing-1" });
-		const [editUrl] = mockFetch.mock.calls[1] as [string, RequestInit];
-		expect(editUrl).toContain("/dns/edit/example.com/existing-1");
-	});
-
-	it("creates a new record when content differs from existing", async () => {
-		mockFetch
-			.mockResolvedValueOnce(
-				pbSuccess({ records: [{ id: "existing-1", content: "1.1.1.1" }] }),
-			)
-			.mockResolvedValueOnce(pbSuccess({ id: "new-2" }));
-
-		const result = await porkbunClient.upsertRecord(config, {
-			zoneId: "example.com",
-			type: "A",
-			name: "app.example.com",
-			content: "5.6.7.8",
-		});
-
-		expect(result).toEqual({ id: "new-2" });
-		const [createUrl, createInit] = mockFetch.mock.calls[1] as [
-			string,
-			RequestInit,
-		];
-		expect(createUrl).toContain("/dns/create/example.com");
-		const body = JSON.parse(createInit.body as string);
-		expect(body).toMatchObject({ name: "app", type: "A", content: "5.6.7.8" });
-	});
-
-	it("defaults ttl to 600 when not provided", async () => {
-		mockFetch
-			.mockResolvedValueOnce(pbSuccess({ records: [] }))
-			.mockResolvedValueOnce(pbSuccess({ id: "new-1" }));
-
-		await porkbunClient.upsertRecord(config, {
-			zoneId: "example.com",
-			type: "CNAME",
-			name: "www.example.com",
-			content: "example.com",
-		});
-
-		const [, createInit] = mockFetch.mock.calls[1] as [string, RequestInit];
-		const body = JSON.parse(createInit.body as string);
-		expect(body.ttl).toBe(600);
-	});
-});
-
-describe("porkbunClient.updateRecord", () => {
-	it("edits the given record id", async () => {
-		mockFetch.mockResolvedValue(pbSuccess({}));
-
-		const result = await porkbunClient.updateRecord(
-			config,
-			"example.com",
-			"1",
-			{
-				type: "A",
-				name: "app.example.com",
-				content: "9.9.9.9",
-				ttl: 300,
-			},
-		);
-
-		expect(result).toEqual({ id: "1" });
-		const [url, init] = mockFetch.mock.calls[0] as [string, RequestInit];
-		expect(url).toContain("/dns/edit/example.com/1");
-		expect(JSON.parse(init.body as string)).toMatchObject({
-			name: "app",
-			type: "A",
-			content: "9.9.9.9",
-			ttl: 300,
-		});
-	});
-});
-
-describe("porkbunClient.deleteRecord", () => {
-	it("posts to the delete endpoint for the given record id", async () => {
-		mockFetch.mockResolvedValue(pbSuccess({}));
-
-		await porkbunClient.deleteRecord(config, "example.com", "1");
-
-		const [url] = mockFetch.mock.calls[0] as [string];
-		expect(url).toContain("/dns/delete/example.com/1");
-	});
-});
-
-describe("porkbunClient.testConnection", () => {
-	it("succeeds when the credentials can ping the API", async () => {
-		mockFetch.mockResolvedValue(pbSuccess({}));
-		await expect(porkbunClient.testConnection(config)).resolves.toBeUndefined();
-	});
-
-	it("surfaces Porkbun's error message on invalid credentials", async () => {
-		mockFetch.mockResolvedValue(pbError("Invalid API key."));
-
-		await expect(porkbunClient.testConnection(config)).rejects.toThrow(
-			"Invalid API key.",
-		);
-	});
-});

apps/dokploy/__test__/dns/route53.test.ts

@@ -1,385 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-type HasInput = { input: any };
-
-const {
-	send,
-	Route53Client,
-	ListHostedZonesCommand,
-	ListResourceRecordSetsCommand,
-	ChangeResourceRecordSetsCommand,
-} = vi.hoisted(() => {
-	class FakeCommand {
-		input: any;
-		constructor(input: any) {
-			this.input = input;
-		}
-	}
-	const send = vi.fn();
-	class Route53Client {
-		send(command: unknown) {
-			return send(command);
-		}
-	}
-	return {
-		send,
-		Route53Client,
-		ListHostedZonesCommand: class extends FakeCommand {},
-		ListResourceRecordSetsCommand: class extends FakeCommand {},
-		ChangeResourceRecordSetsCommand: class extends FakeCommand {},
-	};
-});
-
-vi.mock("@aws-sdk/client-route-53", () => ({
-	Route53Client,
-	ListHostedZonesCommand,
-	ListResourceRecordSetsCommand,
-	ChangeResourceRecordSetsCommand,
-}));
-
-import { route53Client } from "@dokploy/server/utils/dns/route53";
-
-const config = {
-	providerType: "route53" as const,
-	accessKeyId: "AKIA_TEST",
-	secretAccessKey: "secret",
-};
-
-beforeEach(() => {
-	send.mockReset();
-});
-
-describe("route53Client.listZones", () => {
-	it("strips the hostedzone prefix and the trailing dot", async () => {
-		send.mockResolvedValueOnce({
-			HostedZones: [{ Id: "/hostedzone/Z123", Name: "example.com." }],
-			IsTruncated: false,
-		});
-
-		const zones = await route53Client.listZones(config);
-
-		expect(zones).toEqual([{ id: "Z123", name: "example.com" }]);
-	});
-
-	it("follows the marker until IsTruncated is false", async () => {
-		send
-			.mockResolvedValueOnce({
-				HostedZones: [{ Id: "/hostedzone/Z1", Name: "a.com." }],
-				IsTruncated: true,
-				NextMarker: "marker-1",
-			})
-			.mockResolvedValueOnce({
-				HostedZones: [{ Id: "/hostedzone/Z2", Name: "b.com." }],
-				IsTruncated: false,
-			});
-
-		const zones = await route53Client.listZones(config);
-
-		expect(zones).toEqual([
-			{ id: "Z1", name: "a.com" },
-			{ id: "Z2", name: "b.com" },
-		]);
-		expect(send).toHaveBeenCalledTimes(2);
-		expect((send.mock.calls[1]?.[0] as HasInput).input.Marker).toBe("marker-1");
-	});
-});
-
-describe("route53Client.listRecords", () => {
-	it("builds a type:name id and strips the trailing dot from the name", async () => {
-		send.mockResolvedValueOnce({
-			ResourceRecordSets: [
-				{
-					Name: "app.example.com.",
-					Type: "A",
-					TTL: 300,
-					ResourceRecords: [{ Value: "1.2.3.4" }],
-				},
-			],
-			IsTruncated: false,
-		});
-
-		const records = await route53Client.listRecords(config, "Z123");
-
-		expect(records).toEqual([
-			{
-				id: "A:app.example.com",
-				type: "A",
-				name: "app.example.com",
-				content: "1.2.3.4",
-				ttl: 300,
-			},
-		]);
-	});
-
-	it("skips record sets with no ResourceRecords (e.g. alias targets)", async () => {
-		send.mockResolvedValueOnce({
-			ResourceRecordSets: [
-				{ Name: "alias.example.com.", Type: "A", ResourceRecords: [] },
-			],
-			IsTruncated: false,
-		});
-
-		const records = await route53Client.listRecords(config, "Z123");
-
-		expect(records).toEqual([]);
-	});
-
-	it("joins multiple values for the same record", async () => {
-		send.mockResolvedValueOnce({
-			ResourceRecordSets: [
-				{
-					Name: "example.com.",
-					Type: "NS",
-					TTL: 172800,
-					ResourceRecords: [
-						{ Value: "ns1.example.com" },
-						{ Value: "ns2.example.com" },
-					],
-				},
-			],
-			IsTruncated: false,
-		});
-
-		const records = await route53Client.listRecords(config, "Z123");
-
-		expect(records[0]?.content).toBe("ns1.example.com\nns2.example.com");
-	});
-});
-
-describe("route53Client.upsertRecord", () => {
-	it("sends a single UPSERT change when nothing exists yet", async () => {
-		send
-			.mockResolvedValueOnce({ ResourceRecordSets: [] })
-			.mockResolvedValueOnce({});
-
-		const result = await route53Client.upsertRecord(config, {
-			zoneId: "Z123",
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-		});
-
-		expect(result).toEqual({ id: "A:app.example.com" });
-		const command = send.mock.calls[1]?.[0] as HasInput;
-		expect(command.input.HostedZoneId).toBe("Z123");
-		expect(command.input.ChangeBatch.Changes).toEqual([
-			{
-				Action: "UPSERT",
-				ResourceRecordSet: {
-					Name: "app.example.com.",
-					Type: "A",
-					TTL: 300,
-					ResourceRecords: [{ Value: "1.2.3.4" }],
-				},
-			},
-		]);
-	});
-
-	it("keeps the values already in the record set", async () => {
-		send
-			.mockResolvedValueOnce({
-				ResourceRecordSets: [
-					{
-						Name: "app.example.com.",
-						Type: "A",
-						TTL: 300,
-						ResourceRecords: [{ Value: "1.1.1.1" }, { Value: "2.2.2.2" }],
-					},
-				],
-			})
-			.mockResolvedValueOnce({});
-
-		await route53Client.upsertRecord(config, {
-			zoneId: "Z123",
-			type: "A",
-			name: "app.example.com",
-			content: "3.3.3.3",
-		});
-
-		const command = send.mock.calls[1]?.[0] as HasInput;
-		expect(
-			command.input.ChangeBatch.Changes[0].ResourceRecordSet.ResourceRecords,
-		).toEqual([
-			{ Value: "1.1.1.1" },
-			{ Value: "2.2.2.2" },
-			{ Value: "3.3.3.3" },
-		]);
-	});
-
-	it("does not duplicate a value that is already in the record set", async () => {
-		send
-			.mockResolvedValueOnce({
-				ResourceRecordSets: [
-					{
-						Name: "app.example.com.",
-						Type: "A",
-						TTL: 300,
-						ResourceRecords: [{ Value: "1.1.1.1" }],
-					},
-				],
-			})
-			.mockResolvedValueOnce({});
-
-		await route53Client.upsertRecord(config, {
-			zoneId: "Z123",
-			type: "A",
-			name: "app.example.com",
-			content: "1.1.1.1",
-		});
-
-		const command = send.mock.calls[1]?.[0] as HasInput;
-		expect(
-			command.input.ChangeBatch.Changes[0].ResourceRecordSet.ResourceRecords,
-		).toEqual([{ Value: "1.1.1.1" }]);
-	});
-
-	it("wraps unquoted TXT values in double quotes", async () => {
-		send
-			.mockResolvedValueOnce({ ResourceRecordSets: [] })
-			.mockResolvedValueOnce({});
-
-		await route53Client.upsertRecord(config, {
-			zoneId: "Z123",
-			type: "TXT",
-			name: "example.com",
-			content: 'v=spf1 ~all\n"already quoted"',
-		});
-
-		const command = send.mock.calls[1]?.[0] as HasInput;
-		expect(
-			command.input.ChangeBatch.Changes[0].ResourceRecordSet.ResourceRecords,
-		).toEqual([{ Value: '"v=spf1 ~all"' }, { Value: '"already quoted"' }]);
-	});
-});
-
-describe("route53Client.updateRecord", () => {
-	it("only UPSERTs when the name/type identity did not change", async () => {
-		send.mockResolvedValueOnce({});
-
-		await route53Client.updateRecord(config, "Z123", "A:app.example.com", {
-			type: "A",
-			name: "app.example.com",
-			content: "9.9.9.9",
-		});
-
-		expect(send).toHaveBeenCalledTimes(1);
-		const command = send.mock.calls[0]?.[0] as HasInput;
-		expect(command.input.ChangeBatch.Changes).toHaveLength(1);
-		expect(command.input.ChangeBatch.Changes[0].Action).toBe("UPSERT");
-	});
-
-	it("deletes the old record set and creates the new one on rename", async () => {
-		const existingSet = {
-			Name: "old.example.com.",
-			Type: "A",
-			TTL: 300,
-			ResourceRecords: [{ Value: "1.1.1.1" }],
-		};
-		send
-			.mockResolvedValueOnce({ ResourceRecordSets: [existingSet] }) // findExactRecordSet lookup
-			.mockResolvedValueOnce({}); // ChangeResourceRecordSets
-
-		await route53Client.updateRecord(config, "Z123", "A:old.example.com", {
-			type: "A",
-			name: "new.example.com",
-			content: "1.1.1.1",
-		});
-
-		const changeCommand = send.mock.calls[1]?.[0] as HasInput;
-		expect(changeCommand.input.ChangeBatch.Changes).toEqual([
-			{ Action: "DELETE", ResourceRecordSet: existingSet },
-			{
-				Action: "UPSERT",
-				ResourceRecordSet: {
-					Name: "new.example.com.",
-					Type: "A",
-					TTL: 300,
-					ResourceRecords: [{ Value: "1.1.1.1" }],
-				},
-			},
-		]);
-	});
-
-	it("keeps every line of a multi-value record set", async () => {
-		send.mockResolvedValueOnce({});
-
-		await route53Client.updateRecord(config, "Z123", "NS:example.com", {
-			type: "NS",
-			name: "example.com",
-			content: "ns1.example.com\nns2.example.com\n\n  ns3.example.com  ",
-		});
-
-		const command = send.mock.calls[0]?.[0] as HasInput;
-		expect(
-			command.input.ChangeBatch.Changes[0].ResourceRecordSet.ResourceRecords,
-		).toEqual([
-			{ Value: "ns1.example.com" },
-			{ Value: "ns2.example.com" },
-			{ Value: "ns3.example.com" },
-		]);
-	});
-
-	it("skips the DELETE when the old record no longer exists", async () => {
-		send
-			.mockResolvedValueOnce({ ResourceRecordSets: [] })
-			.mockResolvedValueOnce({});
-
-		await route53Client.updateRecord(config, "Z123", "A:gone.example.com", {
-			type: "A",
-			name: "new.example.com",
-			content: "1.1.1.1",
-		});
-
-		const changeCommand = send.mock.calls[1]?.[0] as HasInput;
-		expect(changeCommand.input.ChangeBatch.Changes).toHaveLength(1);
-		expect(changeCommand.input.ChangeBatch.Changes[0].Action).toBe("UPSERT");
-	});
-});
-
-describe("route53Client.deleteRecord", () => {
-	it("deletes the record set found by name/type", async () => {
-		const existingSet = {
-			Name: "app.example.com.",
-			Type: "A",
-			TTL: 300,
-			ResourceRecords: [{ Value: "1.2.3.4" }],
-		};
-		send.mockResolvedValueOnce({ ResourceRecordSets: [existingSet] });
-		send.mockResolvedValueOnce({});
-
-		await route53Client.deleteRecord(config, "Z123", "A:app.example.com");
-
-		const changeCommand = send.mock.calls[1]?.[0] as HasInput;
-		expect(changeCommand.input.ChangeBatch.Changes).toEqual([
-			{ Action: "DELETE", ResourceRecordSet: existingSet },
-		]);
-	});
-
-	it("throws when the record no longer exists", async () => {
-		send.mockResolvedValueOnce({ ResourceRecordSets: [] });
-
-		await expect(
-			route53Client.deleteRecord(config, "Z123", "A:gone.example.com"),
-		).rejects.toThrow("not found");
-	});
-
-	it("throws for a malformed record id", async () => {
-		await expect(
-			route53Client.deleteRecord(config, "Z123", "not-a-valid-id"),
-		).rejects.toThrow("Invalid Route53 record id");
-	});
-});
-
-describe("route53Client.testConnection", () => {
-	it("resolves when ListHostedZones succeeds", async () => {
-		send.mockResolvedValueOnce({ HostedZones: [] });
-		await expect(route53Client.testConnection(config)).resolves.toBeUndefined();
-	});
-
-	it("propagates SDK errors", async () => {
-		send.mockRejectedValueOnce(new Error("InvalidClientTokenId"));
-		await expect(route53Client.testConnection(config)).rejects.toThrow(
-			"InvalidClientTokenId",
-		);
-	});
-});

apps/dokploy/__test__/domains/domain-validation.test.ts

@@ -1,149 +0,0 @@
-import os from "node:os";
-import {
-	getServerIpCandidates,
-	validateDomain,
-} from "@dokploy/server/services/domain";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const mocks = vi.hoisted(() => ({
-	execAsyncRemote: vi.fn(),
-	findServerById: vi.fn(),
-	getPublicIpWithFallback: vi.fn(),
-	getWebServerSettings: vi.fn(),
-	resolve4: vi.fn(),
-	resolve6: vi.fn(),
-}));
-
-vi.mock("node:dns", () => ({
-	default: {
-		resolve4: mocks.resolve4,
-		resolve6: mocks.resolve6,
-	},
-}));
-
-vi.mock("@dokploy/server/utils/process/execAsync", () => ({
-	execAsyncRemote: mocks.execAsyncRemote,
-}));
-
-vi.mock("@dokploy/server/services/server", () => ({
-	findServerById: mocks.findServerById,
-}));
-
-vi.mock("@dokploy/server/services/web-server-settings", () => ({
-	getWebServerSettings: mocks.getWebServerSettings,
-}));
-
-vi.mock("@dokploy/server/wss/utils", () => ({
-	getPublicIpWithFallback: mocks.getPublicIpWithFallback,
-}));
-
-describe("getServerIpCandidates", () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
-	});
-
-	afterEach(() => {
-		vi.restoreAllMocks();
-		vi.useRealTimers();
-	});
-
-	it("includes every address reported by a multi-homed remote server", async () => {
-		mocks.findServerById.mockResolvedValue({
-			ipAddress: "10.0.0.10",
-		});
-		mocks.execAsyncRemote.mockResolvedValue({
-			stdout: ["10.0.0.10", "192.0.2.10", "2001:db8::10"].join("\n"),
-			stderr: "",
-		});
-
-		await expect(getServerIpCandidates("server-id")).resolves.toEqual([
-			"10.0.0.10",
-			"192.0.2.10",
-			"2001:db8::10",
-		]);
-		expect(mocks.execAsyncRemote).toHaveBeenCalledWith(
-			"server-id",
-			expect.stringContaining("ip -o addr show scope global"),
-		);
-	});
-
-	it("includes every address assigned to the local Dokploy host", async () => {
-		mocks.getWebServerSettings.mockResolvedValue({
-			serverIp: "10.0.0.10",
-		});
-		mocks.getPublicIpWithFallback.mockResolvedValue("2001:db8::10");
-		vi.spyOn(os, "networkInterfaces").mockReturnValue({
-			eth0: [
-				{
-					address: "192.0.2.10",
-					netmask: "255.255.255.0",
-					family: "IPv4",
-					mac: "00:00:00:00:00:00",
-					internal: false,
-					cidr: "192.0.2.10/24",
-				},
-			],
-		});
-
-		await expect(getServerIpCandidates()).resolves.toEqual([
-			"10.0.0.10",
-			"192.0.2.10",
-			"2001:db8::10",
-		]);
-	});
-
-	it("retains remote interface addresses when public IP detection times out", async () => {
-		vi.useFakeTimers();
-		mocks.findServerById.mockResolvedValue({
-			ipAddress: "10.0.0.10",
-		});
-		mocks.execAsyncRemote.mockImplementation(
-			(_serverId: string, command: string) => {
-				if (command.includes("curl")) {
-					return new Promise(() => undefined);
-				}
-				return Promise.resolve({
-					stdout: "192.0.2.10\n",
-					stderr: "",
-				});
-			},
-		);
-
-		const candidatesPromise = getServerIpCandidates("server-id");
-		await vi.advanceTimersByTimeAsync(7000);
-
-		await expect(candidatesPromise).resolves.toEqual([
-			"10.0.0.10",
-			"192.0.2.10",
-		]);
-	});
-});
-
-describe("validateDomain", () => {
-	afterEach(() => {
-		vi.clearAllMocks();
-	});
-
-	it("validates an IPv6-only domain against an IPv6 server address", async () => {
-		const noIpv4 = Object.assign(new Error("queryA ENODATA example.com"), {
-			code: "ENODATA",
-		});
-		mocks.resolve4.mockImplementation(
-			(_domain: string, callback: (error: Error | null) => void) =>
-				callback(noIpv4),
-		);
-		mocks.resolve6.mockImplementation(
-			(
-				_domain: string,
-				callback: (error: Error | null, addresses?: string[]) => void,
-			) => callback(null, ["2001:db8::10"]),
-		);
-
-		await expect(
-			validateDomain("example.com", ["2001:db8::10"]),
-		).resolves.toMatchObject({
-			isValid: true,
-			resolvedIp: "2001:db8::10",
-		});
-	});
-});

apps/dokploy/__test__/env/aws-parameter-store.test.ts

@@ -1,195 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-type HasInput = { input: Record<string, unknown> };
-
-const findMany = vi.hoisted(() => vi.fn());
-
-const {
-	send,
-	paginate,
-	SSMClient,
-	GetParametersCommand,
-	DescribeParametersCommand,
-} = vi.hoisted(() => {
-	class FakeCommand {
-		input: Record<string, unknown>;
-		constructor(input: Record<string, unknown>) {
-			this.input = input;
-		}
-	}
-	const send = vi.fn();
-	const paginate = vi.fn();
-	class SSMClient {
-		send(command: unknown) {
-			return send(command);
-		}
-	}
-	return {
-		send,
-		paginate,
-		SSMClient,
-		GetParametersCommand: class extends FakeCommand {},
-		DescribeParametersCommand: class extends FakeCommand {},
-	};
-});
-
-vi.mock("@aws-sdk/client-ssm", () => ({
-	SSMClient,
-	GetParametersCommand,
-	DescribeParametersCommand,
-	paginateDescribeParameters: paginate,
-}));
-
-vi.mock("@dokploy/server/db", () => ({
-	db: {
-		query: {
-			vaultProvider: {
-				findMany: (...args: unknown[]) => findMany(...args),
-			},
-		},
-	},
-}));
-
-import { resolveVaultReferences } from "@dokploy/server/utils/vault";
-import { awsParameterStoreClient } from "@dokploy/server/utils/vault/aws-parameter-store";
-
-const config = {
-	providerType: "aws-parameter-store" as const,
-	region: "eu-central-1",
-	accessKeyId: "AKIA_TEST",
-	secretAccessKey: "secret",
-};
-
-beforeEach(() => {
-	send.mockReset();
-	paginate.mockReset();
-	findMany.mockReset();
-});
-
-describe("awsParameterStoreClient", () => {
-	it("decrypts parameters in batches of ten and preserves selectors", async () => {
-		const refs = [
-			"/prod/database:CURRENT",
-			...Array.from({ length: 10 }, (_, index) => `/prod/secret-${index}`),
-		];
-		send.mockImplementation(async (command: HasInput) => ({
-			Parameters: (command.input.Names as string[]).map((ref) => {
-				if (ref === "/prod/database:CURRENT") {
-					return {
-						Name: "/prod/database",
-						Selector: ":CURRENT",
-						Value: "selected-value",
-					};
-				}
-				return { Name: ref, Value: `value-for-${ref}` };
-			}),
-		}));
-
-		const result = await awsParameterStoreClient.getSecrets(config, refs);
-
-		expect(send).toHaveBeenCalledTimes(2);
-		expect((send.mock.calls[0]?.[0] as HasInput).input).toMatchObject({
-			WithDecryption: true,
-		});
-		expect(
-			((send.mock.calls[0]?.[0] as HasInput).input.Names as string[]).length,
-		).toBe(10);
-		expect(
-			((send.mock.calls[1]?.[0] as HasInput).input.Names as string[]).length,
-		).toBe(1);
-		expect(result["/prod/database:CURRENT"]).toBe("selected-value");
-		expect(result["/prod/secret-9"]).toBe("value-for-/prod/secret-9");
-	});
-
-	it("reports a missing parameter without exposing other values", async () => {
-		send.mockResolvedValue({ Parameters: [], InvalidParameters: ["/missing"] });
-
-		await expect(
-			awsParameterStoreClient.getSecrets(config, ["/missing"]),
-		).rejects.toThrow('AWS Parameter Store: parameter "/missing" not found');
-	});
-
-	it("tests the connection within the configured hierarchy", async () => {
-		send.mockResolvedValue({ Parameters: [] });
-
-		await awsParameterStoreClient.testConnection({
-			...config,
-			parameterPath: "/production/my-app/",
-		});
-
-		expect(send).toHaveBeenCalledTimes(1);
-		expect((send.mock.calls[0]?.[0] as HasInput).input).toEqual({
-			ParameterFilters: [
-				{
-					Key: "Path",
-					Option: "Recursive",
-					Values: ["/production/my-app"],
-				},
-			],
-			MaxResults: 1,
-		});
-	});
-
-	it("explains the discovery permission when connection testing is denied", async () => {
-		const error = new Error("not authorized");
-		error.name = "AccessDeniedException";
-		send.mockRejectedValue(error);
-
-		await expect(
-			awsParameterStoreClient.testConnection(config),
-		).rejects.toThrow("ssm:DescribeParameters");
-	});
-
-	it("lists parameter names across pages within the configured hierarchy", async () => {
-		paginate.mockReturnValue(
-			(async function* () {
-				yield { Parameters: [{ Name: "/prod/db" }] };
-				yield { Parameters: [{ Name: "/prod/api" }] };
-			})(),
-		);
-
-		const names = await awsParameterStoreClient.listSecretNames?.({
-			...config,
-			parameterPath: " /production/my-app/ ",
-		});
-
-		expect(names).toEqual(["/prod/db", "/prod/api"]);
-		expect(paginate).toHaveBeenCalledWith(
-			expect.objectContaining({ pageSize: 50 }),
-			{
-				ParameterFilters: [
-					{
-						Key: "Path",
-						Option: "Recursive",
-						Values: ["/production/my-app"],
-					},
-				],
-			},
-		);
-	});
-
-	it("resolves a vault reference through the registered provider", async () => {
-		findMany.mockResolvedValue([
-			{
-				name: "ssm-prod",
-				providerType: "aws-parameter-store",
-				config,
-				assignments: [{ projectId: "project-1", environmentIds: [] }],
-			},
-		]);
-		send.mockResolvedValue({
-			Parameters: [{ Name: "/prod/database-password", Value: "resolved" }],
-		});
-
-		const result = await resolveVaultReferences(
-			"DB_PASSWORD=${{vault.ssm-prod./prod/database-password}}",
-			{
-				organizationId: "organization-1",
-				projectId: "project-1",
-				environmentId: "environment-1",
-			},
-		);
-
-		expect(result).toBe("DB_PASSWORD=resolved");
-	});
-});

apps/dokploy/__test__/env/vault.test.ts

@@ -20,9 +20,6 @@ import {
 import { azureClient } from "@dokploy/server/utils/vault/azure";
 import { dopplerClient } from "@dokploy/server/utils/vault/doppler";
 import { hashicorpClient } from "@dokploy/server/utils/vault/hashicorp";
-import { infisicalClient } from "@dokploy/server/utils/vault/infisical";
-import { phaseClient } from "@dokploy/server/utils/vault/phase";
-import { scalewayClient } from "@dokploy/server/utils/vault/scaleway";
 
 const mockFetch = vi.fn();
 global.fetch = mockFetch as typeof fetch;
@@ -432,152 +429,6 @@ describe("azure client", () => {
 	});
 });
 
-describe("infisical client", () => {
-	const config = {
-		providerType: "infisical" as const,
-		siteUrl: "https://app.infisical.com",
-		clientId: "client-1",
-		clientSecret: "client-secret",
-		projectId: "workspace-1",
-		environmentSlug: "prod",
-		secretPath: "/frontend",
-	};
-
-	const loginResponse = () => jsonResponse({ accessToken: "token-1" });
-	const list = (secrets: Record<string, string>) =>
-		jsonResponse({
-			secrets: Object.entries(secrets).map(([secretKey, secretValue]) => ({
-				secretKey,
-				secretValue,
-			})),
-		});
-	const listPathOf = (callIndex: number) => {
-		const [url] = mockFetch.mock.calls[callIndex] as [string];
-		return new URL(url).searchParams.get("secretPath");
-	};
-
-	it("asks the list endpoint to expand secret references", async () => {
-		mockFetch
-			.mockResolvedValueOnce(loginResponse())
-			.mockResolvedValueOnce(list({ DB_URL: "postgres://real" }));
-
-		const result = await infisicalClient.getSecrets(config, ["DB_URL"]);
-
-		expect(result).toEqual({ DB_URL: "postgres://real" });
-		const [listUrl] = mockFetch.mock.calls[1] as [string];
-		const params = new URL(listUrl).searchParams;
-		expect(params.get("expandSecretReferences")).toBe("true");
-		expect(params.get("workspaceId")).toBe("workspace-1");
-		expect(params.get("environment")).toBe("prod");
-		expect(params.get("secretPath")).toBe("/frontend");
-	});
-
-	it("throws a clear error for a missing secret", async () => {
-		mockFetch
-			.mockResolvedValueOnce(loginResponse())
-			.mockResolvedValueOnce(jsonResponse({ secrets: [] }));
-
-		await expect(
-			infisicalClient.getSecrets(config, ["ABSENT"]),
-		).rejects.toThrow('secret "ABSENT" not found in environment "prod"');
-	});
-
-	it("propagates authentication failures with the status code", async () => {
-		mockFetch.mockResolvedValueOnce(jsonResponse({}, false, 401));
-
-		await expect(
-			infisicalClient.getSecrets(config, ["DB_URL"]),
-		).rejects.toThrow("authentication failed (status 401)");
-	});
-
-	it("resolves a relative <path>:<KEY> ref against the provider path", async () => {
-		mockFetch
-			.mockResolvedValueOnce(loginResponse())
-			.mockResolvedValueOnce(list({ SENTRY_DSN: "https://key@sentry.io/1" }));
-
-		const result = await infisicalClient.getSecrets(config, [
-			"shared/sentry:SENTRY_DSN",
-		]);
-
-		expect(result).toEqual({
-			"shared/sentry:SENTRY_DSN": "https://key@sentry.io/1",
-		});
-		expect(listPathOf(1)).toBe("/frontend/shared/sentry");
-	});
-
-	it("treats a leading slash as an absolute path", async () => {
-		mockFetch
-			.mockResolvedValueOnce(loginResponse())
-			.mockResolvedValueOnce(list({ SENTRY_DSN: "https://key@sentry.io/1" }));
-
-		await infisicalClient.getSecrets(config, ["/external/sentry:SENTRY_DSN"]);
-
-		expect(listPathOf(1)).toBe("/external/sentry");
-	});
-
-	it("keeps the root path clean when the provider sits at /", async () => {
-		mockFetch
-			.mockResolvedValueOnce(loginResponse())
-			.mockResolvedValueOnce(list({ KEY: "value" }));
-
-		await infisicalClient.getSecrets({ ...config, secretPath: "/" }, [
-			"external/sentry:KEY",
-		]);
-
-		expect(listPathOf(1)).toBe("/external/sentry");
-	});
-
-	it("logs in once and fetches each path once", async () => {
-		const byPath: Record<string, Record<string, string>> = {
-			"/frontend": { A: "a", B: "b" },
-			"/frontend/other": { C: "c" },
-		};
-		mockFetch.mockImplementation(async (url: string) => {
-			if (url.includes("/auth/universal-auth/login")) return loginResponse();
-			const path = new URL(url).searchParams.get("secretPath") as string;
-			return list(byPath[path] ?? {});
-		});
-
-		const result = await infisicalClient.getSecrets(config, [
-			"A",
-			"B",
-			"other:C",
-		]);
-
-		expect(result).toEqual({ A: "a", B: "b", "other:C": "c" });
-
-		const urls = mockFetch.mock.calls.map(([url]) => url as string);
-		expect(urls.filter((u) => u.includes("/login"))).toHaveLength(1);
-		expect(
-			urls
-				.filter((u) => u.includes("/secrets/raw?"))
-				.map((u) => new URL(u).searchParams.get("secretPath"))
-				.sort(),
-		).toEqual(["/frontend", "/frontend/other"]);
-	});
-
-	it("names the path when a secret is missing from an explicit one", async () => {
-		mockFetch
-			.mockResolvedValueOnce(loginResponse())
-			.mockResolvedValueOnce(list({}));
-
-		await expect(
-			infisicalClient.getSecrets(config, ["external/sentry:ABSENT"]),
-		).rejects.toThrow(
-			'secret "ABSENT" not found at "/frontend/external/sentry"',
-		);
-	});
-
-	it("rejects a ref with an empty path or key", async () => {
-		await expect(infisicalClient.getSecrets(config, [":KEY"])).rejects.toThrow(
-			"expected format <path>:<KEY>",
-		);
-		await expect(
-			infisicalClient.getSecrets(config, ["external/sentry:"]),
-		).rejects.toThrow("expected format <path>:<KEY>");
-	});
-});
-
 describe("doppler client", () => {
 	it("propagates auth errors with the status code", async () => {
 		mockFetch.mockResolvedValue(jsonResponse({}, false, 401));
@@ -589,304 +440,3 @@ describe("doppler client", () => {
 		).rejects.toThrow("status 401");
 	});
 });
-
-describe("scaleway client", () => {
-	const config = {
-		providerType: "scaleway" as const,
-		region: "fr-par",
-		projectId: "project-1",
-		secretKey: "scw-secret-key",
-		apiUrl: "https://api.scaleway.com",
-	};
-
-	const accessResponse = (value: string) =>
-		jsonResponse({
-			secret_id: "secret-1",
-			revision: 1,
-			data: Buffer.from(value).toString("base64"),
-		});
-
-	it("reads a secret by name from the root path and decodes the payload", async () => {
-		mockFetch.mockResolvedValue(accessResponse("postgres://real"));
-
-		const result = await scalewayClient.getSecrets(config, ["db-url"]);
-
-		expect(result).toEqual({ "db-url": "postgres://real" });
-		expect(mockFetch).toHaveBeenCalledTimes(1);
-		const [url, init] = mockFetch.mock.calls[0] as [string, RequestInit];
-		expect(url).toBe(
-			"https://api.scaleway.com/secret-manager/v1beta1/regions/fr-par/secrets-by-path/versions/latest_enabled/access?project_id=project-1&secret_name=db-url&secret_path=%2F",
-		);
-		expect((init.headers as Record<string, string>)["X-Auth-Token"]).toBe(
-			"scw-secret-key",
-		);
-	});
-
-	it("sends the folder of a path-qualified ref as secret_path", async () => {
-		mockFetch.mockResolvedValue(accessResponse("value"));
-
-		await scalewayClient.getSecrets(config, ["prod/db/password"]);
-
-		expect(mockFetch.mock.calls[0]?.[0]).toContain(
-			"secret_name=password&secret_path=%2Fprod%2Fdb",
-		);
-	});
-
-	it("extracts a field from a JSON secret and fetches the secret once", async () => {
-		mockFetch.mockResolvedValue(
-			accessResponse(JSON.stringify({ user: "admin", port: 5432 })),
-		);
-
-		const result = await scalewayClient.getSecrets(config, [
-			"db-creds:user",
-			"db-creds:port",
-		]);
-
-		expect(result).toEqual({
-			"db-creds:user": "admin",
-			"db-creds:port": "5432",
-		});
-		expect(mockFetch).toHaveBeenCalledTimes(1);
-	});
-
-	it("throws when the secret is not JSON but a field is requested", async () => {
-		mockFetch.mockResolvedValue(accessResponse("plain-value"));
-
-		await expect(
-			scalewayClient.getSecrets(config, ["db-creds:user"]),
-		).rejects.toThrow("is not JSON");
-	});
-
-	it("throws when the requested field is missing", async () => {
-		mockFetch.mockResolvedValue(accessResponse(JSON.stringify({ user: "a" })));
-
-		await expect(
-			scalewayClient.getSecrets(config, ["db-creds:password"]),
-		).rejects.toThrow('field "password" not found');
-	});
-
-	it("throws a clear error for a missing secret", async () => {
-		mockFetch.mockResolvedValue(
-			jsonResponse({ message: "not found" }, false, 404),
-		);
-
-		await expect(scalewayClient.getSecrets(config, ["nope"])).rejects.toThrow(
-			'secret "nope" not found in path "/"',
-		);
-	});
-
-	it("reports authentication failures with the API message", async () => {
-		mockFetch.mockResolvedValue(
-			jsonResponse({ message: "denied authentication" }, false, 403),
-		);
-
-		await expect(scalewayClient.getSecrets(config, ["db-url"])).rejects.toThrow(
-			"authentication failed (status 403: denied authentication)",
-		);
-	});
-
-	it("throws when the secret has no enabled version", async () => {
-		mockFetch.mockResolvedValue(jsonResponse({ secret_id: "secret-1" }));
-
-		await expect(scalewayClient.getSecrets(config, ["db-url"])).rejects.toThrow(
-			"has no enabled version",
-		);
-	});
-
-	it("rejects a ref without a secret name", async () => {
-		await expect(scalewayClient.getSecrets(config, ["prod/"])).rejects.toThrow(
-			"expected format <name> or <folder>/<name>[:field]",
-		);
-	});
-
-	it("tests the connection against the secrets listing", async () => {
-		mockFetch.mockResolvedValue(jsonResponse({ secrets: [], total_count: 0 }));
-
-		await scalewayClient.testConnection(config);
-
-		expect(mockFetch.mock.calls[0]?.[0]).toBe(
-			"https://api.scaleway.com/secret-manager/v1beta1/regions/fr-par/secrets?project_id=project-1&page_size=1",
-		);
-	});
-
-	it("lists secret names with their folder prefix", async () => {
-		mockFetch.mockResolvedValue(
-			jsonResponse({
-				secrets: [
-					{ id: "1", name: "db-url", path: "/" },
-					{ id: "2", name: "password", path: "/prod/db" },
-				],
-				total_count: 2,
-			}),
-		);
-
-		const names = await scalewayClient.listSecretNames?.(config);
-
-		expect(names).toEqual(["db-url", "prod/db/password"]);
-		expect(mockFetch).toHaveBeenCalledTimes(1);
-	});
-
-	it("follows pagination until a short page is returned", async () => {
-		const page = (start: number, size: number) =>
-			jsonResponse({
-				secrets: Array.from({ length: size }, (_, index) => ({
-					id: String(start + index),
-					name: `secret-${start + index}`,
-					path: "/",
-				})),
-			});
-		mockFetch.mockImplementation(async (url: string) =>
-			url.includes("page=2") ? page(101, 2) : page(1, 100),
-		);
-
-		const names = await scalewayClient.listSecretNames?.(config);
-
-		expect(names).toHaveLength(102);
-		expect(mockFetch).toHaveBeenCalledTimes(2);
-	});
-
-	it("resolves env refs end to end through a scaleway provider", async () => {
-		findMany.mockResolvedValue([
-			{
-				name: "scw-prod",
-				providerType: "scaleway",
-				config,
-				assignments: assignedEverywhere,
-			},
-		]);
-		mockFetch.mockResolvedValue(accessResponse("s3cret"));
-
-		const result = await resolveVaultReferences(
-			"DB_PASSWORD=${{vault.scw-prod.prod/db-password}}",
-			scope,
-		);
-
-		expect(result).toBe("DB_PASSWORD=s3cret");
-	});
-});
-
-describe("phase client", () => {
-	const config = {
-		providerType: "phase" as const,
-		token: "phase-rest-token",
-		appId: "app-123",
-		env: "Production",
-		path: "/",
-		apiUrl: "https://api.phase.dev",
-	};
-
-	it("fetches secrets by key and sends ServiceAccount auth", async () => {
-		mockFetch.mockResolvedValue(
-			jsonResponse([
-				{ key: "DB_URL", value: "postgres://real", path: "/" },
-				{ key: "API_KEY", value: "key-123", path: "/" },
-			]),
-		);
-
-		const result = await phaseClient.getSecrets(config, ["DB_URL", "API_KEY"]);
-
-		expect(result).toEqual({ DB_URL: "postgres://real", API_KEY: "key-123" });
-		expect(mockFetch).toHaveBeenCalledTimes(1);
-		const [url, init] = mockFetch.mock.calls[0] as [string, RequestInit];
-		expect(url).toBe(
-			"https://api.phase.dev/v1/secrets/?app_id=app-123&env=Production&path=%2F",
-		);
-		expect((init.headers as Record<string, string>).Authorization).toBe(
-			"Bearer ServiceAccount phase-rest-token",
-		);
-	});
-
-	it("throws when a requested secret is missing", async () => {
-		mockFetch.mockResolvedValue(
-			jsonResponse([{ key: "DB_URL", value: "postgres://real", path: "/" }]),
-		);
-
-		await expect(phaseClient.getSecrets(config, ["MISSING"])).rejects.toThrow(
-			'secret "MISSING" not found in environment "Production"',
-		);
-	});
-
-	it("reports authentication failures with the status code", async () => {
-		mockFetch.mockResolvedValue(
-			jsonResponse({ error: "unauthorized" }, false, 401),
-		);
-
-		await expect(phaseClient.getSecrets(config, ["DB_URL"])).rejects.toThrow(
-			"authentication failed (status 401: unauthorized)",
-		);
-	});
-
-	it("rejects apps without SSE enabled during testConnection", async () => {
-		mockFetch.mockResolvedValueOnce(
-			jsonResponse({
-				id: "app-123",
-				name: "My App",
-				sseEnabled: false,
-			}),
-		);
-
-		await expect(phaseClient.testConnection(config)).rejects.toThrow(
-			"enable Server-side Encryption (SSE)",
-		);
-		expect(mockFetch).toHaveBeenCalledTimes(1);
-		expect(mockFetch.mock.calls[0]?.[0]).toBe(
-			"https://api.phase.dev/v1/apps/app-123/",
-		);
-	});
-
-	it("tests connection against the app then secrets listing", async () => {
-		mockFetch
-			.mockResolvedValueOnce(
-				jsonResponse({
-					id: "app-123",
-					name: "My App",
-					sseEnabled: true,
-				}),
-			)
-			.mockResolvedValueOnce(jsonResponse([]));
-
-		await phaseClient.testConnection(config);
-
-		expect(mockFetch).toHaveBeenCalledTimes(2);
-		expect(mockFetch.mock.calls[0]?.[0]).toBe(
-			"https://api.phase.dev/v1/apps/app-123/",
-		);
-		expect(mockFetch.mock.calls[1]?.[0]).toBe(
-			"https://api.phase.dev/v1/secrets/?app_id=app-123&env=Production&path=%2F",
-		);
-	});
-
-	it("lists secret names from the configured path", async () => {
-		mockFetch.mockResolvedValue(
-			jsonResponse([
-				{ key: "DB_URL", value: "x", path: "/" },
-				{ key: "API_KEY", value: "y", path: "/" },
-			]),
-		);
-
-		const names = await phaseClient.listSecretNames?.(config);
-
-		expect(names).toEqual(["DB_URL", "API_KEY"]);
-	});
-
-	it("resolves env refs end to end through a phase provider", async () => {
-		findMany.mockResolvedValue([
-			{
-				name: "phase-prod",
-				providerType: "phase",
-				config,
-				assignments: assignedEverywhere,
-			},
-		]);
-		mockFetch.mockResolvedValue(
-			jsonResponse([{ key: "DB_PASSWORD", value: "s3cret", path: "/" }]),
-		);
-
-		const result = await resolveVaultReferences(
-			"DB_PASSWORD=${{vault.phase-prod.DB_PASSWORD}}",
-			scope,
-		);
-
-		expect(result).toBe("DB_PASSWORD=s3cret");
-	});
-});

apps/dokploy/__test__/logs/container-selection.test.ts

@@ -1,41 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { resolveContainerSelection } from "@/components/dashboard/docker/logs/utils";
-
-const containers = [
-	{ containerId: "first-container" },
-	{ containerId: "selected-container" },
-];
-
-describe("resolveContainerSelection", () => {
-	it("selects the first container when no container is selected", () => {
-		expect(resolveContainerSelection(undefined, containers)).toBe(
-			"first-container",
-		);
-	});
-
-	it("preserves a manual selection when refreshed data contains it", () => {
-		const refreshedContainers = containers.map((container) => ({
-			...container,
-		}));
-
-		expect(
-			resolveContainerSelection("selected-container", refreshedContainers),
-		).toBe("selected-container");
-	});
-
-	it("falls back to the first container when the selection disappears", () => {
-		expect(resolveContainerSelection("removed-container", containers)).toBe(
-			"first-container",
-		);
-	});
-
-	it("keeps the current selection while container data is loading", () => {
-		expect(resolveContainerSelection("selected-container", undefined)).toBe(
-			"selected-container",
-		);
-	});
-
-	it("clears the selection when no containers are available", () => {
-		expect(resolveContainerSelection("selected-container", [])).toBeUndefined();
-	});
-});

apps/dokploy/__test__/permissions/check-permission.test.ts

@@ -126,13 +126,6 @@ describe("member is denied org-level enterprise resources (CVE: bypass via stati
 		await expect(checkPermission(ctx, { server: ["read"] })).rejects.toThrow();
 	});
 
-	it("member is denied server.terminal", async () => {
-		memberToReturn = mockMemberData("member");
-		await expect(
-			checkPermission(ctx, { server: ["terminal"] }),
-		).rejects.toThrow();
-	});
-
 	it("member is denied registry.create", async () => {
 		memberToReturn = mockMemberData("member");
 		await expect(

apps/dokploy/__test__/permissions/enterprise-only-resources.test.ts

@@ -40,7 +40,6 @@ const ENTERPRISE_RESOURCES = [
 	"monitoring",
 	"auditLog",
 	"vaultProvider",
-	"dnsProvider",
 ];
 
 describe("enterpriseOnlyResources set", () => {

apps/dokploy/__test__/permissions/resolve-permissions.test.ts

@@ -105,7 +105,6 @@ describe("enterprise resources for static roles", () => {
 		const perms = await resolvePermissions(ctx);
 
 		expect(perms.server.read).toBe(false);
-		expect(perms.server.terminal).toBe(false);
 		expect(perms.registry.read).toBe(false);
 		expect(perms.certificate.read).toBe(false);
 		expect(perms.destination.read).toBe(false);

apps/dokploy/__test__/permissions/server-terminal.test.ts

@@ -1,105 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const mockMemberData = (role: string) => ({
-	id: "member-1",
-	role,
-	userId: "user-1",
-	organizationId: "org-1",
-	accessedProjects: [] as string[],
-	accessedServices: [] as string[],
-	accessedEnvironments: [] as string[],
-	accessedServers: [] as string[],
-	canCreateProjects: false,
-	canDeleteProjects: false,
-	canCreateServices: false,
-	canDeleteServices: false,
-	canCreateEnvironments: false,
-	canDeleteEnvironments: false,
-	canAccessToTraefikFiles: false,
-	canAccessToDocker: false,
-	canAccessToAPI: false,
-	canAccessToSSHKeys: false,
-	canAccessToGitProviders: false,
-	user: { id: "user-1", email: "test@test.com" },
-});
-
-let memberToReturn = mockMemberData("deployer");
-let rolesToReturn: { permission: string }[] = [];
-
-vi.mock("@dokploy/server/db", () => ({
-	db: {
-		query: {
-			member: {
-				findFirst: vi.fn(() => Promise.resolve(memberToReturn)),
-				findMany: vi.fn(() => Promise.resolve([])),
-			},
-			organizationRole: {
-				findFirst: vi.fn(),
-				findMany: vi.fn(() => Promise.resolve(rolesToReturn)),
-			},
-		},
-	},
-}));
-
-vi.mock("@dokploy/server/services/proprietary/license-key", () => ({
-	hasValidLicense: vi.fn(() => Promise.resolve(true)),
-}));
-
-const { checkPermission, resolvePermissions } = await import(
-	"@dokploy/server/services/permission"
-);
-
-const ctx = {
-	user: { id: "user-1" },
-	session: { activeOrganizationId: "org-1" },
-};
-
-const withPermissions = (permissions: Record<string, string[]>) => {
-	rolesToReturn = [{ permission: JSON.stringify(permissions) }];
-};
-
-beforeEach(() => {
-	vi.clearAllMocks();
-	memberToReturn = mockMemberData("deployer");
-	rolesToReturn = [];
-});
-
-describe("server.terminal on custom roles", () => {
-	it("a role with server.read alone cannot open a terminal", async () => {
-		withPermissions({ server: ["read"] });
-
-		await expect(
-			checkPermission(ctx, { server: ["read"] }),
-		).resolves.toBeUndefined();
-		await expect(
-			checkPermission(ctx, { server: ["terminal"] }),
-		).rejects.toThrow();
-
-		const perms = await resolvePermissions(ctx);
-		expect(perms.server.read).toBe(true);
-		expect(perms.server.terminal).toBe(false);
-	});
-
-	it("a role with server.terminal can open a terminal", async () => {
-		withPermissions({ server: ["read", "terminal"] });
-
-		await expect(
-			checkPermission(ctx, { server: ["terminal"] }),
-		).resolves.toBeUndefined();
-
-		const perms = await resolvePermissions(ctx);
-		expect(perms.server.terminal).toBe(true);
-	});
-
-	it("owner and admin keep terminal access", async () => {
-		for (const role of ["owner", "admin"]) {
-			memberToReturn = mockMemberData(role);
-			await expect(
-				checkPermission(ctx, { server: ["terminal"] }),
-			).resolves.toBeUndefined();
-
-			const perms = await resolvePermissions(ctx);
-			expect(perms.server.terminal).toBe(true);
-		}
-	});
-});

apps/dokploy/__test__/server/server-health-subnet.test.ts

@@ -1,24 +0,0 @@
-import { getSubnetCapacity } from "@dokploy/server/services/server-health";
-import { describe, expect, test } from "vitest";
-
-describe("getSubnetCapacity", () => {
-	test("returns null for missing/invalid input", () => {
-		expect(getSubnetCapacity(undefined)).toBeNull();
-		expect(getSubnetCapacity("")).toBeNull();
-		expect(getSubnetCapacity("10.0.0.0")).toBeNull();
-		expect(getSubnetCapacity("not-a-subnet")).toBeNull();
-		expect(getSubnetCapacity("10.0.0.0/33")).toBeNull();
-		expect(getSubnetCapacity("10.0.0.0/-1")).toBeNull();
-	});
-
-	test("excludes network and broadcast addresses", () => {
-		expect(getSubnetCapacity("10.0.1.0/24")).toBe(254);
-		expect(getSubnetCapacity("10.0.0.0/16")).toBe(65534);
-		expect(getSubnetCapacity("10.99.99.0/30")).toBe(2);
-	});
-
-	test("returns 0 for subnets too small to hold a host", () => {
-		expect(getSubnetCapacity("10.0.0.0/31")).toBe(0);
-		expect(getSubnetCapacity("10.0.0.0/32")).toBe(0);
-	});
-});

apps/dokploy/__test__/services/overview-backups-icon.test.ts

@@ -1,113 +0,0 @@
-import {
-	getBackupOverviewIcon,
-	getServiceOverviewIcon,
-} from "@dokploy/server/services/overview";
-import { describe, expect, test } from "vitest";
-
-describe("getServiceOverviewIcon", () => {
-	test("returns a db icon for every known DB engine type", () => {
-		for (const type of [
-			"postgres",
-			"mariadb",
-			"mysql",
-			"mongo",
-			"redis",
-			"libsql",
-		] as const) {
-			expect(getServiceOverviewIcon({ type, icon: null })).toEqual({
-				kind: "db",
-				engine: type,
-			});
-		}
-	});
-
-	test("returns a custom icon for application/compose with a service icon set", () => {
-		expect(
-			getServiceOverviewIcon({
-				type: "application",
-				icon: "data:image/png;base64,x",
-			}),
-		).toEqual({ kind: "custom", url: "data:image/png;base64,x" });
-		expect(
-			getServiceOverviewIcon({
-				type: "compose",
-				icon: "data:image/png;base64,y",
-			}),
-		).toEqual({ kind: "custom", url: "data:image/png;base64,y" });
-	});
-
-	test("falls back to a generic icon for application/compose without a service icon", () => {
-		expect(getServiceOverviewIcon({ type: "application", icon: null })).toEqual(
-			{
-				kind: "generic",
-				type: "application",
-			},
-		);
-		expect(getServiceOverviewIcon({ type: "compose", icon: null })).toEqual({
-			kind: "generic",
-			type: "compose",
-		});
-	});
-});
-
-describe("getBackupOverviewIcon", () => {
-	test("returns a db icon for a database backup with a known databaseType", () => {
-		expect(
-			getBackupOverviewIcon({
-				databaseType: "postgres",
-				serviceType: null,
-				serviceOwnerType: "postgres",
-			}),
-		).toEqual({ kind: "db", engine: "postgres" });
-	});
-
-	test("returns a webServer icon for a web-server database backup", () => {
-		expect(
-			getBackupOverviewIcon({
-				databaseType: "web-server",
-				serviceType: null,
-				serviceOwnerType: "web-server",
-			}),
-		).toEqual({ kind: "webServer" });
-	});
-
-	test("returns a db icon for a compose-type backup dumping a known DB engine", () => {
-		expect(
-			getBackupOverviewIcon({
-				databaseType: "mysql",
-				serviceType: null,
-				serviceOwnerType: "compose",
-			}),
-		).toEqual({ kind: "db", engine: "mysql" });
-	});
-
-	test("returns a db icon for a volume backup of a known DB engine service", () => {
-		expect(
-			getBackupOverviewIcon({
-				databaseType: null,
-				serviceType: "mongo",
-				serviceOwnerType: "mongo",
-			}),
-		).toEqual({ kind: "db", engine: "mongo" });
-	});
-
-	test("returns a generic application icon for a volume backup of an application", () => {
-		expect(
-			getBackupOverviewIcon({
-				databaseType: null,
-				serviceType: "application",
-				serviceOwnerType: "application",
-			}),
-		).toEqual({ kind: "generic", type: "application" });
-	});
-
-	test("returns a generic compose icon for a volume backup of a compose service", () => {
-		expect(
-			getBackupOverviewIcon({
-				databaseType: null,
-				serviceType: "compose",
-				serviceOwnerType: "compose",
-			}),
-		).toEqual({ kind: "generic", type: "compose" });
-	});
-});

apps/dokploy/__test__/services/overview-domains-sort.test.ts

@@ -1,79 +0,0 @@
-import type { OverviewDomain } from "@dokploy/server/services/overview";
-import { sortOverviewDomains } from "@dokploy/server/services/overview";
-import { describe, expect, test } from "vitest";
-
-const makeDomain = (overrides: Partial<OverviewDomain>): OverviewDomain => ({
-	domainId: "id",
-	host: "example.com",
-	path: "/",
-	port: 3000,
-	customEntrypoint: null,
-	https: true,
-	certificateType: "letsencrypt",
-	createdAt: "2024-01-01T00:00:00.000Z",
-	enabled: true,
-	domainType: "application",
-	serviceOwnerId: "app",
-	serviceOwnerType: "application",
-	serviceName: "App",
-	projectId: "project",
-	projectName: "Project",
-	environmentId: "environment",
-	environmentName: "Environment",
-	...overrides,
-});
-
-describe("sortOverviewDomains", () => {
-	test("sorts by createdAt asc/desc", () => {
-		const domains = [
-			makeDomain({ domainId: "old", createdAt: "2023-01-01T00:00:00.000Z" }),
-			makeDomain({ domainId: "new", createdAt: "2024-06-01T00:00:00.000Z" }),
-			makeDomain({ domainId: "mid", createdAt: "2023-12-01T00:00:00.000Z" }),
-		];
-
-		expect(
-			sortOverviewDomains(domains, "createdAt-asc").map((d) => d.domainId),
-		).toEqual(["old", "mid", "new"]);
-		expect(
-			sortOverviewDomains(domains, "createdAt-desc").map((d) => d.domainId),
-		).toEqual(["new", "mid", "old"]);
-	});
-
-	test("sorts by port asc/desc, with portless domains always last", () => {
-		const domains = [
-			makeDomain({ domainId: "none", port: null }),
-			makeDomain({ domainId: "low", port: 80 }),
-			makeDomain({ domainId: "high", port: 8080 }),
-		];
-
-		expect(
-			sortOverviewDomains(domains, "port-asc").map((d) => d.domainId),
-		).toEqual(["low", "high", "none"]);
-		expect(
-			sortOverviewDomains(domains, "port-desc").map((d) => d.domainId),
-		).toEqual(["high", "low", "none"]);
-	});
-
-	test("port sort with all domains portless is a no-op", () => {
-		const domains = [
-			makeDomain({ domainId: "a", port: null }),
-			makeDomain({ domainId: "b", port: null }),
-		];
-
-		expect(
-			sortOverviewDomains(domains, "port-desc").map((d) => d.domainId),
-		).toEqual(["a", "b"]);
-	});
-
-	test("does not mutate the input array", () => {
-		const domains = [
-			makeDomain({ domainId: "b", port: 8080 }),
-			makeDomain({ domainId: "a", port: 80 }),
-		];
-		const original = [...domains];
-
-		sortOverviewDomains(domains, "port-asc");
-
-		expect(domains).toEqual(original);
-	});
-});

apps/dokploy/__test__/services/overview-services-sort.test.ts

@@ -1,106 +0,0 @@
-import type { OverviewService } from "@dokploy/server/services/overview";
-import { sortOverviewServices } from "@dokploy/server/services/overview";
-import { describe, expect, test } from "vitest";
-
-const makeService = (overrides: Partial<OverviewService>): OverviewService => ({
-	id: "id",
-	type: "application",
-	name: "name",
-	appName: "app-name",
-	status: "running",
-	createdAt: "2024-01-01T00:00:00.000Z",
-	serverId: null,
-	serverName: null,
-	icon: null,
-	projectId: "project",
-	projectName: "Project",
-	environmentId: "environment",
-	environmentName: "Environment",
-	lastDeployAt: null,
-	...overrides,
-});
-
-describe("sortOverviewServices", () => {
-	test("sorts by name asc/desc", () => {
-		const services = [
-			makeService({ id: "b", name: "Bravo" }),
-			makeService({ id: "a", name: "Alpha" }),
-			makeService({ id: "c", name: "Charlie" }),
-		];
-
-		expect(sortOverviewServices(services, "name-asc").map((s) => s.id)).toEqual(
-			["a", "b", "c"],
-		);
-		expect(
-			sortOverviewServices(services, "name-desc").map((s) => s.id),
-		).toEqual(["c", "b", "a"]);
-	});
-
-	test("sorts by type asc/desc", () => {
-		const services = [
-			makeService({ id: "app", type: "application" }),
-			makeService({ id: "pg", type: "postgres" }),
-			makeService({ id: "comp", type: "compose" }),
-		];
-
-		expect(sortOverviewServices(services, "type-asc").map((s) => s.id)).toEqual(
-			["app", "comp", "pg"],
-		);
-		expect(
-			sortOverviewServices(services, "type-desc").map((s) => s.id),
-		).toEqual(["pg", "comp", "app"]);
-	});
-
-	test("sorts by createdAt asc/desc", () => {
-		const services = [
-			makeService({ id: "old", createdAt: "2023-01-01T00:00:00.000Z" }),
-			makeService({ id: "new", createdAt: "2024-06-01T00:00:00.000Z" }),
-			makeService({ id: "mid", createdAt: "2023-12-01T00:00:00.000Z" }),
-		];
-
-		expect(
-			sortOverviewServices(services, "createdAt-asc").map((s) => s.id),
-		).toEqual(["old", "mid", "new"]);
-		expect(
-			sortOverviewServices(services, "createdAt-desc").map((s) => s.id),
-		).toEqual(["new", "mid", "old"]);
-	});
-
-	test("sorts by lastDeploy asc/desc, with never-deployed services always last", () => {
-		const services = [
-			makeService({ id: "never", lastDeployAt: null }),
-			makeService({ id: "old", lastDeployAt: "2023-01-01T00:00:00.000Z" }),
-			makeService({ id: "new", lastDeployAt: "2024-06-01T00:00:00.000Z" }),
-		];
-
-		expect(
-			sortOverviewServices(services, "lastDeploy-desc").map((s) => s.id),
-		).toEqual(["new", "old", "never"]);
-		expect(
-			sortOverviewServices(services, "lastDeploy-asc").map((s) => s.id),
-		).toEqual(["old", "new", "never"]);
-	});
-
-	test("lastDeploy sort with all services never deployed is a no-op", () => {
-		const services = [
-			makeService({ id: "a", lastDeployAt: null }),
-			makeService({ id: "b", lastDeployAt: null }),
-		];
-
-		expect(
-			sortOverviewServices(services, "lastDeploy-desc").map((s) => s.id),
-		).toEqual(["a", "b"]);
-	});
-
-	test("does not mutate the input array", () => {
-		const services = [
-			makeService({ id: "b", name: "Bravo" }),
-			makeService({ id: "a", name: "Alpha" }),
-		];
-		const original = [...services];
-
-		sortOverviewServices(services, "name-asc");
-
-		expect(services).toEqual(original);
-	});
-});

apps/dokploy/__test__/setup/monitoring-setup.real.test.ts

@@ -1,261 +0,0 @@
-import { execSync } from "node:child_process";
-import { docker } from "@dokploy/server/constants";
-import { setupMonitoring } from "@dokploy/server/setup/monitoring-setup";
-import { afterAll, beforeEach, describe, expect, it, vi } from "vitest";
-
-const REAL_TEST_TIMEOUT = 120000;
-const SERVICE_NAME = "dokploy-monitoring";
-const TEST_IMAGE = "busybox:latest";
-
-// Mock ONLY db-backed lookups and remote I/O. Dockerode stays real and talks to
-// the local daemon, so the legacy-container cleanup is exercised for real.
-vi.mock("@dokploy/server/services/server", () => ({
-	findServerById: vi.fn().mockResolvedValue({
-		serverId: "test-server",
-		serverType: "deploy",
-		sshKeyId: null, // -> getRemoteDocker returns the local docker instance
-		metricsConfig: {
-			server: {
-				type: "Remote",
-				port: 4500,
-				token: "test-token",
-				urlCallback: "http://localhost/callback",
-				cronJob: "0 0 * * *",
-				retentionDays: 2,
-				refreshRate: 60,
-				thresholds: { cpu: 0, memory: 0 },
-			},
-			containers: { refreshRate: 60, services: { include: [], exclude: [] } },
-		},
-	}),
-}));
-
-vi.mock("@dokploy/server/services/settings", () => ({
-	getDokployImageTag: vi.fn(() => "latest"),
-}));
-
-vi.mock("@dokploy/server/utils/docker/utils", () => ({
-	pullImage: vi.fn().mockResolvedValue(undefined),
-	pullRemoteImage: vi.fn().mockResolvedValue(undefined),
-}));
-
-vi.mock("@dokploy/server/utils/process/execAsync", () => ({
-	execAsync: vi.fn().mockResolvedValue({ stdout: "", stderr: "" }),
-	execAsyncRemote: vi.fn().mockResolvedValue({ stdout: "", stderr: "" }),
-}));
-
-const containerExists = async (name: string) => {
-	try {
-		await docker.getContainer(name).inspect();
-		return true;
-	} catch (error: any) {
-		if (error.statusCode === 404) return false;
-		throw error;
-	}
-};
-
-const serviceExists = async (name: string) => {
-	try {
-		await docker.getService(name).inspect();
-		return true;
-	} catch (error: any) {
-		if (error.statusCode === 404) return false;
-		throw error;
-	}
-};
-
-// Swarm keeps converging a service for a bit after it's created (scheduling
-// tasks, resolving endpoints), which bumps Version.Index on its own. Calling
-// setupMonitoring again before that settles races that internal bump, so wait
-// for two consecutive reads to agree before treating the service as stable.
-const waitForServiceConvergence = async (name: string, timeoutMs = 5000) => {
-	const deadline = Date.now() + timeoutMs;
-	let lastIndex: string | null = null;
-	while (Date.now() < deadline) {
-		const inspect = await docker.getService(name).inspect();
-		if (inspect.Version.Index === lastIndex) return;
-		lastIndex = inspect.Version.Index;
-		await new Promise((resolve) => setTimeout(resolve, 50));
-	}
-};
-
-const swarmTaskNames = async () => {
-	const list = await docker.listContainers({ all: true });
-	return list
-		.flatMap((c) => c.Names.map((n) => n.replace(/^\//, "")))
-		.filter((n) => n.startsWith(`${SERVICE_NAME}.`));
-};
-
-const cleanup = async () => {
-	try {
-		await docker.getService(SERVICE_NAME).remove();
-	} catch {}
-	try {
-		await docker.getContainer(SERVICE_NAME).remove({ force: true });
-	} catch {}
-	for (const name of await swarmTaskNames()) {
-		try {
-			await docker.getContainer(name).remove({ force: true });
-		} catch {}
-	}
-};
-
-// Recreates the pre-v0.30.0 standalone agent stuck in a crash loop.
-const createLegacyZombie = async () => {
-	const container = await docker.createContainer({
-		name: SERVICE_NAME,
-		Image: TEST_IMAGE,
-		Cmd: [
-			"sh",
-			"-c",
-			"echo 'Error starting metrics cleanup system: empty spec string'; exit 1",
-		],
-		HostConfig: { RestartPolicy: { Name: "always" }, NetworkMode: "host" },
-	});
-	await container.start();
-};
-
-const pullTestImage = async () => {
-	try {
-		await docker.getImage(TEST_IMAGE).inspect();
-		return;
-	} catch {}
-	await new Promise<void>((resolve, reject) =>
-		docker.pull(TEST_IMAGE, (err: any, stream: any) =>
-			err
-				? reject(err)
-				: docker.modem.followProgress(stream, (e: any) =>
-						e ? reject(e) : resolve(),
-					),
-		),
-	);
-};
-
-// The code under test hardcodes the production name, so this suite cannot
-// namespace its fixtures. Skip rather than wipe a real agent on a Dokploy host.
-const hasRealMonitoring = () => {
-	const query = (cmd: string) => {
-		try {
-			return execSync(cmd, { stdio: ["ignore", "pipe", "ignore"] })
-				.toString()
-				.trim();
-		} catch {
-			return "";
-		}
-	};
-
-	return (
-		query(
-			`docker service ls --filter name=${SERVICE_NAME} --format '{{.Name}}'`,
-		) !== "" ||
-		query(
-			`docker ps -a --filter name=^${SERVICE_NAME}$ --format '{{.Names}}'`,
-		) !== ""
-	);
-};
-
-const hasDocker = () => {
-	try {
-		execSync("docker info", { stdio: "ignore" });
-		return true;
-	} catch {
-		return false;
-	}
-};
-
-describe.skipIf(!hasDocker() || hasRealMonitoring() || !process.env.CI)(
-	"setupMonitoring - legacy container cleanup (real docker)",
-	() => {
-		beforeEach(async () => {
-			await pullTestImage();
-			await cleanup();
-		}, REAL_TEST_TIMEOUT);
-
-		afterAll(async () => {
-			await cleanup();
-		}, REAL_TEST_TIMEOUT);
-
-		it(
-			"removes the legacy standalone container left behind by the swarm migration",
-			async () => {
-				await createLegacyZombie();
-				expect(await containerExists(SERVICE_NAME)).toBe(true);
-
-				await setupMonitoring("test-server");
-
-				expect(await containerExists(SERVICE_NAME)).toBe(false);
-				expect(await serviceExists(SERVICE_NAME)).toBe(true);
-			},
-			REAL_TEST_TIMEOUT,
-		);
-
-		it(
-			"removes the legacy container without touching swarm tasks, which are named dokploy-monitoring.<slot>.<id>",
-			async () => {
-				const taskName = `${SERVICE_NAME}.1.qh3ldvg2h9x0test`;
-				const task = await docker.createContainer({
-					name: taskName,
-					Image: TEST_IMAGE,
-					Cmd: ["sleep", "3600"],
-				});
-				await task.start();
-				await createLegacyZombie();
-
-				await setupMonitoring("test-server");
-
-				expect(await containerExists(SERVICE_NAME)).toBe(false);
-				expect(await containerExists(taskName)).toBe(true);
-				const inspect = await docker.getContainer(taskName).inspect();
-				expect(inspect.State.Running).toBe(true);
-			},
-			REAL_TEST_TIMEOUT,
-		);
-
-		it(
-			"is idempotent when no legacy container exists",
-			async () => {
-				expect(await containerExists(SERVICE_NAME)).toBe(false);
-
-				await expect(setupMonitoring("test-server")).resolves.not.toThrow();
-				await waitForServiceConvergence(SERVICE_NAME);
-				await expect(setupMonitoring("test-server")).resolves.not.toThrow();
-
-				expect(await serviceExists(SERVICE_NAME)).toBe(true);
-			},
-			REAL_TEST_TIMEOUT,
-		);
-
-		it(
-			"deploys the service even when removing the legacy container fails",
-			async () => {
-				const failingDocker = {
-					getContainer: () => ({
-						remove: async () => {
-							const error: any = new Error("device or resource busy");
-							error.statusCode = 500;
-							throw error;
-						},
-					}),
-					getService: docker.getService.bind(docker),
-					createService: docker.createService.bind(docker),
-				};
-
-				const remoteDocker = await import(
-					"@dokploy/server/utils/servers/remote-docker"
-				);
-				const spy = vi
-					.spyOn(remoteDocker, "getRemoteDocker")
-					.mockResolvedValue(failingDocker as any);
-
-				try {
-					await expect(setupMonitoring("test-server")).resolves.not.toThrow();
-					expect(spy).toHaveBeenCalled(); // guards against the spy silently not intercepting
-					expect(await serviceExists(SERVICE_NAME)).toBe(true);
-				} finally {
-					spy.mockRestore();
-				}
-			},
-			REAL_TEST_TIMEOUT,
-		);
-	},
-);

apps/dokploy/__test__/traefik/forward-auth.test.ts

@@ -35,7 +35,6 @@ const baseDomain: Domain = {
 	stripPath: false,
 	middlewares: null,
 	forwardAuthEnabled: false,
-	enabled: true,
 };
 
 describe("forwardAuthMiddlewareName", () => {

apps/dokploy/__test__/traefik/reconnect-services.test.ts

@@ -1,71 +0,0 @@
-import { reconnectServicesToTraefik } from "@dokploy/server/services/settings";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const mocks = vi.hoisted(() => ({
-	findMany: vi.fn(),
-	execAsync: vi.fn(),
-	execAsyncRemote: vi.fn(),
-}));
-
-vi.mock("@dokploy/server/db", () => ({
-	db: {
-		query: {
-			compose: {
-				findMany: mocks.findMany,
-			},
-		},
-	},
-}));
-
-vi.mock("@dokploy/server/utils/process/execAsync", () => ({
-	execAsync: mocks.execAsync,
-	execAsyncRemote: mocks.execAsyncRemote,
-}));
-
-describe("reconnectServicesToTraefik", () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
-		mocks.findMany.mockResolvedValue([]);
-	});
-
-	it("does not execute an empty local command when no isolated deployments exist", async () => {
-		await reconnectServicesToTraefik();
-
-		expect(mocks.execAsync).not.toHaveBeenCalled();
-	});
-
-	it("does not execute an empty remote command when no isolated deployments exist", async () => {
-		await reconnectServicesToTraefik("server-id");
-
-		expect(mocks.execAsyncRemote).not.toHaveBeenCalled();
-	});
-
-	it("reconnects isolated deployments to the local Traefik network", async () => {
-		mocks.findMany.mockResolvedValue([
-			{ appName: "first-compose" },
-			{ appName: "second-compose" },
-		]);
-
-		await reconnectServicesToTraefik();
-
-		expect(mocks.execAsync).toHaveBeenCalledOnce();
-		expect(mocks.execAsync).toHaveBeenCalledWith(
-			'docker network connect first-compose $(docker ps --filter "name=dokploy-traefik" -q) >/dev/null 2>&1\n' +
-				'docker network connect second-compose $(docker ps --filter "name=dokploy-traefik" -q) >/dev/null 2>&1\n',
-		);
-		expect(mocks.execAsyncRemote).not.toHaveBeenCalled();
-	});
-
-	it("reconnects isolated deployments on a remote server", async () => {
-		mocks.findMany.mockResolvedValue([{ appName: "remote-compose" }]);
-
-		await reconnectServicesToTraefik("server-id");
-
-		expect(mocks.execAsyncRemote).toHaveBeenCalledOnce();
-		expect(mocks.execAsyncRemote).toHaveBeenCalledWith(
-			"server-id",
-			'docker network connect remote-compose $(docker ps --filter "name=dokploy-traefik" -q) >/dev/null 2>&1\n',
-		);
-		expect(mocks.execAsync).not.toHaveBeenCalled();
-	});
-});

apps/dokploy/__test__/traefik/server/update-server-config.test.ts

@@ -60,7 +60,7 @@ const baseSettings: WebServerSettings = {
 		docsUrl: null,
 		errorPageTitle: null,
 		errorPageDescription: null,
-		ogImageUrl: null,
+		metaTitle: null,
 		footerText: null,
 	},
 	cleanupCacheApplications: false,

apps/dokploy/__test__/traefik/traefik.test.ts

@@ -151,7 +151,6 @@ const baseDomain: Domain = {
 	stripPath: false,
 	middlewares: null,
 	forwardAuthEnabled: false,
-	enabled: true,
 };
 
 const baseRedirect: Redirect = {

apps/dokploy/__test__/traefik/write-app-traefik-config.test.ts

@@ -1,121 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { writeAppTraefikConfig } from "@dokploy/server/utils/traefik/application";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const mocks = vi.hoisted(() => ({
-	execAsyncRemote: vi.fn(),
-	writeFileRemote: vi.fn(),
-}));
-
-vi.mock("@dokploy/server/utils/process/execAsync", async (importOriginal) => {
-	const actual =
-		await importOriginal<
-			typeof import("@dokploy/server/utils/process/execAsync")
-		>();
-	return {
-		...actual,
-		execAsyncRemote: mocks.execAsyncRemote,
-		writeFileRemote: mocks.writeFileRemote,
-	};
-});
-
-describe("writeAppTraefikConfig", () => {
-	let cwd: string;
-	let dynamicPath: string;
-
-	beforeEach(() => {
-		cwd = fs.mkdtempSync(path.join(os.tmpdir(), "dokploy-traefik-"));
-		dynamicPath = path.join(cwd, ".docker", "traefik", "dynamic");
-		fs.mkdirSync(dynamicPath, { recursive: true });
-		vi.spyOn(process, "cwd").mockReturnValue(cwd);
-		vi.clearAllMocks();
-	});
-
-	afterEach(() => {
-		vi.restoreAllMocks();
-		fs.rmSync(cwd, { recursive: true, force: true });
-	});
-
-	// Regression test for #5189: Traefik's file provider rejects a standalone
-	// `routers: {}` / `services: {}` map and aborts its watcher for every
-	// dynamic config once it hits one, so an app with no domains must never
-	// get an on-disk config file at all.
-	it("removes the file instead of writing empty routers/services", async () => {
-		const appName = "no-domain-app";
-		const configPath = path.join(dynamicPath, `${appName}.yml`);
-		fs.writeFileSync(configPath, "stale content", "utf8");
-
-		await writeAppTraefikConfig(
-			{ http: { routers: {}, services: {} } },
-			appName,
-		);
-
-		expect(fs.existsSync(configPath)).toBe(false);
-	});
-
-	it("writes the file when routers/services are present", async () => {
-		const appName = "with-domain-app";
-		const configPath = path.join(dynamicPath, `${appName}.yml`);
-
-		await writeAppTraefikConfig(
-			{
-				http: {
-					routers: {
-						[`${appName}-router-1`]: {
-							rule: "Host(`x`)",
-							service: `${appName}-service`,
-						},
-					},
-					services: {},
-				},
-			},
-			appName,
-		);
-
-		expect(fs.existsSync(configPath)).toBe(true);
-	});
-
-	it("removes the remote file instead of writing empty routers/services", async () => {
-		mocks.execAsyncRemote.mockResolvedValue({ stdout: "", stderr: "" });
-
-		await writeAppTraefikConfig(
-			{ http: { routers: {}, services: {} } },
-			"no-domain-app",
-			"server-id",
-		);
-
-		expect(mocks.execAsyncRemote).toHaveBeenCalledOnce();
-		const [, command] = mocks.execAsyncRemote.mock.calls[0] ?? [];
-		expect(command).toMatch(/^rm -f /);
-		expect(command).toContain("no-domain-app.yml");
-	});
-
-	it("writes the remote file when routers/services are present", async () => {
-		mocks.writeFileRemote.mockResolvedValue(undefined);
-
-		await writeAppTraefikConfig(
-			{
-				http: {
-					routers: {
-						"with-domain-app-router-1": {
-							rule: "Host(`x`)",
-							service: "with-domain-app-service",
-						},
-					},
-					services: {},
-				},
-			},
-			"with-domain-app",
-			"server-id",
-		);
-
-		expect(mocks.writeFileRemote).toHaveBeenCalledOnce();
-		const [serverId, remotePath, content] =
-			mocks.writeFileRemote.mock.calls[0] ?? [];
-		expect(serverId).toBe("server-id");
-		expect(remotePath).toContain("with-domain-app.yml");
-		expect(content).toContain("with-domain-app-router-1");
-	});
-});

apps/dokploy/__test__/wss/authorize.test.ts

@@ -95,35 +95,10 @@ describe("canAccessTerminalOverWss", () => {
 	});
 
 	it("gates a remote server terminal on server access", async () => {
-		mockHasPermission.mockResolvedValue(true);
 		mockGetAccessibleServerIds.mockResolvedValue(new Set(["srv-1"]));
 		expect(await canAccessTerminalOverWss(USER, SESSION, "srv-1")).toBe(true);
 		expect(await canAccessTerminalOverWss(USER, SESSION, "srv-2")).toBe(false);
-		// the remote path must never fall through to the owner/admin local branch
+		// role lookup must not be needed for the remote path
 		expect(mockFindMember).not.toHaveBeenCalled();
 	});
-
-	it("denies a remote server terminal without the server.terminal permission", async () => {
-		// Reaching a server (to deploy on it) must not imply a root shell on it.
-		mockGetAccessibleServerIds.mockResolvedValue(new Set(["srv-1"]));
-		mockHasPermission.mockResolvedValue(false);
-		expect(await canAccessTerminalOverWss(USER, SESSION, "srv-1")).toBe(false);
-		expect(mockHasPermission).toHaveBeenCalledWith(
-			{ user: { id: USER.id }, session: { activeOrganizationId: "org-1" } },
-			{ server: ["terminal"] },
-		);
-	});
-
-	it("allows a remote server terminal with the server.terminal permission", async () => {
-		mockGetAccessibleServerIds.mockResolvedValue(new Set(["srv-1"]));
-		mockHasPermission.mockResolvedValue(true);
-		expect(await canAccessTerminalOverWss(USER, SESSION, "srv-1")).toBe(true);
-	});
-
-	it("does not check permissions for a server the caller cannot access", async () => {
-		mockGetAccessibleServerIds.mockResolvedValue(new Set(["srv-1"]));
-		mockHasPermission.mockResolvedValue(true);
-		expect(await canAccessTerminalOverWss(USER, SESSION, "srv-2")).toBe(false);
-		expect(mockHasPermission).not.toHaveBeenCalled();
-	});
 });

apps/dokploy/__test__/wss/readValidDirectory.test.ts

@@ -94,32 +94,4 @@ describe("readValidDirectory (path traversal)", () => {
 			),
 		).toBe(true);
 	});
-
-	it("returns true for SvelteKit routes with + prefix and @ symbols", () => {
-		expect(
-			readValidDirectory(
-				`${BASE}/applications/myapp/code/src/routes/+page.svelte`,
-			),
-		).toBe(true);
-		expect(
-			readValidDirectory(
-				`${BASE}/applications/myapp/code/src/routes/+layout.svelte`,
-			),
-		).toBe(true);
-		expect(
-			readValidDirectory(
-				`${BASE}/applications/myapp/code/src/routes/+server.ts`,
-			),
-		).toBe(true);
-		expect(
-			readValidDirectory(
-				`${BASE}/applications/myapp/code/src/routes/+error.svelte`,
-			),
-		).toBe(true);
-		expect(
-			readValidDirectory(
-				`${BASE}/applications/myapp/code/node_modules/@types/node/index.d.ts`,
-			),
-		).toBe(true);
-	});
 });

apps/dokploy/components/dashboard/application/advanced/cluster/show-cluster-settings.tsx

@@ -187,7 +187,7 @@ export const ShowClusterSettings = ({ id, type }: Props) => {
 												To use a cluster feature, you need to configure at least
 												a registry first. Please, go to{" "}
 												<Link
-													href="/dashboard/docker?tab=swarm&subtab=nodes"
+													href="/dashboard/settings/cluster"
 													className="text-foreground"
 												>
 													Settings

apps/dokploy/components/dashboard/application/advanced/cluster/swarm-forms/index.ts

@@ -8,3 +8,4 @@ export { RestartPolicyForm } from "./restart-policy-form";
 export { RollbackConfigForm } from "./rollback-config-form";
 export { StopGracePeriodForm } from "./stop-grace-period-form";
 export { UpdateConfigForm } from "./update-config-form";
+export { filterEmptyValues, hasValues } from "./utils";

apps/dokploy/components/dashboard/application/advanced/cluster/swarm-forms/utils.ts

@@ -0,0 +1,31 @@
+/**
+ * Filters out undefined, null, and empty string values from form data
+ * Only returns fields that have actual values
+ */
+export const filterEmptyValues = (
+	formData: Record<string, any>,
+): Record<string, any> => {
+	return Object.entries(formData).reduce(
+		(acc, [key, value]) => {
+			// Keep arrays even if empty (they might be intentionally cleared)
+			if (Array.isArray(value)) {
+				if (value.length > 0) {
+					acc[key] = value;
+				}
+			}
+			// For other values, filter out undefined, null, and empty strings
+			else if (value !== undefined && value !== null && value !== "") {
+				acc[key] = value;
+			}
+			return acc;
+		},
+		{} as Record<string, any>,
+	);
+};
+
+/**
+ * Checks if filtered data has any values to save
+ */
+export const hasValues = (data: Record<string, any>): boolean => {
+	return Object.keys(data).length > 0;
+};

apps/dokploy/components/dashboard/application/advanced/redirects/handle-redirect.tsx

@@ -234,7 +234,7 @@ export const HandleRedirect = ({
 									<FormItem>
 										<FormLabel>Replacement</FormLabel>
 										<FormControl>
-											<Input placeholder="http://mydomain/$1" {...field} />
+											<Input placeholder="http://mydomain/$${1}" {...field} />
 										</FormControl>
 
 										<FormMessage />

apps/dokploy/components/dashboard/application/build/show.tsx

@@ -31,45 +31,6 @@ import { api } from "@/utils/api";
 
 // Railpack versions from https://github.com/railwayapp/railpack/releases
 export const RAILPACK_VERSIONS = [
-	"0.39.0",
-	"0.38.0",
-	"0.37.1",
-	"0.37.0",
-	"0.36.4",
-	"0.36.3",
-	"0.36.2",
-	"0.36.1",
-	"0.36.0",
-	"0.35.0",
-	"0.34.0",
-	"0.33.0",
-	"0.32.0",
-	"0.31.2",
-	"0.31.1",
-	"0.31.0",
-	"0.30.1",
-	"0.30.0",
-	"0.29.0",
-	"0.28.0",
-	"0.27.2",
-	"0.27.1",
-	"0.27.0",
-	"0.26.1",
-	"0.26.0",
-	"0.25.0",
-	"0.24.0",
-	"0.23.0",
-	"0.22.2",
-	"0.22.1",
-	"0.22.0",
-	"0.21.0",
-	"0.20.0",
-	"0.19.0",
-	"0.18.0",
-	"0.17.2",
-	"0.17.1",
-	"0.17.0",
-	"0.16.0",
 	"0.15.4",
 	"0.15.3",
 	"0.15.2",
@@ -84,22 +45,12 @@ export const RAILPACK_VERSIONS = [
 	"0.9.1",
 	"0.9.0",
 	"0.8.0",
-	"0.7.2",
-	"0.7.1",
 	"0.7.0",
-	"0.6.1",
 	"0.6.0",
-	"0.5.1",
 	"0.5.0",
 	"0.4.0",
 	"0.3.0",
-	"0.2.3",
 	"0.2.2",
-	"0.2.1",
-	"0.2.0",
-	"0.1.2",
-	"0.1.1",
-	"0.1.0",
 ] as const;
 
 export enum BuildType {

apps/dokploy/components/dashboard/application/deployments/show-deployment.tsx

@@ -148,7 +148,7 @@ export const ShowDeployment = ({
 					<DialogDescription className="flex items-center gap-2">
 						<span className="flex items-center gap-2">
 							See all the details of this deployment |{" "}
-							<Badge variant="blank" className="text-xs tabular-nums">
+							<Badge variant="blank" className="text-xs">
 								{filteredLogs.length} lines
 							</Badge>
 						</span>

apps/dokploy/components/dashboard/application/deployments/show-deployments.tsx

@@ -342,7 +342,7 @@ export const ShowDeployments = ({
 											)}
 											{/* Hash (from description) - shown in compact form */}
 											{deployment.description?.trim() && (
-												<span className="wrap-anywhere text-xs text-muted-foreground font-mono">
+												<span className="text-xs text-muted-foreground font-mono">
 													{deployment.description}
 												</span>
 											)}

apps/dokploy/components/dashboard/application/domains/columns.tsx

@@ -14,7 +14,6 @@ import Link from "next/link";
 import { DialogAction } from "@/components/shared/dialog-action";
 import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
-import { Switch } from "@/components/ui/switch";
 import {
 	Tooltip,
 	TooltipContent,
@@ -36,9 +35,7 @@ interface ColumnsProps {
 	validationStates: ValidationStates;
 	handleValidateDomain: (host: string) => Promise<void>;
 	handleDeleteDomain: (domainId: string) => Promise<void>;
-	handleToggleEnable: (domainId: string) => Promise<void>;
 	isDeleting: boolean;
-	isToggling: boolean;
 	serverIp?: string;
 	canCreateDomain: boolean;
 	canDeleteDomain: boolean;
@@ -50,9 +47,7 @@ export const createColumns = ({
 	validationStates,
 	handleValidateDomain,
 	handleDeleteDomain,
-	handleToggleEnable,
 	isDeleting,
-	isToggling,
 	serverIp,
 	canCreateDomain,
 	canDeleteDomain,
@@ -254,42 +249,6 @@ export const createColumns = ({
 			);
 		},
 	},
-	{
-		id: "status",
-		header: "Status",
-		cell: ({ row }) => {
-			const domain = row.original;
-			if (!canCreateDomain) {
-				return (
-					<Badge variant={domain.enabled ? "outline" : "secondary"}>
-						{domain.enabled ? "Enabled" : "Disabled"}
-					</Badge>
-				);
-			}
-			return (
-				<TooltipProvider>
-					<Tooltip>
-						<TooltipTrigger asChild>
-							<div className="flex items-center">
-								<Switch
-									checked={domain.enabled}
-									onCheckedChange={() => handleToggleEnable(domain.domainId)}
-									disabled={isToggling}
-								/>
-							</div>
-						</TooltipTrigger>
-						<TooltipContent>
-							<p>
-								{domain.enabled
-									? "Domain is active. Toggle to disable routing without deleting it."
-									: "Domain is disabled and not routed. Toggle to enable it again."}
-							</p>
-						</TooltipContent>
-					</Tooltip>
-				</TooltipProvider>
-			);
-		},
-	},
 	{
 		id: "actions",
 		header: "Actions",

apps/dokploy/components/dashboard/application/domains/handle-domain.tsx

@@ -46,7 +46,6 @@ import {
 	TooltipTrigger,
 } from "@/components/ui/tooltip";
 import { api } from "@/utils/api";
-import { COMPOSE_REDEPLOY_TOAST, ComposeRedeployAlert } from "./redeploy-hint";
 
 export type CacheType = "fetch" | "cache";
 
@@ -156,7 +155,7 @@ export const AddDomain = ({ id, type, domainId = "", children }: Props) => {
 			domainId,
 		},
 		{
-			enabled: isOpen && !!domainId,
+			enabled: !!domainId,
 		},
 	);
 
@@ -167,7 +166,7 @@ export const AddDomain = ({ id, type, domainId = "", children }: Props) => {
 						applicationId: id,
 					},
 					{
-						enabled: isOpen && !!id,
+						enabled: !!id,
 					},
 				)
 			: api.compose.one.useQuery(
@@ -175,7 +174,7 @@ export const AddDomain = ({ id, type, domainId = "", children }: Props) => {
 						composeId: id,
 					},
 					{
-						enabled: isOpen && !!id,
+						enabled: !!id,
 					},
 				);
 
@@ -187,14 +186,9 @@ export const AddDomain = ({ id, type, domainId = "", children }: Props) => {
 		api.domain.generateDomain.useMutation();
 
 	const { data: canGenerateTraefikMeDomains } =
-		api.domain.canGenerateTraefikMeDomains.useQuery(
-			{
-				serverId: application?.serverId || "",
-			},
-			{
-				enabled: isOpen,
-			},
-		);
+		api.domain.canGenerateTraefikMeDomains.useQuery({
+			serverId: application?.serverId || "",
+		});
 
 	const {
 		data: services,
@@ -209,7 +203,7 @@ export const AddDomain = ({ id, type, domainId = "", children }: Props) => {
 		{
 			retry: false,
 			refetchOnWindowFocus: false,
-			enabled: isOpen && type === "compose" && !!id,
+			enabled: type === "compose" && !!id,
 		},
 	);
 
@@ -306,12 +300,7 @@ export const AddDomain = ({ id, type, domainId = "", children }: Props) => {
 			customEntrypoint: data.useCustomEntrypoint ? data.customEntrypoint : null,
 		})
 			.then(async () => {
-				toast.success(
-					dictionary.success,
-					data.domainType === "compose"
-						? { description: COMPOSE_REDEPLOY_TOAST }
-						: undefined,
-				);
+				toast.success(dictionary.success);
 
 				if (data.domainType === "application") {
 					await utils.domain.byApplicationId.invalidate({
@@ -348,7 +337,12 @@ export const AddDomain = ({ id, type, domainId = "", children }: Props) => {
 				</DialogHeader>
 				{isError && <AlertBlock type="error">{error?.message}</AlertBlock>}
 
-				{type === "compose" && <ComposeRedeployAlert className="mb-4" />}
+				{type === "compose" && (
+					<AlertBlock type="info" className="mb-4">
+						Whenever you make changes to domains, remember to redeploy your
+						compose to apply the changes.
+					</AlertBlock>
+				)}
 
 				<Form {...form}>
 					<form

apps/dokploy/components/dashboard/application/domains/redeploy-hint.tsx

@@ -1,19 +0,0 @@
-import { AlertBlock } from "@/components/shared/alert-block";
-
-/**
- * Domains attached to a compose service are rendered as docker labels and only
- * take effect on the next deployment. These strings keep the "redeploy required"
- * wording consistent across the add/edit dialog, the domains list and the
- * toasts shown after create/update/delete/toggle operations.
- */
-export const COMPOSE_REDEPLOY_HINT =
-	"Whenever you make changes to domains, remember to redeploy your compose to apply the changes.";
-
-export const COMPOSE_REDEPLOY_TOAST =
-	"Redeploy the compose to apply the changes.";
-
-export const ComposeRedeployAlert = ({ className }: { className?: string }) => (
-	<AlertBlock type="info" className={className}>
-		{COMPOSE_REDEPLOY_HINT}
-	</AlertBlock>
-);

apps/dokploy/components/dashboard/application/domains/show-domains.tsx

@@ -44,7 +44,6 @@ import {
 	DropdownMenuTrigger,
 } from "@/components/ui/dropdown-menu";
 import { Input } from "@/components/ui/input";
-import { Switch } from "@/components/ui/switch";
 import {
 	Table,
 	TableBody,
@@ -59,13 +58,11 @@ import {
 	TooltipProvider,
 	TooltipTrigger,
 } from "@/components/ui/tooltip";
-import { cn } from "@/lib/utils";
 import { api } from "@/utils/api";
 import { createColumns } from "./columns";
 import { DnsHelperModal } from "./dns-helper-modal";
 import { AddDomain } from "./handle-domain";
 import { HandleForwardAuth } from "./handle-forward-auth";
-import { COMPOSE_REDEPLOY_TOAST, ComposeRedeployAlert } from "./redeploy-hint";
 
 export type ValidationState = {
 	isLoading: boolean;
@@ -149,34 +146,12 @@ export const ShowDomains = ({ id, type }: Props) => {
 		api.domain.validateDomain.useMutation();
 	const { mutateAsync: deleteDomain, isPending: isRemoving } =
 		api.domain.delete.useMutation();
-	const { mutateAsync: toggleEnable, isPending: isToggling } =
-		api.domain.toggleEnable.useMutation();
-
-	const handleToggleEnable = async (domainId: string) => {
-		try {
-			const result = await toggleEnable({ domainId });
-			refetch();
-			toast.success(
-				result.enabled ? "Domain enabled" : "Domain disabled",
-				result.requiresRedeploy
-					? { description: COMPOSE_REDEPLOY_TOAST }
-					: undefined,
-			);
-		} catch {
-			toast.error("Error updating the domain");
-		}
-	};
 
 	const handleDeleteDomain = async (domainId: string) => {
 		try {
 			await deleteDomain({ domainId });
 			refetch();
-			toast.success(
-				"Domain deleted successfully",
-				type === "compose"
-					? { description: COMPOSE_REDEPLOY_TOAST }
-					: undefined,
-			);
+			toast.success("Domain deleted successfully");
 		} catch {
 			toast.error("Error deleting domain");
 		}
@@ -191,7 +166,8 @@ export const ShowDomains = ({ id, type }: Props) => {
 		try {
 			const result = await validateDomain({
 				domain: host,
-				serverId: application?.serverId ?? undefined,
+				serverIp:
+					application?.server?.ipAddress?.toString() || ip?.toString() || "",
 			});
 
 			setValidationStates((prev) => ({
@@ -224,9 +200,7 @@ export const ShowDomains = ({ id, type }: Props) => {
 		validationStates,
 		handleValidateDomain,
 		handleDeleteDomain,
-		handleToggleEnable,
 		isDeleting: isRemoving,
-		isToggling,
 		serverIp: application?.server?.ipAddress?.toString() || ip?.toString(),
 		canCreateDomain,
 		canDeleteDomain,
@@ -291,11 +265,6 @@ export const ShowDomains = ({ id, type }: Props) => {
 						)}
 					</div>
 				</CardHeader>
-				{type === "compose" && data && data.length > 0 && (
-					<div className="px-6 pb-4">
-						<ComposeRedeployAlert />
-					</div>
-				)}
 				<CardContent className="flex w-full flex-row gap-4">
 					{isLoadingDomains ? (
 						<div className="flex w-full flex-row gap-4 min-h-[40vh] justify-center items-center">
@@ -444,10 +413,7 @@ export const ShowDomains = ({ id, type }: Props) => {
 								return (
 									<Card
 										key={item.domainId}
-										className={cn(
-											"relative overflow-hidden w-full border transition-all hover:shadow-md bg-transparent h-fit",
-											!item.enabled && "opacity-60",
-										)}
+										className="relative overflow-hidden w-full border transition-all hover:shadow-md bg-transparent h-fit"
 									>
 										<CardContent className="p-6">
 											<div className="flex flex-col gap-4">
@@ -500,7 +466,18 @@ export const ShowDomains = ({ id, type }: Props) => {
 																description="Are you sure you want to delete this domain?"
 																type="destructive"
 																onClick={async () => {
-																	await handleDeleteDomain(item.domainId);
+																	await deleteDomain({
+																		domainId: item.domainId,
+																	})
+																		.then((_data) => {
+																			refetch();
+																			toast.success(
+																				"Domain deleted successfully",
+																			);
+																		})
+																		.catch(() => {
+																			toast.error("Error deleting domain");
+																		});
 																}}
 															>
 																<Button
@@ -515,41 +492,15 @@ export const ShowDomains = ({ id, type }: Props) => {
 														)}
 													</div>
 												</div>
-												<div className="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
-													<div className="w-full break-all">
-														<Link
-															className="flex items-center gap-2 text-base font-medium hover:underline"
-															target="_blank"
-															href={`${item.https ? "https" : "http"}://${item.host}${item.path}`}
-														>
-															{item.host}
-															<ExternalLink className="size-4 min-w-4" />
-														</Link>
-													</div>
-													{canCreateDomain && (
-														<TooltipProvider>
-															<Tooltip>
-																<TooltipTrigger asChild>
-																	<div className="flex items-center shrink-0">
-																		<Switch
-																			checked={item.enabled}
-																			onCheckedChange={() =>
-																				handleToggleEnable(item.domainId)
-																			}
-																			disabled={isToggling}
-																		/>
-																	</div>
-																</TooltipTrigger>
-																<TooltipContent>
-																	<p>
-																		{item.enabled
-																			? "Domain is active. Toggle to disable routing without deleting it."
-																			: "Domain is disabled and not routed. Toggle to enable it again."}
-																	</p>
-																</TooltipContent>
-															</Tooltip>
-														</TooltipProvider>
-													)}
+												<div className="w-full break-all">
+													<Link
+														className="flex items-center gap-2 text-base font-medium hover:underline"
+														target="_blank"
+														href={`${item.https ? "https" : "http"}://${item.host}${item.path}`}
+													>
+														{item.host}
+														<ExternalLink className="size-4 min-w-4" />
+													</Link>
 												</div>
 
 												{/* Domain Details */}

apps/dokploy/components/dashboard/application/environment/show-environment.tsx

@@ -6,7 +6,6 @@ import { toast } from "sonner";
 import { z } from "zod";
 import { CodeEditor } from "@/components/shared/code-editor";
 import { useEnvCompletionSource } from "@/components/shared/env-autocomplete";
-import { VaultImportDialog } from "@/components/shared/vault-import-dialog";
 import { Button } from "@/components/ui/button";
 import {
 	Card,
@@ -198,18 +197,6 @@ export const ShowEnvironment = ({ id, type }: Props) => {
 								name="environment"
 								render={({ field }) => (
 									<FormItem>
-										<div className="flex justify-end">
-											<VaultImportDialog
-												projectId={data?.environment?.projectId}
-												environmentId={data?.environment?.environmentId}
-												currentEnv={field.value ?? ""}
-												onImport={(next) =>
-													form.setValue("environment", next, {
-														shouldDirty: true,
-													})
-												}
-											/>
-										</div>
 										<FormControl className="">
 											<CodeEditor
 												style={

apps/dokploy/components/dashboard/application/environment/show.tsx

@@ -151,8 +151,6 @@ export const ShowEnvironment = ({ applicationId }: Props) => {
 						}
 						placeholder={["NODE_ENV=production", "PORT=3000"].join("\n")}
 						completionSource={completionSource}
-						projectId={data?.environment?.projectId}
-						environmentId={data?.environment?.environmentId}
 					/>
 					{data?.buildType === "dockerfile" && (
 						<Secrets

apps/dokploy/components/dashboard/application/icon/show-icon-settings.tsx

@@ -1,3 +1,4 @@
+import DOMPurify from "dompurify";
 import { CircuitBoard, GlobeIcon, Pencil, Search, X } from "lucide-react";
 import { useEffect, useMemo, useState } from "react";
 import { toast } from "sonner";
@@ -13,7 +14,6 @@ import { Dropzone } from "@/components/ui/dropzone";
 import { Input } from "@/components/ui/input";
 import { type BundledIcon, bundledIcons } from "@/lib/bundled-icons";
 import { api } from "@/utils/api";
-import { sanitizeSvg } from "@/utils/sanitize-svg";
 
 interface ShowIconSettingsProps {
 	serviceId: string;
@@ -89,6 +89,15 @@ export const ShowIconSettings = ({
 		}
 	};
 
+	const sanitizeSvg = (svgContent: string): string | null => {
+		const clean = DOMPurify.sanitize(svgContent, {
+			USE_PROFILES: { svg: true, svgFilters: true },
+			ADD_TAGS: ["use"],
+		});
+		if (!clean) return null;
+		return `data:image/svg+xml;base64,${btoa(clean)}`;
+	};
+
 	const handleFileUpload = async (files: FileList | null) => {
 		if (!files || files.length === 0) return;
 		const file = files[0];

apps/dokploy/components/dashboard/application/logs/show.tsx

@@ -1,7 +1,6 @@
 import { Loader2 } from "lucide-react";
 import dynamic from "next/dynamic";
 import { useEffect, useState } from "react";
-import { resolveContainerSelection } from "@/components/dashboard/docker/logs/utils";
 import { Badge } from "@/components/ui/badge";
 import {
 	Card,
@@ -80,13 +79,17 @@ export const ShowDockerLogs = ({ appName, serverId, serviceId }: Props) => {
 			},
 		);
 
-	const availableContainers = option === "native" ? containers : services;
-
 	useEffect(() => {
-		setContainerId((currentContainerId) =>
-			resolveContainerSelection(currentContainerId, availableContainers),
-		);
-	}, [availableContainers]);
+		if (option === "native") {
+			if (containers && containers?.length > 0) {
+				setContainerId(containers[0]?.containerId);
+			}
+		} else {
+			if (services && services?.length > 0) {
+				setContainerId(services[0]?.containerId);
+			}
+		}
+	}, [option, services, containers]);
 
 	const isLoading = option === "native" ? containersLoading : servicesLoading;
 	const containersLength =
@@ -102,7 +105,7 @@ export const ShowDockerLogs = ({ appName, serverId, serviceId }: Props) => {
 			</CardHeader>
 
 			<CardContent className="flex flex-col gap-4">
-				<div className="flex flex-col sm:flex-row justify-between sm:items-center gap-2">
+				<div className="flex flex-row justify-between items-center gap-2">
 					<Label>Select a container to view logs</Label>
 					<div className="flex flex-row gap-2 items-center">
 						<span className="text-sm text-muted-foreground">
@@ -111,7 +114,6 @@ export const ShowDockerLogs = ({ appName, serverId, serviceId }: Props) => {
 						<Switch
 							checked={option === "native"}
 							onCheckedChange={(checked) => {
-								setContainerId(undefined);
 								setOption(checked ? "native" : "swarm");
 							}}
 						/>

apps/dokploy/components/dashboard/application/volume-backups/restore-volume-backups.tsx

@@ -50,7 +50,6 @@ interface Props {
 	id: string;
 	type: "application" | "compose";
 	serverId?: string;
-	trigger?: React.ReactNode;
 }
 
 const RestoreBackupSchema = z.object({
@@ -65,12 +64,7 @@ const RestoreBackupSchema = z.object({
 	}),
 });
 
-export const RestoreVolumeBackups = ({
-	id,
-	type,
-	serverId,
-	trigger,
-}: Props) => {
+export const RestoreVolumeBackups = ({ id, type, serverId }: Props) => {
 	const [isOpen, setIsOpen] = useState(false);
 	const [search, setSearch] = useState("");
 	const [debouncedSearchTerm, setDebouncedSearchTerm] = useState("");
@@ -150,12 +144,10 @@ export const RestoreVolumeBackups = ({
 	return (
 		<Dialog open={isOpen} onOpenChange={setIsOpen}>
 			<DialogTrigger asChild>
-				{trigger ?? (
-					<Button variant="outline">
-						<RotateCcw className="mr-2 size-4" />
-						Restore Volume Backup
-					</Button>
-				)}
+				<Button variant="outline">
+					<RotateCcw className="mr-2 size-4" />
+					Restore Volume Backup
+				</Button>
 			</DialogTrigger>
 			<DialogContent className="sm:max-w-lg">
 				<DialogHeader>

apps/dokploy/components/dashboard/billing/trial-banner.tsx

@@ -1,47 +0,0 @@
-import { Rocket } from "lucide-react";
-import { useRouter } from "next/router";
-import { Button } from "@/components/ui/button";
-import { api } from "@/utils/api";
-
-export const TrialBanner = () => {
-	const router = useRouter();
-	const { data: billingStatus } = api.stripe.getBillingStatus.useQuery();
-	const { mutateAsync: createCustomerPortalSession, isPending } =
-		api.stripe.createCustomerPortalSession.useMutation();
-
-	const handleAddPaymentMethod = async () => {
-		const session = await createCustomerPortalSession().catch(() => null);
-		if (session?.url) {
-			window.open(session.url);
-			return;
-		}
-		router.push("/dashboard/settings/billing");
-	};
-
-	if (!billingStatus?.isOnTrial || billingStatus.hasPaymentMethod) {
-		return null;
-	}
-
-	const daysRemaining = billingStatus.trialDaysRemaining ?? 0;
-	const daysLabel = `${daysRemaining} day${daysRemaining === 1 ? "" : "s"}`;
-
-	return (
-		<div className="sticky top-0 z-20 mx-4 mt-4 flex flex-wrap items-center justify-center gap-x-3 gap-y-2 rounded-lg border border-primary/20 bg-primary/10 px-4 py-2 text-sm">
-			<span className="flex items-center gap-2">
-				<Rocket className="h-4 w-4 text-primary shrink-0" />
-				{daysRemaining > 0
-					? `You have ${daysLabel} left in your free trial. Add a payment method to keep your servers.`
-					: "Your free trial ends today. Add a payment method to keep your servers."}
-			</span>
-			<Button
-				size="sm"
-				variant="default"
-				className="h-7"
-				isLoading={isPending}
-				onClick={handleAddPaymentMethod}
-			>
-				Add payment method
-			</Button>
-		</div>
-	);
-};

apps/dokploy/components/dashboard/compose/general/actions.tsx

@@ -1,11 +1,4 @@
-import {
-	Ban,
-	CheckCircle2,
-	HardDriveDownload,
-	RefreshCcw,
-	Rocket,
-	Terminal,
-} from "lucide-react";
+import { Ban, CheckCircle2, RefreshCcw, Rocket, Terminal } from "lucide-react";
 import { useRouter } from "next/router";
 import { Tooltip as TooltipPrimitive } from "radix-ui";
 import { toast } from "sonner";
@@ -89,51 +82,6 @@ export const ComposeActions = ({ composeId }: Props) => {
 						</Button>
 					</DialogAction>
 				)}
-				{canDeploy && data?.composeType === "docker-compose" && (
-					<DialogAction
-						title="Deploy with Fresh Volumes"
-						description="This will remove all volumes and redeploy with a clean state. All persistent data will be permanently deleted."
-						type="destructive"
-						onClick={async () => {
-							await deploy({
-								composeId: composeId,
-								freshVolumes: true,
-							})
-								.then(() => {
-									toast.success("Compose deployed with fresh volumes");
-									refetch();
-									router.push(
-										`/dashboard/project/${data?.environment.projectId}/environment/${data?.environmentId}/services/compose/${composeId}?tab=deployments`,
-									);
-								})
-								.catch(() => {
-									toast.error("Error deploying compose");
-								});
-						}}
-					>
-						<Button
-							variant="outline"
-							isLoading={data?.composeStatus === "running"}
-							className="flex items-center gap-1.5 group focus-visible:ring-2 focus-visible:ring-offset-2"
-						>
-							<Tooltip>
-								<TooltipTrigger asChild>
-									<div className="flex items-center">
-										<HardDriveDownload className="size-4 mr-1" />
-										Fresh Volumes
-									</div>
-								</TooltipTrigger>
-								<TooltipPrimitive.Portal>
-									<TooltipContent sideOffset={5} className="z-[60]">
-										<p>
-											Deploy with fresh volumes (removes all persistent data)
-										</p>
-									</TooltipContent>
-								</TooltipPrimitive.Portal>
-							</Tooltip>
-						</Button>
-					</DialogAction>
-				)}
 				{canDeploy && (
 					<DialogAction
 						title="Rebuild Compose"

apps/dokploy/components/dashboard/compose/logs/show-stack.tsx

@@ -2,7 +2,6 @@ import { Loader2 } from "lucide-react";
 import dynamic from "next/dynamic";
 import { useEffect, useState } from "react";
 import { badgeStateColor } from "@/components/dashboard/application/logs/show";
-import { resolveContainerSelection } from "@/components/dashboard/docker/logs/utils";
 import { Badge } from "@/components/ui/badge";
 import {
 	Card,
@@ -55,7 +54,6 @@ export const ShowDockerLogsStack = ({
 			},
 			{
 				enabled: !!appName && option === "swarm",
-				refetchInterval: 5000,
 			},
 		);
 
@@ -68,18 +66,22 @@ export const ShowDockerLogsStack = ({
 			},
 			{
 				enabled: !!appName && option === "native",
-				refetchInterval: 5000,
 			},
 		);
 
 	const containers = data?.filter((container) => container.containerId);
-	const availableContainers = option === "native" ? containers : services;
 
 	useEffect(() => {
-		setContainerId((currentContainerId) =>
-			resolveContainerSelection(currentContainerId, availableContainers),
-		);
-	}, [availableContainers]);
+		if (option === "native") {
+			if (containers && containers?.length > 0) {
+				setContainerId(containers[0]?.containerId);
+			}
+		} else {
+			if (services && services?.length > 0) {
+				setContainerId(services[0]?.containerId);
+			}
+		}
+	}, [option, services, containers]);
 
 	const isLoading = option === "native" ? containersLoading : servicesLoading;
 	const containersLength =
@@ -104,7 +106,6 @@ export const ShowDockerLogsStack = ({
 						<Switch
 							checked={option === "native"}
 							onCheckedChange={(checked) => {
-								setContainerId(undefined);
 								setOption(checked ? "native" : "swarm");
 							}}
 						/>

apps/dokploy/components/dashboard/compose/logs/show.tsx

@@ -2,7 +2,6 @@ import { Loader2 } from "lucide-react";
 import dynamic from "next/dynamic";
 import { useEffect, useState } from "react";
 import { badgeStateColor } from "@/components/dashboard/application/logs/show";
-import { resolveContainerSelection } from "@/components/dashboard/docker/logs/utils";
 import { Badge } from "@/components/ui/badge";
 import {
 	Card,
@@ -53,15 +52,14 @@ export const ShowDockerLogsCompose = ({
 		},
 		{
 			enabled: !!appName,
-			refetchInterval: 5000,
 		},
 	);
 	const [containerId, setContainerId] = useState<string | undefined>();
 
 	useEffect(() => {
-		setContainerId((currentContainerId) =>
-			resolveContainerSelection(currentContainerId, data),
-		);
+		if (data && data?.length > 0) {
+			setContainerId(data[0]?.containerId);
+		}
 	}, [data]);
 
 	return (

apps/dokploy/components/dashboard/database/backups/restore-backup.tsx

@@ -74,7 +74,6 @@ interface Props {
 	databaseType?: DatabaseType;
 	serverId?: string | null;
 	backupType?: "database" | "compose";
-	trigger?: React.ReactNode;
 }
 
 const RestoreBackupSchema = z
@@ -201,7 +200,6 @@ export const RestoreBackup = ({
 	databaseType,
 	serverId,
 	backupType = "database",
-	trigger,
 }: Props) => {
 	const [isOpen, setIsOpen] = useState(false);
 	const [search, setSearch] = useState("");
@@ -313,12 +311,10 @@ export const RestoreBackup = ({
 	return (
 		<Dialog open={isOpen} onOpenChange={setIsOpen}>
 			<DialogTrigger asChild>
-				{trigger ?? (
-					<Button variant="outline">
-						<RotateCcw className="mr-2 size-4" />
-						Restore Backup
-					</Button>
-				)}
+				<Button variant="outline">
+					<RotateCcw className="mr-2 size-4" />
+					Restore Backup
+				</Button>
 			</DialogTrigger>
 			<DialogContent className="sm:max-w-2xl">
 				<DialogHeader>

apps/dokploy/components/dashboard/deployments/show-deployments-table.tsx

@@ -14,11 +14,10 @@ import {
 import type { inferRouterOutputs } from "@trpc/server";
 import {
 	ArrowUpDown,
+	Boxes,
 	ChevronLeft,
 	ChevronRight,
-	CircuitBoard,
 	ExternalLink,
-	GlobeIcon,
 	Loader2,
 	Rocket,
 	Server,
@@ -72,26 +71,24 @@ function getServiceInfo(d: DeploymentRow) {
 		return {
 			type: "Application" as const,
 			name: app.name,
-			icon: app.icon,
 			projectId: app.environment.project.projectId,
 			environmentId: app.environment.environmentId,
 			projectName: app.environment.project.name,
 			environmentName: app.environment.name,
 			serviceId: app.applicationId,
-			href: `/dashboard/project/${app.environment.project.projectId}/environment/${app.environment.environmentId}/services/application/${app.applicationId}?tab=deployments`,
+			href: `/dashboard/project/${app.environment.project.projectId}/environment/${app.environment.environmentId}/services/application/${app.applicationId}`,
 		};
 	}
 	if (comp?.environment?.project && comp.environment) {
 		return {
 			type: "Compose" as const,
 			name: comp.name,
-			icon: comp.icon,
 			projectId: comp.environment.project.projectId,
 			environmentId: comp.environment.environmentId,
 			projectName: comp.environment.project.name,
 			environmentName: comp.environment.name,
 			serviceId: comp.composeId,
-			href: `/dashboard/project/${comp.environment.project.projectId}/environment/${comp.environment.environmentId}/services/compose/${comp.composeId}?tab=deployments`,
+			href: `/dashboard/project/${comp.environment.project.projectId}/environment/${comp.environment.environmentId}/services/compose/${comp.composeId}`,
 		};
 	}
 	return null;
@@ -178,16 +175,10 @@ export function ShowDeploymentsTable() {
 					if (!info) return <span className="text-muted-foreground">—</span>;
 					return (
 						<div className="flex items-center gap-2">
-							{info.icon ? (
-								<img
-									src={info.icon}
-									alt={info.name}
-									className="size-4 object-contain shrink-0"
-								/>
-							) : info.type === "Application" ? (
-								<GlobeIcon className="size-4 text-muted-foreground shrink-0" />
+							{info.type === "Application" ? (
+								<Rocket className="size-4 text-muted-foreground shrink-0" />
 							) : (
-								<CircuitBoard className="size-4 text-muted-foreground shrink-0" />
+								<Boxes className="size-4 text-muted-foreground shrink-0" />
 							)}
 							<div className="flex flex-col min-w-0">
 								<span className="font-medium truncate">{info.name}</span>

apps/dokploy/components/dashboard/docker/disk-usage/show-disk-usage.tsx

@@ -1,428 +0,0 @@
-"use client";
-
-import {
-	type ColumnDef,
-	flexRender,
-	getCoreRowModel,
-	getPaginationRowModel,
-	getSortedRowModel,
-	type PaginationState,
-	type SortingState,
-	useReactTable,
-} from "@tanstack/react-table";
-import type { inferRouterOutputs } from "@trpc/server";
-import {
-	ArrowUpDown,
-	Boxes,
-	Database,
-	Gauge,
-	HardDrive,
-	Layers,
-	Loader2,
-	type LucideIcon,
-	Trash2,
-} from "lucide-react";
-import { useMemo, useState } from "react";
-import { toast } from "sonner";
-import { DialogAction } from "@/components/shared/dialog-action";
-import { Badge } from "@/components/ui/badge";
-import { Button } from "@/components/ui/button";
-import {
-	Card,
-	CardContent,
-	CardDescription,
-	CardHeader,
-	CardTitle,
-} from "@/components/ui/card";
-import { Input } from "@/components/ui/input";
-import {
-	Table,
-	TableBody,
-	TableCell,
-	TableHead,
-	TableHeader,
-	TableRow,
-} from "@/components/ui/table";
-import type { AppRouter } from "@/server/api/root";
-import { api } from "@/utils/api";
-
-type DiskUsageItem =
-	inferRouterOutputs<AppRouter>["dockerDiskUsage"]["getDiskUsage"][number];
-type BuildCacheBase =
-	inferRouterOutputs<AppRouter>["dockerDiskUsage"]["getBuildCache"][number];
-type BuildCacheRow = BuildCacheBase & { key: string };
-
-interface Props {
-	serverId?: string;
-}
-
-const STAT_CARDS: { type: string; title: string; icon: LucideIcon }[] = [
-	{ type: "Images", title: "Images", icon: Layers },
-	{ type: "Containers", title: "Containers", icon: Boxes },
-	{ type: "Local Volumes", title: "Volumes", icon: HardDrive },
-	{ type: "Build Cache", title: "Build Cache", icon: Database },
-];
-
-const SortableHeader = ({
-	column,
-	title,
-}: {
-	column: {
-		getIsSorted: () => false | "asc" | "desc";
-		toggleSorting: (asc: boolean) => void;
-	};
-	title: string;
-}) => (
-	<Button
-		variant="ghost"
-		className="-ml-3 h-8"
-		onClick={() => column.toggleSorting(column.getIsSorted() === "asc")}
-	>
-		{title}
-		<ArrowUpDown className="ml-2 size-4" />
-	</Button>
-);
-
-const StatCard = ({
-	icon: Icon,
-	title,
-	item,
-	isLoading,
-}: {
-	icon: LucideIcon;
-	title: string;
-	item?: DiskUsageItem;
-	isLoading: boolean;
-}) => (
-	<Card className="p-4">
-		<div className="flex items-center gap-2 text-sm text-muted-foreground">
-			<Icon className="size-4" />
-			{title}
-		</div>
-		{isLoading ? (
-			<div className="mt-3 flex items-center gap-2 text-sm text-muted-foreground">
-				<Loader2 className="size-4 animate-spin" />
-			</div>
-		) : (
-			<>
-				<div className="mt-2 text-2xl font-semibold">{item?.size ?? "-"}</div>
-				<div className="mt-1 flex flex-wrap gap-x-3 text-xs text-muted-foreground">
-					<span>{item?.totalCount ?? 0} total</span>
-					<span>{item?.active ?? 0} active</span>
-					<span>{item?.reclaimable ?? "-"} reclaimable</span>
-				</div>
-			</>
-		)}
-	</Card>
-);
-
-export const ShowDiskUsage = ({ serverId }: Props) => {
-	const utils = api.useUtils();
-	const [sorting, setSorting] = useState<SortingState>([
-		{ id: "Size", desc: true },
-	]);
-	const [globalFilter, setGlobalFilter] = useState("");
-	const [pagination, setPagination] = useState<PaginationState>({
-		pageIndex: 0,
-		pageSize: 10,
-	});
-
-	const { data: diskUsage, isLoading: isLoadingDiskUsage } =
-		api.dockerDiskUsage.getDiskUsage.useQuery({ serverId });
-	const { data: buildCache, isLoading: isLoadingBuildCache } =
-		api.dockerDiskUsage.getBuildCache.useQuery({ serverId });
-	const { mutateAsync: pruneBuildCache, isPending: isPruning } =
-		api.dockerDiskUsage.pruneBuildCache.useMutation();
-
-	const usageByType = useMemo(
-		() => new Map((diskUsage ?? []).map((item) => [item.type, item])),
-		[diskUsage],
-	);
-
-	const rows = useMemo<BuildCacheRow[]>(
-		() =>
-			(buildCache ?? []).map((entry) => ({
-				...entry,
-				key: entry.id,
-			})),
-		[buildCache],
-	);
-
-	const filteredData = useMemo(() => {
-		if (!globalFilter.trim()) {
-			return rows;
-		}
-		const query = globalFilter.toLowerCase();
-		return rows.filter(
-			(entry) =>
-				entry.id.toLowerCase().includes(query) ||
-				entry.description.toLowerCase().includes(query) ||
-				entry.type.toLowerCase().includes(query),
-		);
-	}, [rows, globalFilter]);
-
-	const handlePrune = async () => {
-		try {
-			await pruneBuildCache({ serverId });
-			toast.success("Build cache pruned");
-			await Promise.all([
-				utils.dockerDiskUsage.getBuildCache.invalidate(),
-				utils.dockerDiskUsage.getDiskUsage.invalidate(),
-			]);
-		} catch (error) {
-			toast.error("Error pruning build cache", {
-				description: error instanceof Error ? error.message : "Unknown error",
-			});
-		}
-	};
-
-	const columns = useMemo<ColumnDef<BuildCacheRow>[]>(
-		() => [
-			{
-				accessorKey: "id",
-				header: ({ column }) => (
-					<SortableHeader column={column} title="Cache ID" />
-				),
-				cell: ({ row }) => (
-					<span className="font-mono text-xs text-muted-foreground">
-						{row.original.id.slice(0, 16)}
-					</span>
-				),
-			},
-			{
-				accessorKey: "type",
-				header: ({ column }) => <SortableHeader column={column} title="Type" />,
-				cell: ({ row }) => <Badge variant="outline">{row.original.type}</Badge>,
-			},
-			{
-				accessorKey: "description",
-				header: "Description",
-				enableSorting: false,
-				cell: ({ row }) => (
-					<div
-						className="max-w-[360px] truncate text-xs text-muted-foreground"
-						title={row.original.description}
-					>
-						{row.original.description || "-"}
-					</div>
-				),
-			},
-			{
-				id: "Size",
-				accessorFn: (entry) => entry.sizeBytes,
-				header: ({ column }) => <SortableHeader column={column} title="Size" />,
-				cell: ({ row }) => (
-					<span className="text-muted-foreground">{row.original.size}</span>
-				),
-			},
-			{
-				id: "created",
-				accessorKey: "createdSince",
-				header: "Created",
-				enableSorting: false,
-				cell: ({ row }) => (
-					<span className="text-xs text-muted-foreground whitespace-nowrap">
-						{row.original.createdSince}
-					</span>
-				),
-			},
-			{
-				id: "lastUsed",
-				accessorKey: "lastUsedSince",
-				header: "Last Used",
-				enableSorting: false,
-				cell: ({ row }) => (
-					<span className="text-xs text-muted-foreground whitespace-nowrap">
-						{row.original.lastUsedSince}
-					</span>
-				),
-			},
-			{
-				accessorKey: "usageCount",
-				header: ({ column }) => (
-					<SortableHeader column={column} title="Usage" />
-				),
-				cell: ({ row }) => (
-					<span className="text-muted-foreground">
-						{row.original.usageCount}
-					</span>
-				),
-			},
-			{
-				id: "flags",
-				enableSorting: false,
-				header: "Flags",
-				cell: ({ row }) => (
-					<div className="flex gap-1">
-						{row.original.inUse && <Badge variant="blue">In use</Badge>}
-						{row.original.shared && <Badge variant="outline">Shared</Badge>}
-					</div>
-				),
-			},
-		],
-		[],
-	);
-
-	const table = useReactTable({
-		data: filteredData,
-		columns,
-		getRowId: (row) => row.key,
-		state: {
-			sorting,
-			pagination,
-		},
-		onSortingChange: setSorting,
-		onPaginationChange: setPagination,
-		getCoreRowModel: getCoreRowModel(),
-		getSortedRowModel: getSortedRowModel(),
-		getPaginationRowModel: getPaginationRowModel(),
-	});
-
-	return (
-		<div className="w-full space-y-4">
-			<div className="grid grid-cols-1 gap-4 sm:grid-cols-2 lg:grid-cols-4">
-				{STAT_CARDS.map((stat) => (
-					<StatCard
-						key={stat.type}
-						icon={stat.icon}
-						title={stat.title}
-						item={usageByType.get(stat.type)}
-						isLoading={isLoadingDiskUsage}
-					/>
-				))}
-			</div>
-			<Card className="h-full bg-sidebar p-2.5 rounded-xl">
-				<div className="rounded-xl bg-background shadow-md">
-					<CardHeader>
-						<div className="flex flex-wrap items-center justify-between gap-2">
-							<div>
-								<CardTitle className="text-xl flex flex-row gap-2">
-									<Gauge className="size-6 text-muted-foreground self-center" />
-									Build Cache
-								</CardTitle>
-								<CardDescription>
-									Cache layers kept by the Docker builder on the selected
-									server.
-								</CardDescription>
-							</div>
-							<DialogAction
-								title="Prune build cache"
-								description="This will remove all build cache entries that are not currently in use. This action cannot be undone."
-								onClick={handlePrune}
-								disabled={isPruning}
-							>
-								<Button variant="outline" size="sm" disabled={isPruning}>
-									<Trash2 className="size-4 mr-1" />
-									Prune build cache
-								</Button>
-							</DialogAction>
-						</div>
-					</CardHeader>
-					<CardContent className="space-y-4 py-8 border-t">
-						{isLoadingBuildCache ? (
-							<div className="flex flex-row gap-2 items-center justify-center text-sm text-muted-foreground min-h-[45vh]">
-								<span>Loading...</span>
-								<Loader2 className="animate-spin size-4" />
-							</div>
-						) : !buildCache?.length ? (
-							<div className="flex min-h-[45vh] w-full flex-col items-center justify-center gap-4 rounded-lg border border-dashed p-8">
-								<div className="rounded-full bg-muted p-4">
-									<Database className="size-10 text-muted-foreground" />
-								</div>
-								<div className="space-y-1 text-center">
-									<p className="text-sm font-medium">No build cache found</p>
-									<p className="max-w-sm text-sm text-muted-foreground">
-										Layers cached by "docker build" on this server will appear
-										here.
-									</p>
-								</div>
-							</div>
-						) : (
-							<>
-								<div className="flex flex-wrap items-center gap-2">
-									<Input
-										placeholder="Search by id, type or description..."
-										value={globalFilter}
-										onChange={(e) => setGlobalFilter(e.target.value)}
-										className="max-w-xs"
-									/>
-								</div>
-								<div className="rounded-md border overflow-x-auto">
-									<Table>
-										<TableHeader>
-											{table.getHeaderGroups().map((headerGroup) => (
-												<TableRow key={headerGroup.id}>
-													{headerGroup.headers.map((header) => (
-														<TableHead key={header.id}>
-															{header.isPlaceholder
-																? null
-																: flexRender(
-																		header.column.columnDef.header,
-																		header.getContext(),
-																	)}
-														</TableHead>
-													))}
-												</TableRow>
-											))}
-										</TableHeader>
-										<TableBody>
-											{table.getRowModel().rows?.length ? (
-												table.getRowModel().rows.map((row) => (
-													<TableRow key={row.id}>
-														{row.getVisibleCells().map((cell) => (
-															<TableCell key={cell.id}>
-																{flexRender(
-																	cell.column.columnDef.cell,
-																	cell.getContext(),
-																)}
-															</TableCell>
-														))}
-													</TableRow>
-												))
-											) : (
-												<TableRow>
-													<TableCell
-														colSpan={columns.length}
-														className="h-24 text-center text-muted-foreground"
-													>
-														No build cache entries match your filters.
-													</TableCell>
-												</TableRow>
-											)}
-										</TableBody>
-									</Table>
-								</div>
-								{table.getPageCount() > 1 && (
-									<div className="flex items-center justify-end gap-4">
-										<span className="text-sm text-muted-foreground">
-											Page {table.getState().pagination.pageIndex + 1} of{" "}
-											{table.getPageCount()}
-										</span>
-										<div className="flex gap-2">
-											<Button
-												variant="outline"
-												size="sm"
-												onClick={() => table.previousPage()}
-												disabled={!table.getCanPreviousPage()}
-											>
-												Previous
-											</Button>
-											<Button
-												variant="outline"
-												size="sm"
-												onClick={() => table.nextPage()}
-												disabled={!table.getCanNextPage()}
-											>
-												Next
-											</Button>
-										</div>
-									</div>
-								)}
-							</>
-						)}
-					</CardContent>
-				</div>
-			</Card>
-		</div>
-	);
-};

apps/dokploy/components/dashboard/docker/events/show-docker-events.tsx

@@ -1,425 +0,0 @@
-import {
-	type ColumnDef,
-	flexRender,
-	getCoreRowModel,
-	getPaginationRowModel,
-	getSortedRowModel,
-	type PaginationState,
-	type SortingState,
-	useReactTable,
-} from "@tanstack/react-table";
-import { Activity, ArrowUpDown, Loader2, RefreshCw } from "lucide-react";
-import { useMemo, useState } from "react";
-import { Badge } from "@/components/ui/badge";
-import { Button } from "@/components/ui/button";
-import {
-	Card,
-	CardContent,
-	CardDescription,
-	CardHeader,
-	CardTitle,
-} from "@/components/ui/card";
-import { Input } from "@/components/ui/input";
-import {
-	Select,
-	SelectContent,
-	SelectItem,
-	SelectTrigger,
-	SelectValue,
-} from "@/components/ui/select";
-import {
-	Table,
-	TableBody,
-	TableCell,
-	TableHead,
-	TableHeader,
-	TableRow,
-} from "@/components/ui/table";
-import { api, type RouterOutputs } from "@/utils/api";
-
-interface Props {
-	serverId?: string;
-}
-
-type DockerEvent = RouterOutputs["docker"]["getEvents"]["events"][number];
-type EventRow = DockerEvent & { key: string };
-
-const RANGE_OPTIONS = [
-	{ label: "Last 5 minutes", value: 5 },
-	{ label: "Last 15 minutes", value: 15 },
-	{ label: "Last hour", value: 60 },
-	{ label: "Last 6 hours", value: 360 },
-	{ label: "Last 24 hours", value: 1440 },
-];
-
-type BadgeVariant = "blue" | "green" | "yellow" | "orange" | "red" | "blank";
-
-const TYPE_VARIANTS: Record<string, BadgeVariant> = {
-	container: "blue",
-	image: "green",
-	volume: "yellow",
-	network: "orange",
-	service: "blue",
-	node: "orange",
-};
-
-const ACTION_VARIANTS: Record<string, BadgeVariant> = {
-	create: "green",
-	start: "green",
-	pull: "green",
-	connect: "green",
-	die: "red",
-	destroy: "red",
-	kill: "red",
-	stop: "red",
-	remove: "red",
-	disconnect: "red",
-	pause: "yellow",
-	unpause: "yellow",
-};
-
-const getTypeVariant = (type?: string): BadgeVariant =>
-	(type && TYPE_VARIANTS[type]) || "blank";
-
-const getActionVariant = (action?: string): BadgeVariant =>
-	(action && ACTION_VARIANTS[action]) || "blank";
-
-const getResource = (event: DockerEvent) =>
-	event.Actor?.Attributes?.name ?? event.Actor?.ID ?? "-";
-
-const getAttributesText = (event: DockerEvent) => {
-	const attributes = Object.entries(event.Actor?.Attributes ?? {}).filter(
-		([key]) => key !== "name",
-	);
-	return attributes.map(([key, value]) => `${key}=${value}`).join(" ") || "-";
-};
-
-const SortableHeader = ({
-	column,
-	title,
-}: {
-	column: {
-		getIsSorted: () => false | "asc" | "desc";
-		toggleSorting: (asc: boolean) => void;
-	};
-	title: string;
-}) => (
-	<Button
-		variant="ghost"
-		className="-ml-3 h-8"
-		onClick={() => column.toggleSorting(column.getIsSorted() === "asc")}
-	>
-		{title}
-		<ArrowUpDown className="ml-2 size-4" />
-	</Button>
-);
-
-export const ShowDockerEvents = ({ serverId }: Props) => {
-	const [minutes, setMinutes] = useState(15);
-	const [search, setSearch] = useState("");
-	const [sorting, setSorting] = useState<SortingState>([
-		{ id: "time", desc: true },
-	]);
-	const [pagination, setPagination] = useState<PaginationState>({
-		pageIndex: 0,
-		pageSize: 15,
-	});
-
-	const { data, isLoading, isRefetching, refetch, error } =
-		api.docker.getEvents.useQuery({
-			serverId,
-			minutes,
-		});
-
-	const events = useMemo<EventRow[]>(
-		() =>
-			(data?.events ?? []).map((event, index) => ({
-				...event,
-				key: `${event.time}-${event.Action}-${index}`,
-			})),
-		[data],
-	);
-
-	const filteredEvents = useMemo(() => {
-		if (!search.trim()) return events;
-		const query = search.toLowerCase();
-		return events.filter((event) => {
-			return (
-				event.Type?.toLowerCase().includes(query) ||
-				event.Action?.toLowerCase().includes(query) ||
-				event.Actor?.Attributes?.name?.toLowerCase().includes(query) ||
-				event.Actor?.ID?.toLowerCase().includes(query)
-			);
-		});
-	}, [events, search]);
-
-	const columns = useMemo<ColumnDef<EventRow>[]>(
-		() => [
-			{
-				id: "time",
-				accessorFn: (event) => event.time ?? 0,
-				header: ({ column }) => <SortableHeader column={column} title="Time" />,
-				cell: ({ row }) => (
-					<span className="text-xs text-muted-foreground whitespace-nowrap">
-						{row.original.time
-							? new Date(row.original.time * 1000).toLocaleTimeString()
-							: "-"}
-					</span>
-				),
-			},
-			{
-				id: "type",
-				accessorFn: (event) => event.Type ?? "",
-				header: ({ column }) => <SortableHeader column={column} title="Type" />,
-				cell: ({ row }) => (
-					<Badge variant={getTypeVariant(row.original.Type)}>
-						{row.original.Type ?? "unknown"}
-					</Badge>
-				),
-			},
-			{
-				id: "action",
-				accessorFn: (event) => event.Action ?? "",
-				header: ({ column }) => (
-					<SortableHeader column={column} title="Action" />
-				),
-				cell: ({ row }) => (
-					<Badge variant={getActionVariant(row.original.Action)}>
-						{row.original.Action ?? "-"}
-					</Badge>
-				),
-			},
-			{
-				id: "resource",
-				accessorFn: (event) => getResource(event),
-				header: ({ column }) => (
-					<SortableHeader column={column} title="Resource" />
-				),
-				cell: ({ row }) => {
-					const resource = getResource(row.original);
-					return (
-						<div
-							className="max-w-[220px] truncate font-mono text-xs"
-							title={resource}
-						>
-							{resource}
-						</div>
-					);
-				},
-			},
-			{
-				id: "attributes",
-				accessorFn: (event) => getAttributesText(event),
-				header: "Attributes",
-				enableSorting: false,
-				cell: ({ row }) => {
-					const attributesText = getAttributesText(row.original);
-					return (
-						<div
-							className="max-w-[360px] truncate text-xs text-muted-foreground"
-							title={attributesText}
-						>
-							{attributesText}
-						</div>
-					);
-				},
-			},
-		],
-		[],
-	);
-
-	const table = useReactTable({
-		data: filteredEvents,
-		columns,
-		getRowId: (row) => row.key,
-		state: {
-			sorting,
-			pagination,
-		},
-		onSortingChange: setSorting,
-		onPaginationChange: setPagination,
-		getCoreRowModel: getCoreRowModel(),
-		getSortedRowModel: getSortedRowModel(),
-		getPaginationRowModel: getPaginationRowModel(),
-	});
-
-	return (
-		<div className="w-full">
-			<Card className="h-full bg-sidebar p-2.5 rounded-xl">
-				<div className="rounded-xl bg-background shadow-md">
-					<CardHeader>
-						<div className="flex flex-wrap items-center justify-between gap-2">
-							<div>
-								<CardTitle className="text-xl flex flex-row gap-2">
-									<Activity className="size-6 text-muted-foreground self-center" />
-									Docker Events
-								</CardTitle>
-								<CardDescription>
-									Events reported by the Docker daemon, equivalent to running
-									"docker events".
-								</CardDescription>
-							</div>
-							<Button
-								variant="outline"
-								size="sm"
-								onClick={() => refetch()}
-								disabled={isRefetching}
-							>
-								<RefreshCw
-									className={`size-4 mr-1 ${isRefetching ? "animate-spin" : ""}`}
-								/>
-								Refresh
-							</Button>
-						</div>
-					</CardHeader>
-					<CardContent className="space-y-4 py-8 border-t">
-						{error && (
-							<p className="text-sm text-destructive">{error.message}</p>
-						)}
-						<div className="flex flex-wrap items-center gap-2">
-							<Input
-								placeholder="Filter by type, action or name..."
-								value={search}
-								onChange={(e) => {
-									setSearch(e.target.value);
-									setPagination((prev) => ({ ...prev, pageIndex: 0 }));
-								}}
-								className="max-w-xs"
-							/>
-							<Select
-								value={String(minutes)}
-								onValueChange={(value) => setMinutes(Number(value))}
-							>
-								<SelectTrigger className="w-[180px]">
-									<SelectValue />
-								</SelectTrigger>
-								<SelectContent>
-									{RANGE_OPTIONS.map((option) => (
-										<SelectItem key={option.value} value={String(option.value)}>
-											{option.label}
-										</SelectItem>
-									))}
-								</SelectContent>
-							</Select>
-						</div>
-						<div className="rounded-md border overflow-x-auto">
-							<Table>
-								<TableHeader>
-									{table.getHeaderGroups().map((headerGroup) => (
-										<TableRow key={headerGroup.id}>
-											{headerGroup.headers.map((header) => (
-												<TableHead key={header.id}>
-													{header.isPlaceholder
-														? null
-														: flexRender(
-																header.column.columnDef.header,
-																header.getContext(),
-															)}
-												</TableHead>
-											))}
-										</TableRow>
-									))}
-								</TableHeader>
-								<TableBody>
-									{isLoading ? (
-										<TableRow>
-											<TableCell
-												colSpan={columns.length}
-												className="h-24 text-center text-muted-foreground"
-											>
-												<div className="flex flex-row items-center justify-center gap-2">
-													<span>Loading events...</span>
-													<Loader2 className="size-4 animate-spin" />
-												</div>
-											</TableCell>
-										</TableRow>
-									) : table.getRowModel().rows?.length ? (
-										table.getRowModel().rows.map((row) => (
-											<TableRow key={row.id}>
-												{row.getVisibleCells().map((cell) => (
-													<TableCell key={cell.id}>
-														{flexRender(
-															cell.column.columnDef.cell,
-															cell.getContext(),
-														)}
-													</TableCell>
-												))}
-											</TableRow>
-										))
-									) : (
-										<TableRow>
-											<TableCell
-												colSpan={columns.length}
-												className="h-24 text-center text-muted-foreground"
-											>
-												No events found in the selected time range.
-											</TableCell>
-										</TableRow>
-									)}
-								</TableBody>
-							</Table>
-						</div>
-						{table.getPageCount() > 1 && (
-							<div className="flex items-center justify-end gap-4">
-								<span className="text-sm text-muted-foreground">
-									Page {table.getState().pagination.pageIndex + 1} of{" "}
-									{table.getPageCount()}
-								</span>
-								<div className="flex items-center gap-2">
-									<span className="text-sm text-muted-foreground">Go to</span>
-									<Input
-										type="number"
-										min={1}
-										max={table.getPageCount()}
-										defaultValue={table.getState().pagination.pageIndex + 1}
-										key={table.getState().pagination.pageIndex}
-										onKeyDown={(e) => {
-											if (e.key !== "Enter") return;
-											const value = Number(
-												(e.target as HTMLInputElement).value,
-											);
-											if (!Number.isFinite(value)) return;
-											const page = Math.min(
-												Math.max(value, 1),
-												table.getPageCount(),
-											);
-											table.setPageIndex(page - 1);
-										}}
-										onBlur={(e) => {
-											const value = Number(e.target.value);
-											if (!Number.isFinite(value)) return;
-											const page = Math.min(
-												Math.max(value, 1),
-												table.getPageCount(),
-											);
-											table.setPageIndex(page - 1);
-										}}
-										className="w-16 h-8"
-									/>
-								</div>
-								<div className="flex gap-2">
-									<Button
-										variant="outline"
-										size="sm"
-										onClick={() => table.previousPage()}
-										disabled={!table.getCanPreviousPage()}
-									>
-										Previous
-									</Button>
-									<Button
-										variant="outline"
-										size="sm"
-										onClick={() => table.nextPage()}
-										disabled={!table.getCanNextPage()}
-									>
-										Next
-									</Button>
-								</div>
-							</div>
-						)}
-					</CardContent>
-				</div>
-			</Card>
-		</div>
-	);
-};

apps/dokploy/components/dashboard/docker/health/show-health.tsx

@@ -1,454 +0,0 @@
-import {
-	AlertTriangle,
-	Cpu,
-	Download,
-	HardDrive,
-	Loader2,
-	Network,
-	RefreshCw,
-	Server as ServerIcon,
-} from "lucide-react";
-import { useState } from "react";
-import { CodeEditor } from "@/components/shared/code-editor";
-import { Badge } from "@/components/ui/badge";
-import { Button } from "@/components/ui/button";
-import { Card } from "@/components/ui/card";
-import { Progress } from "@/components/ui/progress";
-import {
-	Select,
-	SelectContent,
-	SelectItem,
-	SelectTrigger,
-	SelectValue,
-} from "@/components/ui/select";
-import {
-	Table,
-	TableBody,
-	TableCell,
-	TableHead,
-	TableHeader,
-	TableRow,
-} from "@/components/ui/table";
-import { api } from "@/utils/api";
-
-interface Props {
-	serverId?: string;
-}
-
-const bytesToGb = (bytes: number) => (bytes / 1024 ** 3).toFixed(1);
-const nanoCpusToCores = (nanoCpus: number) => (nanoCpus / 1e9).toFixed(2);
-const pct = (used: number, total: number) =>
-	Math.min(100, Math.round((used / (total || 1)) * 100));
-
-const SINCE_HOURS_OPTIONS = [
-	{ label: "Last hour", value: 1 },
-	{ label: "Last 6 hours", value: 6 },
-	{ label: "Last 24 hours", value: 24 },
-	{ label: "Last 7 days", value: 168 },
-];
-
-export const ShowHealth = ({ serverId }: Props) => {
-	const [sinceHours, setSinceHours] = useState(24);
-	const {
-		data: health,
-		isFetching,
-		refetch,
-		isFetched,
-	} = api.docker.getServerHealth.useQuery(
-		{ serverId, sinceHours },
-		{ refetchOnMount: false, refetchOnWindowFocus: false },
-	);
-
-	const memUsedPct = health
-		? pct(health.resources.memUsedBytes, health.resources.memTotalBytes)
-		: 0;
-	const diskUsedPct = health
-		? pct(health.disk.usedBytes, health.disk.totalBytes)
-		: 0;
-	const inotifyUsedPct = health
-		? pct(health.inotify.currentInstances, health.inotify.maxInstances)
-		: 0;
-
-	const daemonLogsWindowText = health?.daemonLogsWindow
-		? `Logs from ${new Date(health.daemonLogsWindow.fromEpoch * 1000).toLocaleString()} to ${new Date(health.daemonLogsWindow.toEpoch * 1000).toLocaleString()}`
-		: null;
-	const daemonErrorsText = [
-		daemonLogsWindowText,
-		health && health.daemonErrors.length > 0
-			? health.daemonErrors.join("\n")
-			: "(no daemon errors matched in this window)",
-	]
-		.filter(Boolean)
-		.join("\n\n");
-
-	const buildHealthReport = () => {
-		if (!health) return "";
-		const lines: string[] = [];
-		lines.push("# Dokploy server health report");
-		lines.push(`Generated: ${new Date(health.checkedAt).toLocaleString()}`);
-		lines.push(
-			`Window: ${SINCE_HOURS_OPTIONS.find((o) => o.value === sinceHours)?.label ?? `${sinceHours}h`}`,
-		);
-		lines.push("");
-
-		lines.push("## Containers & services");
-		lines.push(`Containers: ${health.containers.containerCount}`);
-		lines.push(`Swarm services: ${health.containers.serviceCount}`);
-		lines.push("");
-
-		lines.push("## Host resources");
-		lines.push(
-			`Memory: ${bytesToGb(health.resources.memUsedBytes)} / ${bytesToGb(health.resources.memTotalBytes)} GB`,
-		);
-		lines.push(`CPU cores: ${health.resources.cpuCount}`);
-		lines.push("");
-
-		lines.push("## Disk (/)");
-		lines.push(
-			`${bytesToGb(health.disk.usedBytes)} / ${bytesToGb(health.disk.totalBytes)} GB`,
-		);
-		lines.push("");
-
-		lines.push("## Inotify");
-		lines.push(
-			`max_user_instances: ${health.inotify.currentInstances} / ${health.inotify.maxInstances}`,
-		);
-		lines.push(`max_user_watches: ${health.inotify.maxWatches}`);
-		lines.push(`max_queued_events: ${health.inotify.maxQueuedEvents}`);
-		lines.push(
-			`Persisted in sysctl: ${health.inotify.persisted ? "yes" : "no"}`,
-		);
-		lines.push("");
-
-		lines.push("## Docker networks");
-		lines.push(`Total networks: ${health.dockerNetworks.count}`);
-		if (health.dockerNetworks.addressPools) {
-			lines.push(
-				`default-address-pools: ${JSON.stringify(health.dockerNetworks.addressPools)}`,
-			);
-		}
-		if (health.dockerNetworks.usageError) {
-			lines.push(
-				`Could not read network IP usage: ${health.dockerNetworks.usageError}`,
-			);
-		} else if (health.dockerNetworks.usage.length > 0) {
-			lines.push("");
-			lines.push(
-				"| Network | Driver | Subnet | IPs in use | Capacity | Usage |",
-			);
-			lines.push("|---|---|---|---|---|---|");
-			for (const n of health.dockerNetworks.usage) {
-				lines.push(
-					`| ${n.name} | ${n.driver} | ${n.subnet ?? "auto"} | ${n.containersInUse} | ${n.capacity ?? "—"} | ${n.percentUsed ?? "—"}% |`,
-				);
-			}
-		}
-		lines.push("");
-
-		if (health.reservation) {
-			lines.push("## Memory/CPU reservation");
-			lines.push(
-				`Reserved memory: ${bytesToGb(health.reservation.memoryReservedBytes)} GB`,
-			);
-			lines.push(
-				`Reserved CPU: ${nanoCpusToCores(health.reservation.cpuReservedNanoCpus)} cores`,
-			);
-			lines.push(`Across ${health.reservation.appCount} Application services`);
-			if (health.reservation.unsupportedComposeCount > 0) {
-				lines.push(
-					`${health.reservation.unsupportedComposeCount} Compose service(s) not included (not tracked per-service)`,
-				);
-			}
-			lines.push("");
-		}
-
-		lines.push("## Docker daemon errors (raw)");
-		lines.push("```");
-		lines.push(daemonErrorsText);
-		lines.push("```");
-
-		return lines.join("\n");
-	};
-
-	const handleDownload = () => {
-		const report = buildHealthReport();
-		if (!report) return;
-		const blob = new Blob([report], { type: "text/markdown" });
-		const url = URL.createObjectURL(blob);
-		const a = document.createElement("a");
-		a.href = url;
-		a.download = `dokploy-health-report-${new Date().toISOString().replace(/[:.]/g, "-")}.md`;
-		a.click();
-		URL.revokeObjectURL(url);
-	};
-
-	return (
-		<div className="flex flex-col gap-4 w-full">
-			<Card className="bg-sidebar p-2.5 rounded-xl w-full">
-				<div className="rounded-xl bg-background shadow-md p-6 flex flex-col gap-4">
-					<div className="flex items-center justify-between gap-4 flex-wrap">
-						<div>
-							<h3 className="text-lg font-medium">Server diagnostics</h3>
-							<p className="text-sm text-muted-foreground max-w-xl">
-								Runs a read-only check over SSH (inotify limits, disk, Docker
-								network pool, daemon errors). Runs automatically when you open
-								this tab — click Re-check to refresh.
-							</p>
-						</div>
-						<div className="flex items-center gap-2">
-							<Select
-								value={String(sinceHours)}
-								onValueChange={(v) => setSinceHours(Number(v))}
-							>
-								<SelectTrigger className="w-[160px]">
-									<SelectValue />
-								</SelectTrigger>
-								<SelectContent>
-									{SINCE_HOURS_OPTIONS.map((opt) => (
-										<SelectItem key={opt.value} value={String(opt.value)}>
-											{opt.label}
-										</SelectItem>
-									))}
-								</SelectContent>
-							</Select>
-							<Button onClick={() => refetch()} disabled={isFetching}>
-								{isFetching ? (
-									<Loader2 className="size-4 animate-spin mr-2" />
-								) : (
-									<RefreshCw className="size-4 mr-2" />
-								)}
-								{isFetched ? "Re-check" : "Check server health"}
-							</Button>
-							{health && !health.error && (
-								<Button variant="outline" onClick={handleDownload}>
-									<Download className="size-4 mr-2" />
-									Download report
-								</Button>
-							)}
-						</div>
-					</div>
-
-					{isFetching && !health && (
-						<div className="flex flex-col items-center justify-center gap-2 py-12 text-muted-foreground border border-dashed rounded-xl">
-							<Loader2 className="size-8 animate-spin" />
-							<span>Checking server health…</span>
-						</div>
-					)}
-
-					{health?.error && (
-						<div className="text-sm text-destructive border border-destructive/30 bg-destructive/10 rounded-lg p-3">
-							Couldn't read server health: {health.error}
-						</div>
-					)}
-
-					{health && !health.error && (
-						<div
-							className={`grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4 transition-opacity ${isFetching ? "opacity-50" : ""}`}
-						>
-							<Card className="p-4">
-								<div className="flex items-center gap-2 text-sm font-medium mb-2">
-									<ServerIcon className="size-4 text-muted-foreground" />
-									Containers &amp; services
-								</div>
-								<div className="text-2xl font-semibold">
-									{health.containers.containerCount}
-								</div>
-								<div className="text-xs text-muted-foreground">
-									containers · {health.containers.serviceCount} swarm services
-								</div>
-							</Card>
-
-							<Card className="p-4">
-								<div className="flex items-center gap-2 text-sm font-medium mb-2">
-									<Cpu className="size-4 text-muted-foreground" />
-									Host resources
-								</div>
-								<div className="text-sm">
-									Memory: {bytesToGb(health.resources.memUsedBytes)} /{" "}
-									{bytesToGb(health.resources.memTotalBytes)} GB
-								</div>
-								<Progress value={memUsedPct} className="h-2 mt-1" />
-								<div className="text-xs text-muted-foreground mt-2">
-									{health.resources.cpuCount} CPU cores
-								</div>
-							</Card>
-
-							<Card className="p-4">
-								<div className="flex items-center gap-2 text-sm font-medium mb-2">
-									<HardDrive className="size-4 text-muted-foreground" />
-									Disk (/)
-								</div>
-								<div className="text-sm">
-									{bytesToGb(health.disk.usedBytes)} /{" "}
-									{bytesToGb(health.disk.totalBytes)} GB
-								</div>
-								<Progress value={diskUsedPct} className="h-2 mt-1" />
-							</Card>
-
-							<Card className="p-4">
-								<div className="flex items-center justify-between gap-2 text-sm font-medium mb-2">
-									<span className="flex items-center gap-2">
-										<AlertTriangle className="size-4 text-muted-foreground" />
-										Inotify
-									</span>
-									<Badge
-										variant={health.inotify.persisted ? "default" : "secondary"}
-									>
-										{health.inotify.persisted ? "persisted" : "runtime only"}
-									</Badge>
-								</div>
-								<div className="text-sm">
-									max_user_instances: {health.inotify.currentInstances} /{" "}
-									{health.inotify.maxInstances.toLocaleString()} (
-									{inotifyUsedPct}%)
-								</div>
-								<Progress value={inotifyUsedPct} className="h-2 mt-1" />
-								<div className="text-xs text-muted-foreground mt-2">
-									max_user_watches: {health.inotify.maxWatches.toLocaleString()}{" "}
-									· max_queued_events:{" "}
-									{health.inotify.maxQueuedEvents.toLocaleString()}
-								</div>
-							</Card>
-
-							<Card className="p-4">
-								<div className="flex items-center gap-2 text-sm font-medium mb-2">
-									<Network className="size-4 text-muted-foreground" />
-									Docker networks
-								</div>
-								<div className="text-2xl font-semibold">
-									{health.dockerNetworks.count}
-								</div>
-								<div className="text-xs text-muted-foreground">
-									The default Docker address pool is exhausted around ~30
-									networks unless <code>default-address-pools</code> is
-									configured in <code>/etc/docker/daemon.json</code>.
-									{health.dockerNetworks.addressPools
-										? " Custom pool detected on this server."
-										: ""}
-								</div>
-							</Card>
-
-							{health.reservation && (
-								<Card className="p-4">
-									<div className="flex items-center gap-2 text-sm font-medium mb-2">
-										<Cpu className="size-4 text-muted-foreground" />
-										Memory/CPU reservation
-									</div>
-									<div className="text-sm">
-										{bytesToGb(health.reservation.memoryReservedBytes)} GB
-										reserved ·{" "}
-										{nanoCpusToCores(health.reservation.cpuReservedNanoCpus)}{" "}
-										CPUs reserved
-									</div>
-									<div className="text-xs text-muted-foreground mt-2">
-										Across {health.reservation.appCount} Application services.
-										{health.reservation.unsupportedComposeCount > 0
-											? ` ${health.reservation.unsupportedComposeCount} Compose service(s) on this server aren't included — reservations aren't tracked per-service for Compose.`
-											: ""}
-									</div>
-								</Card>
-							)}
-						</div>
-					)}
-
-					{health &&
-						!health.error &&
-						(health.dockerNetworks.usage.length > 0 ||
-							health.dockerNetworks.usageError) && (
-							<div className="flex flex-col gap-2">
-								<h4 className="text-sm font-medium flex items-center gap-2">
-									<Network className="size-4 text-muted-foreground" />
-									Network IP usage
-								</h4>
-								<p className="text-xs text-muted-foreground">
-									IPs assigned to containers vs. the subnet's usable capacity,
-									per network — including reserved networks like{" "}
-									<code>dokploy-network</code>. A network stuck near 100% blocks
-									new containers from starting even when the host has plenty of
-									other resources free.
-								</p>
-								{health.dockerNetworks.usageError ? (
-									<div className="text-sm text-destructive border border-destructive/30 bg-destructive/10 rounded-lg p-3">
-										Couldn't read network IP usage:{" "}
-										{health.dockerNetworks.usageError}
-									</div>
-								) : (
-									<div className="rounded-lg border overflow-x-auto">
-										<Table>
-											<TableHeader>
-												<TableRow>
-													<TableHead>Network</TableHead>
-													<TableHead>Driver</TableHead>
-													<TableHead>Subnet</TableHead>
-													<TableHead>IPs in use</TableHead>
-													<TableHead>Usage</TableHead>
-												</TableRow>
-											</TableHeader>
-											<TableBody>
-												{health.dockerNetworks.usage.map((n) => (
-													<TableRow key={n.name}>
-														<TableCell className="font-medium">
-															{n.name}
-														</TableCell>
-														<TableCell className="text-muted-foreground">
-															{n.driver}
-														</TableCell>
-														<TableCell className="text-muted-foreground">
-															{n.subnet ?? "Auto"}
-														</TableCell>
-														<TableCell className="text-muted-foreground">
-															{n.capacity !== null
-																? `${n.containersInUse} / ${n.capacity}`
-																: n.containersInUse}
-														</TableCell>
-														<TableCell>
-															{n.percentUsed !== null ? (
-																<Badge
-																	variant={
-																		n.percentUsed >= 90
-																			? "red"
-																			: n.percentUsed >= 70
-																				? "yellow"
-																				: "green"
-																	}
-																>
-																	{n.percentUsed}%
-																</Badge>
-															) : (
-																<span className="text-muted-foreground text-xs">
-																	—
-																</span>
-															)}
-														</TableCell>
-													</TableRow>
-												))}
-											</TableBody>
-										</Table>
-									</div>
-								)}
-							</div>
-						)}
-
-					{health && !health.error && (
-						<div className="flex flex-col gap-2">
-							<h4 className="text-sm font-medium">
-								Docker daemon errors (
-								{SINCE_HOURS_OPTIONS.find(
-									(o) => o.value === sinceHours,
-								)?.label.toLowerCase()}
-								)
-							</h4>
-							<CodeEditor
-								value={daemonErrorsText}
-								language="shell"
-								disabled
-								lineWrapping
-								wrapperClassName="h-64 rounded-lg border"
-							/>
-						</div>
-					)}
-				</div>
-			</Card>
-		</div>
-	);
-};

apps/dokploy/components/dashboard/docker/images/show-images.tsx

@@ -1,470 +0,0 @@
-"use client";
-
-import {
-	type ColumnDef,
-	flexRender,
-	getCoreRowModel,
-	getPaginationRowModel,
-	getSortedRowModel,
-	type PaginationState,
-	type SortingState,
-	useReactTable,
-} from "@tanstack/react-table";
-import type { inferRouterOutputs } from "@trpc/server";
-import { ArrowUpDown, Eye, Layers, Loader2, Trash2 } from "lucide-react";
-import { useMemo, useState } from "react";
-import { toast } from "sonner";
-import { AlertBlock } from "@/components/shared/alert-block";
-import { CodeEditor } from "@/components/shared/code-editor";
-import { DialogAction } from "@/components/shared/dialog-action";
-import {
-	AlertDialog,
-	AlertDialogAction,
-	AlertDialogCancel,
-	AlertDialogContent,
-	AlertDialogDescription,
-	AlertDialogFooter,
-	AlertDialogHeader,
-	AlertDialogTitle,
-} from "@/components/ui/alert-dialog";
-import { Badge } from "@/components/ui/badge";
-import { Button } from "@/components/ui/button";
-import {
-	Card,
-	CardContent,
-	CardDescription,
-	CardHeader,
-	CardTitle,
-} from "@/components/ui/card";
-import {
-	Dialog,
-	DialogContent,
-	DialogDescription,
-	DialogHeader,
-	DialogTitle,
-	DialogTrigger,
-} from "@/components/ui/dialog";
-import { Input } from "@/components/ui/input";
-import {
-	Table,
-	TableBody,
-	TableCell,
-	TableHead,
-	TableHeader,
-	TableRow,
-} from "@/components/ui/table";
-import type { AppRouter } from "@/server/api/root";
-import { api } from "@/utils/api";
-
-type ImageBase =
-	inferRouterOutputs<AppRouter>["dockerImage"]["getImages"][number];
-type ImageRow = ImageBase & { key: string };
-
-interface Props {
-	serverId?: string;
-}
-
-const SIZE_UNITS: Record<string, number> = {
-	b: 1,
-	kb: 1e3,
-	mb: 1e6,
-	gb: 1e9,
-	tb: 1e12,
-};
-
-const parseSize = (size?: string) => {
-	if (!size) return -1;
-	const match = /^([\d.]+)\s*([a-zA-Z]+)$/.exec(size.trim());
-	if (!match?.[1] || !match[2]) return -1;
-	return Number(match[1]) * (SIZE_UNITS[match[2].toLowerCase()] ?? 1);
-};
-
-const getReference = (image: ImageBase) =>
-	image.Repository !== "<none>" && image.Tag !== "<none>"
-		? `${image.Repository}:${image.Tag}`
-		: image.ID;
-
-const FORCE_HINT_REGEX =
-	/must be forced|image is being used|referenced in multiple repositories/i;
-
-const SortableHeader = ({
-	column,
-	title,
-}: {
-	column: {
-		getIsSorted: () => false | "asc" | "desc";
-		toggleSorting: (asc: boolean) => void;
-	};
-	title: string;
-}) => (
-	<Button
-		variant="ghost"
-		className="-ml-3 h-8"
-		onClick={() => column.toggleSorting(column.getIsSorted() === "asc")}
-	>
-		{title}
-		<ArrowUpDown className="ml-2 size-4" />
-	</Button>
-);
-
-const ShowImageConfig = ({
-	imageRef,
-	serverId,
-}: {
-	imageRef: string;
-	serverId?: string;
-}) => {
-	const [open, setOpen] = useState(false);
-	const { data, isLoading, error } = api.dockerImage.getImageConfig.useQuery(
-		{ imageRef, serverId },
-		{ enabled: open },
-	);
-
-	return (
-		<Dialog open={open} onOpenChange={setOpen}>
-			<DialogTrigger asChild>
-				<Button variant="ghost" size="icon-sm" aria-label="View image config">
-					<Eye className="size-4" />
-				</Button>
-			</DialogTrigger>
-			<DialogContent className="w-full md:w-[70vw] min-w-[70vw]">
-				<DialogHeader>
-					<DialogTitle>Image Config</DialogTitle>
-					<DialogDescription>
-						docker image inspect output for "{imageRef}"
-					</DialogDescription>
-				</DialogHeader>
-				{error ? (
-					<AlertBlock type="error">{error.message}</AlertBlock>
-				) : isLoading ? (
-					<div className="flex flex-row gap-2 items-center justify-center py-10 text-sm text-muted-foreground">
-						<span>Loading...</span>
-						<Loader2 className="animate-spin size-4" />
-					</div>
-				) : (
-					<div className="text-wrap rounded-lg border p-4 overflow-y-auto text-sm bg-card max-h-[80vh]">
-						<code>
-							<pre className="whitespace-pre-wrap wrap-break-word">
-								<CodeEditor
-									language="json"
-									lineWrapping
-									lineNumbers={false}
-									readOnly
-									value={JSON.stringify(data, null, 2)}
-								/>
-							</pre>
-						</code>
-					</div>
-				)}
-			</DialogContent>
-		</Dialog>
-	);
-};
-
-export const ShowImages = ({ serverId }: Props) => {
-	const utils = api.useUtils();
-	const [sorting, setSorting] = useState<SortingState>([
-		{ id: "Repository", desc: false },
-	]);
-	const [globalFilter, setGlobalFilter] = useState("");
-	const [pagination, setPagination] = useState<PaginationState>({
-		pageIndex: 0,
-		pageSize: 10,
-	});
-	const [forcePrompt, setForcePrompt] = useState<{
-		image: ImageRow;
-		message: string;
-	} | null>(null);
-
-	const { data: images, isLoading } = api.dockerImage.getImages.useQuery({
-		serverId,
-	});
-	const { mutateAsync: removeImage } =
-		api.dockerImage.removeImage.useMutation();
-
-	const rows = useMemo<ImageRow[]>(
-		() =>
-			(images ?? []).map((image) => ({
-				...image,
-				key: `${image.ID}-${image.Repository}-${image.Tag}`,
-			})),
-		[images],
-	);
-
-	const filteredData = useMemo(() => {
-		if (!globalFilter.trim()) {
-			return rows;
-		}
-		const query = globalFilter.toLowerCase();
-		return rows.filter(
-			(image) =>
-				image.Repository.toLowerCase().includes(query) ||
-				image.Tag.toLowerCase().includes(query) ||
-				image.ID.toLowerCase().includes(query),
-		);
-	}, [rows, globalFilter]);
-
-	const handleDelete = async (image: ImageRow, force = false) => {
-		try {
-			await removeImage({
-				repository: image.Repository,
-				tag: image.Tag,
-				id: image.ID,
-				force,
-				serverId,
-			});
-			toast.success("Image deleted");
-			setForcePrompt(null);
-			await utils.dockerImage.getImages.invalidate();
-		} catch (error) {
-			const message = error instanceof Error ? error.message : "Unknown error";
-			if (!force && FORCE_HINT_REGEX.test(message)) {
-				setForcePrompt({ image, message });
-			} else {
-				toast.error("Error deleting image", { description: message });
-			}
-		}
-	};
-
-	const columns = useMemo<ColumnDef<ImageRow>[]>(
-		() => [
-			{
-				accessorKey: "Repository",
-				header: ({ column }) => (
-					<SortableHeader column={column} title="Repository" />
-				),
-				cell: ({ row }) => (
-					<div
-						className="max-w-[280px] truncate font-medium"
-						title={row.original.Repository}
-					>
-						{row.original.Repository}
-					</div>
-				),
-			},
-			{
-				accessorKey: "Tag",
-				header: ({ column }) => <SortableHeader column={column} title="Tag" />,
-				cell: ({ row }) => <Badge variant="outline">{row.original.Tag}</Badge>,
-			},
-			{
-				accessorKey: "ID",
-				header: ({ column }) => (
-					<SortableHeader column={column} title="Image ID" />
-				),
-				cell: ({ row }) => (
-					<span className="font-mono text-xs text-muted-foreground">
-						{row.original.ID}
-					</span>
-				),
-			},
-			{
-				id: "Size",
-				accessorFn: (image) => parseSize(image.Size),
-				header: ({ column }) => <SortableHeader column={column} title="Size" />,
-				cell: ({ row }) => (
-					<span className="text-muted-foreground">{row.original.Size}</span>
-				),
-			},
-			{
-				id: "Created",
-				accessorFn: (image) => new Date(image.CreatedAt).getTime() || 0,
-				header: ({ column }) => (
-					<SortableHeader column={column} title="Created" />
-				),
-				cell: ({ row }) => (
-					<span className="text-muted-foreground whitespace-nowrap">
-						{row.original.CreatedSince}
-					</span>
-				),
-			},
-			{
-				id: "actions",
-				enableSorting: false,
-				header: () => <div className="text-right">Actions</div>,
-				cell: ({ row }) => (
-					<div className="flex items-center justify-end gap-3">
-						<ShowImageConfig
-							imageRef={getReference(row.original)}
-							serverId={serverId}
-						/>
-						<DialogAction
-							title="Delete image"
-							description={`The image "${getReference(row.original)}" will be removed from Docker. This action cannot be undone.`}
-							onClick={() => handleDelete(row.original)}
-						>
-							<Button variant="ghost" size="icon-sm" aria-label="Delete image">
-								<Trash2 className="size-4 text-destructive" />
-							</Button>
-						</DialogAction>
-					</div>
-				),
-			},
-		],
-		[serverId],
-	);
-
-	const table = useReactTable({
-		data: filteredData,
-		columns,
-		getRowId: (row) => row.key,
-		state: {
-			sorting,
-			pagination,
-		},
-		onSortingChange: setSorting,
-		onPaginationChange: setPagination,
-		getCoreRowModel: getCoreRowModel(),
-		getSortedRowModel: getSortedRowModel(),
-		getPaginationRowModel: getPaginationRowModel(),
-	});
-
-	return (
-		<div className="w-full">
-			<Card className="h-full bg-sidebar p-2.5 rounded-xl">
-				<div className="rounded-xl bg-background shadow-md ">
-					<CardHeader className="">
-						<CardTitle className="text-xl flex flex-row gap-2">
-							<Layers className="size-6 text-muted-foreground self-center" />
-							Images
-						</CardTitle>
-						<CardDescription>
-							Manage the Docker images of the selected server.
-						</CardDescription>
-					</CardHeader>
-
-					<CardContent className="space-y-4 py-8 border-t">
-						{isLoading ? (
-							<div className="flex flex-row gap-2 items-center justify-center text-sm text-muted-foreground min-h-[45vh]">
-								<span>Loading...</span>
-								<Loader2 className="animate-spin size-4" />
-							</div>
-						) : !images?.length ? (
-							<div className="flex min-h-[45vh] w-full flex-col items-center justify-center gap-4 rounded-lg border border-dashed p-8">
-								<div className="rounded-full bg-muted p-4">
-									<Layers className="size-10 text-muted-foreground" />
-								</div>
-								<div className="space-y-1 text-center">
-									<p className="text-sm font-medium">No images found</p>
-									<p className="max-w-sm text-sm text-muted-foreground">
-										Docker images pulled or built on this server will appear
-										here.
-									</p>
-								</div>
-							</div>
-						) : (
-							<>
-								<div className="flex flex-wrap items-center gap-2">
-									<Input
-										placeholder="Search by repository, tag or id..."
-										value={globalFilter}
-										onChange={(e) => setGlobalFilter(e.target.value)}
-										className="max-w-xs"
-									/>
-								</div>
-								<div className="rounded-md border overflow-x-auto">
-									<Table>
-										<TableHeader>
-											{table.getHeaderGroups().map((headerGroup) => (
-												<TableRow key={headerGroup.id}>
-													{headerGroup.headers.map((header) => (
-														<TableHead key={header.id}>
-															{header.isPlaceholder
-																? null
-																: flexRender(
-																		header.column.columnDef.header,
-																		header.getContext(),
-																	)}
-														</TableHead>
-													))}
-												</TableRow>
-											))}
-										</TableHeader>
-										<TableBody>
-											{table.getRowModel().rows?.length ? (
-												table.getRowModel().rows.map((row) => (
-													<TableRow key={row.id}>
-														{row.getVisibleCells().map((cell) => (
-															<TableCell key={cell.id}>
-																{flexRender(
-																	cell.column.columnDef.cell,
-																	cell.getContext(),
-																)}
-															</TableCell>
-														))}
-													</TableRow>
-												))
-											) : (
-												<TableRow>
-													<TableCell
-														colSpan={columns.length}
-														className="h-24 text-center text-muted-foreground"
-													>
-														No images match your filters.
-													</TableCell>
-												</TableRow>
-											)}
-										</TableBody>
-									</Table>
-								</div>
-								{table.getPageCount() > 1 && (
-									<div className="flex items-center justify-end gap-4">
-										<span className="text-sm text-muted-foreground">
-											Page {table.getState().pagination.pageIndex + 1} of{" "}
-											{table.getPageCount()}
-										</span>
-										<div className="flex gap-2">
-											<Button
-												variant="outline"
-												size="sm"
-												onClick={() => table.previousPage()}
-												disabled={!table.getCanPreviousPage()}
-											>
-												Previous
-											</Button>
-											<Button
-												variant="outline"
-												size="sm"
-												onClick={() => table.nextPage()}
-												disabled={!table.getCanNextPage()}
-											>
-												Next
-											</Button>
-										</div>
-									</div>
-								)}
-							</>
-						)}
-					</CardContent>
-				</div>
-			</Card>
-			<AlertDialog
-				open={!!forcePrompt}
-				onOpenChange={(open) => !open && setForcePrompt(null)}
-			>
-				<AlertDialogContent>
-					<AlertDialogHeader>
-						<AlertDialogTitle>Image is in use</AlertDialogTitle>
-						<AlertDialogDescription>
-							{forcePrompt?.message} Do you want to force the deletion? This may
-							affect containers still using this image.
-						</AlertDialogDescription>
-					</AlertDialogHeader>
-					<AlertDialogFooter>
-						<AlertDialogCancel onClick={() => setForcePrompt(null)}>
-							Cancel
-						</AlertDialogCancel>
-						<AlertDialogAction
-							variant="destructive"
-							onClick={() =>
-								forcePrompt && handleDelete(forcePrompt.image, true)
-							}
-						>
-							Force delete
-						</AlertDialogAction>
-					</AlertDialogFooter>
-				</AlertDialogContent>
-			</AlertDialog>
-		</div>
-	);
-};

apps/dokploy/components/dashboard/docker/logs/docker-logs-id.tsx

@@ -26,11 +26,6 @@ interface Props {
 	serviceId?: string;
 }
 
-// Sentinel the container-picker views fall back to before a real container
-// is selected/auto-selected — querying logs for it just surfaces Docker's
-// raw "No such container: select-a-container" daemon error.
-const PLACEHOLDER_CONTAINER_ID = "select-a-container";
-
 export const priorities = [
 	{
 		label: "Info",
@@ -60,16 +55,13 @@ export const DockerLogsId: React.FC<Props> = ({
 	runType,
 	serviceId,
 }) => {
-	const hasContainer =
-		!!containerId && containerId !== PLACEHOLDER_CONTAINER_ID;
-
 	const { data } = api.docker.getConfig.useQuery(
 		{
 			containerId,
 			serverId: serverId ?? undefined,
 		},
 		{
-			enabled: hasContainer,
+			enabled: !!containerId,
 		},
 	);
 
@@ -142,7 +134,7 @@ export const DockerLogsId: React.FC<Props> = ({
 	};
 
 	useEffect(() => {
-		if (!hasContainer) return;
+		if (!containerId) return;
 
 		let isCurrentConnection = true;
 		let noDataTimeout: NodeJS.Timeout;
@@ -352,11 +344,11 @@ export const DockerLogsId: React.FC<Props> = ({
 							/>
 						</div>
 
-						<div className="flex flex-wrap gap-2">
+						<div className="flex gap-2">
 							<Button
 								variant="outline"
 								size="sm"
-								className="h-9 w-full sm:w-auto"
+								className="h-9"
 								onClick={handlePauseResume}
 								title={isPaused ? "Resume logs" : "Pause logs"}
 							>
@@ -372,7 +364,7 @@ export const DockerLogsId: React.FC<Props> = ({
 							<Button
 								variant="outline"
 								size="sm"
-								className="h-9 w-full sm:w-auto"
+								className="h-9"
 								onClick={handleCopy}
 								disabled={filteredLogs.length === 0}
 								title="Copy logs to clipboard"
@@ -389,7 +381,7 @@ export const DockerLogsId: React.FC<Props> = ({
 							<Button
 								variant="outline"
 								size="sm"
-								className="h-9 w-full sm:w-auto"
+								className="h-9 sm:w-auto w-full"
 								onClick={handleDownload}
 								disabled={filteredLogs.length === 0 || !data?.Name}
 								title="Download logs as text file"
@@ -418,7 +410,7 @@ export const DockerLogsId: React.FC<Props> = ({
 					<div
 						ref={scrollRef}
 						onScroll={handleScroll}
-						className="h-[50vh] sm:h-[720px] overflow-y-auto space-y-0 border p-4 bg-[#fafafa] dark:bg-[#050506] rounded custom-logs-scrollbar"
+						className="h-[720px] overflow-y-auto space-y-0 border p-4 bg-[#fafafa] dark:bg-[#050506] rounded custom-logs-scrollbar"
 					>
 						{filteredLogs.length > 0 ? (
 							filteredLogs.map((filteredLog: LogLine, index: number) => (
@@ -433,15 +425,10 @@ export const DockerLogsId: React.FC<Props> = ({
 							<div className="flex justify-center items-center h-full text-muted-foreground">
 								<Loader2 className="h-6 w-6 animate-spin" />
 							</div>
-						) : hasContainer ? (
+						) : (
 							<div className="flex justify-center items-center h-full text-muted-foreground">
 								No logs found
 							</div>
-						) : (
-							<div className="flex justify-center items-center h-full text-center text-sm text-muted-foreground px-8">
-								Select a container above to view its logs. If none are listed,
-								make sure the service is deployed and running.
-							</div>
 						)}
 					</div>
 				</div>

apps/dokploy/components/dashboard/docker/logs/terminal-line.tsx

@@ -64,9 +64,7 @@ export function TerminalLine({ log, noTimestamp, searchTerm }: LogLineProps) {
 
 	const tooltip = (color: string, timestamp: string | null) => {
 		const square = (
-			<div
-				className={cn("w-2 min-h-4 h-full flex-shrink-0 rounded-[3px]", color)}
-			/>
+			<div className={cn("w-2 h-full shrink-0 rounded-[3px]", color)} />
 		);
 		return timestamp ? (
 			<TooltipProvider delayDuration={0} disableHoverableContent>
@@ -90,7 +88,7 @@ export function TerminalLine({ log, noTimestamp, searchTerm }: LogLineProps) {
 	return (
 		<div
 			className={cn(
-				"font-mono text-xs flex flex-col sm:flex-row gap-1 sm:gap-3 py-2 sm:py-0.5 group",
+				"font-mono text-xs flex flex-row gap-3 py-2 sm:py-0.5 group",
 				type === "error"
 					? "bg-red-500/10 hover:bg-red-500/15"
 					: type === "warning"
@@ -106,7 +104,7 @@ export function TerminalLine({ log, noTimestamp, searchTerm }: LogLineProps) {
 				{/* <Square className="size-4 text-muted-foreground opacity-0 group-hover/logitem:opacity-100 transition-opacity" /> */}
 				{tooltip(color, rawTimestamp)}
 				{!noTimestamp && (
-					<span className="select-none pl-2 text-muted-foreground w-auto sm:w-40 flex-shrink-0">
+					<span className="select-none pl-2 text-muted-foreground w-full sm:w-40 shrink-0">
 						{formattedTime}
 					</span>
 				)}

apps/dokploy/components/dashboard/docker/logs/utils.ts

@@ -7,28 +7,6 @@ export interface LogLine {
 	message: string;
 }
 
-interface ContainerOption {
-	containerId: string;
-}
-
-export const resolveContainerSelection = (
-	currentContainerId: string | undefined,
-	containers: readonly ContainerOption[] | undefined,
-) => {
-	if (!containers) {
-		return currentContainerId;
-	}
-
-	if (
-		currentContainerId &&
-		containers.some(({ containerId }) => containerId === currentContainerId)
-	) {
-		return currentContainerId;
-	}
-
-	return containers[0]?.containerId;
-};
-
 interface LogStyle {
 	type: LogType;
 	variant: LogVariant;

apps/dokploy/components/dashboard/docker/terminal/docker-terminal.tsx

@@ -3,7 +3,6 @@ import React, { useEffect, useRef } from "react";
 import { FitAddon } from "xterm-addon-fit";
 import "@xterm/xterm/css/xterm.css";
 import { AttachAddon } from "@xterm/addon-attach";
-import { ClipboardAddon } from "@xterm/addon-clipboard";
 import { useTheme } from "next-themes";
 import { Tabs, TabsList, TabsTrigger } from "@/components/ui/tabs";
 import { fixMacOsAltKeys } from "@/lib/terminal-keyboard";
@@ -15,10 +14,6 @@ interface Props {
 	serviceId?: string;
 }
 
-// Sentinel the container-picker modal renders with before a real container
-// is selected/auto-selected — never worth opening a connection for.
-const PLACEHOLDER_CONTAINER_ID = "select-a-container";
-
 export const DockerTerminal: React.FC<Props> = ({
 	id,
 	containerId,
@@ -29,105 +24,56 @@ export const DockerTerminal: React.FC<Props> = ({
 	const [activeWay, setActiveWay] = React.useState<string | undefined>("bash");
 	const { resolvedTheme } = useTheme();
 	useEffect(() => {
-		if (!containerId || containerId === PLACEHOLDER_CONTAINER_ID) {
-			return;
+		const container = document.getElementById(id);
+		if (container) {
+			container.innerHTML = "";
 		}
-
-		let cancelled = false;
-		let term: Terminal | null = null;
-		let ws: WebSocket | null = null;
-		let resizeObserver: ResizeObserver | null = null;
-
-		// Deferred a frame so React StrictMode's dev-only phantom mount+cleanup
-		// (which runs synchronously, before anything paints) never creates a
-		// terminal in the first place — dodges a known xterm.js dispose race
-		// (xtermjs/xterm.js#5011) where a deferred internal callback outlives
-		// term.dispose() and reads renderer state that's already gone.
-		const frame = requestAnimationFrame(() => {
-			if (cancelled) return;
-
-			const container = document.getElementById(id);
-			if (container) {
-				container.innerHTML = "";
-			}
-			term = new Terminal({
-				cursorBlink: true,
-				lineHeight: 1.4,
-				convertEol: true,
-				theme: {
-					cursor: resolvedTheme === "light" ? "#000000" : "transparent",
-					background: "rgba(0, 0, 0, 0)",
-					foreground: "currentColor",
-				},
-			});
-			const addonFit = new FitAddon();
-			const clipboardAddon = new ClipboardAddon();
-			term.loadAddon(clipboardAddon);
-			fixMacOsAltKeys(term);
-			// @ts-expect-error
-			term.open(termRef.current);
-			term.loadAddon(addonFit);
-			addonFit.fit();
-
-			const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
-			const wsUrl = `${protocol}//${window.location.host}/docker-container-terminal?containerId=${containerId}&activeWay=${activeWay}&cols=${term.cols}&rows=${term.rows}${serverId ? `&serverId=${serverId}` : ""}${serviceId ? `&serviceId=${serviceId}` : ""}`;
-
-			ws = new WebSocket(wsUrl);
-			const addonAttach = new AttachAddon(ws);
-			term.loadAddon(addonAttach);
-
-			const sendResize = (cols: number, rows: number) => {
-				if (ws && ws.readyState === WebSocket.OPEN) {
-					ws.send(JSON.stringify({ type: "resize", cols, rows }));
-				}
-			};
-			term.onResize(({ cols, rows }) => sendResize(cols, rows));
-
-			resizeObserver = new ResizeObserver(() => addonFit.fit());
-			if (termRef.current) {
-				resizeObserver.observe(termRef.current);
-			}
+		const term = new Terminal({
+			cursorBlink: true,
+			lineHeight: 1.4,
+			convertEol: true,
+			theme: {
+				cursor: resolvedTheme === "light" ? "#000000" : "transparent",
+				background: "rgba(0, 0, 0, 0)",
+				foreground: "currentColor",
+			},
 		});
+		const addonFit = new FitAddon();
+		const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
 
+		const wsUrl = `${protocol}//${window.location.host}/docker-container-terminal?containerId=${containerId}&activeWay=${activeWay}${serverId ? `&serverId=${serverId}` : ""}${serviceId ? `&serviceId=${serviceId}` : ""}`;
+
+		const ws = new WebSocket(wsUrl);
+
+		const addonAttach = new AttachAddon(ws);
+		fixMacOsAltKeys(term);
+		// @ts-ignore
+		term.open(termRef.current);
+		// @ts-ignore
+		term.loadAddon(addonFit);
+		term.loadAddon(addonAttach);
+		addonFit.fit();
 		return () => {
-			cancelled = true;
-			cancelAnimationFrame(frame);
-			resizeObserver?.disconnect();
-			if (ws && ws.readyState === WebSocket.OPEN) {
-				ws.close();
-			}
-			term?.dispose();
+			ws.readyState === WebSocket.OPEN && ws.close();
 		};
 	}, [containerId, activeWay, id]);
 
-	const hasContainer =
-		!!containerId && containerId !== PLACEHOLDER_CONTAINER_ID;
-
 	return (
 		<div className="flex flex-col gap-4">
-			{hasContainer && (
-				<div className="flex flex-col gap-2  mt-4">
-					<span>
-						Select way to connect to <b>{containerId}</b>
-					</span>
-					<Tabs value={activeWay} onValueChange={setActiveWay}>
-						<TabsList>
-							<TabsTrigger value="bash">Bash</TabsTrigger>
-							<TabsTrigger value="sh">/bin/sh</TabsTrigger>
-						</TabsList>
-					</Tabs>
-				</div>
-			)}
-			{hasContainer ? (
-				<div className="w-full h-[420px] rounded-lg p-2 bg-transparent border">
-					<div id={id} ref={termRef} className="h-full" />
-				</div>
-			) : (
-				<div className="flex h-[420px] w-full items-center justify-center rounded-lg border border-dashed p-4 text-center text-sm text-muted-foreground">
-					Select a container above to open a terminal. If none are listed, make
-					sure the service is deployed and running.
-				</div>
-			)}
+			<div className="flex flex-col gap-2  mt-4">
+				<span>
+					Select way to connect to <b>{containerId}</b>
+				</span>
+				<Tabs value={activeWay} onValueChange={setActiveWay}>
+					<TabsList>
+						<TabsTrigger value="bash">Bash</TabsTrigger>
+						<TabsTrigger value="sh">/bin/sh</TabsTrigger>
+					</TabsList>
+				</Tabs>
+			</div>
+			<div className="w-full h-full rounded-lg p-2 bg-transparent border">
+				<div id={id} ref={termRef} />
+			</div>
 		</div>
 	);
 };

apps/dokploy/components/dashboard/home/show-home.tsx

@@ -223,7 +223,7 @@ export const ShowHome = () => {
 							</div>
 							{canReadDeployments && (
 								<Link
-									href="/dashboard/overview?tab=deployments"
+									href="/dashboard/deployments"
 									className="text-xs text-muted-foreground hover:text-foreground transition-colors"
 								>
 									view all →

apps/dokploy/components/dashboard/monitoring/free/container/show-free-container-monitoring.tsx

@@ -1,6 +1,5 @@
 import { formatMb } from "@dokploy/server/monitoring/units";
 import { useEffect, useState } from "react";
-import { toast } from "sonner";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import { Progress } from "@/components/ui/progress";
 import { api } from "@/utils/api";
@@ -168,8 +167,6 @@ export const ContainerFreeMonitoring = ({
 	}, [data]);
 
 	useEffect(() => {
-		if (!appName) return;
-
 		const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
 		const wsUrl = `${protocol}//${window.location.host}/listen-docker-stats-monitoring?appName=${appName}&appType=${appType}`;
 		const ws = new WebSocket(wsUrl);
@@ -199,9 +196,7 @@ export const ContainerFreeMonitoring = ({
 		};
 
 		ws.onclose = (e) => {
-			if (e.reason) {
-				toast.error(e.reason);
-			}
+			console.log(e.reason);
 		};
 
 		return () => ws.close();

apps/dokploy/components/dashboard/monitoring/paid/servers/network-chart.tsx

@@ -19,11 +19,6 @@ interface NetworkChartProps {
 	data: any[];
 }
 
-function formatNetworkGB(valueInMB: number) {
-	if (Number.isNaN(valueInMB)) return "0";
-	return (valueInMB / 1024).toFixed(1);
-}
-
 const chartConfig = {
 	networkIn: {
 		label: "Network In",
@@ -43,8 +38,8 @@ export function NetworkChart({ data }: NetworkChartProps) {
 			<CardHeader className="border-b py-5">
 				<CardTitle>Network</CardTitle>
 				<CardDescription>
-					Network Total: ↑ {formatNetworkGB(latestData.networkOut)} GB ↓{" "}
-					{formatNetworkGB(latestData.networkIn)} GB (since Boot)
+					Network Traffic: ↑ {latestData.networkOut} KB/s ↓{" "}
+					{latestData.networkIn} KB/s
 				</CardDescription>
 			</CardHeader>
 			<CardContent className="px-2 pt-4 sm:px-6 sm:pt-6">
@@ -88,7 +83,7 @@ export function NetworkChart({ data }: NetworkChartProps) {
 							minTickGap={32}
 							tickFormatter={(value) => formatTimestamp(value)}
 						/>
-						<YAxis tickFormatter={(value) => `${formatNetworkGB(value)} GB`} />
+						<YAxis tickFormatter={(value) => `${value} KB/s`} />
 						<ChartTooltip
 							cursor={false}
 							content={({ active, payload, label }) => {
@@ -110,8 +105,8 @@ export function NetworkChart({ data }: NetworkChartProps) {
 														Network
 													</span>
 													<span className="font-bold">
-														↑ {formatNetworkGB(data.networkOut)} GB
-														<br />↓ {formatNetworkGB(data.networkIn)} GB
+														↑ {data.networkOut} KB/s
+														<br />↓ {data.networkIn} KB/s
 													</span>
 												</div>
 											</div>

apps/dokploy/components/dashboard/networks/sync-networks.tsx

@@ -34,7 +34,6 @@ export const SyncNetworks = ({ serverId }: Props) => {
 	const importMutation = api.network.import.useMutation();
 	const removeMutation = api.network.remove.useMutation();
 	const recreateMutation = api.network.recreate.useMutation();
-	const resyncMutation = api.network.resync.useMutation();
 
 	const toggleSelected = (name: string) => {
 		setSelected((prev) => {
@@ -103,20 +102,6 @@ export const SyncNetworks = ({ serverId }: Props) => {
 		}
 	};
 
-	const onResync = async (networkId: string, name: string) => {
-		try {
-			await resyncMutation.mutateAsync({ networkId });
-			toast.success(`Network "${name}" updated from Docker`);
-			await utils.network.all.invalidate();
-			await utils.network.networksToSync.invalidate();
-			await refetch();
-		} catch (error) {
-			toast.error("Error updating network", {
-				description: error instanceof Error ? error.message : "Unknown error",
-			});
-		}
-	};
-
 	return (
 		<Dialog
 			open={open}
@@ -192,45 +177,6 @@ export const SyncNetworks = ({ serverId }: Props) => {
 							)}
 						</div>
 
-						{!!data?.changed.length && (
-							<>
-								<Separator />
-								<div className="flex flex-col gap-2">
-									<span className="text-sm font-medium">
-										Changed ({data.changed.length})
-									</span>
-									<span className="text-xs text-muted-foreground">
-										These networks were deleted and recreated in Docker under
-										the same name — attributes in Dokploy are outdated.
-									</span>
-									{data.changed.map((changed) => (
-										<div
-											key={changed.networkId}
-											className="flex items-center justify-between gap-3 rounded-lg border border-dashed p-3"
-										>
-											<div className="flex items-center gap-3">
-												<span className="text-sm">{changed.name}</span>
-												{changed.driver && (
-													<Badge variant="outline">{changed.driver}</Badge>
-												)}
-											</div>
-											<Button
-												variant="outline"
-												size="xs"
-												isLoading={resyncMutation.isPending}
-												onClick={() =>
-													onResync(changed.networkId, changed.name)
-												}
-											>
-												<RotateCcw className="size-3.5" />
-												Update
-											</Button>
-										</div>
-									))}
-								</div>
-							</>
-						)}
-
 						{!!data?.missing.length && (
 							<>
 								<Separator />

apps/dokploy/components/dashboard/onboarding/font.ts

@@ -1,8 +0,0 @@
-import { Fraunces } from "next/font/google";
-
-export const displayFont = Fraunces({
-	subsets: ["latin"],
-	weight: ["600"],
-	style: ["normal", "italic"],
-	display: "swap",
-});

apps/dokploy/components/dashboard/onboarding/onboarding-lock.ts

@@ -1,49 +0,0 @@
-const ONBOARDING_ACTIVE_KEY = "dokploy_onboarding_active";
-const ONBOARDING_STATE_KEY = "dokploy_onboarding_state";
-
-interface OnboardingState {
-	stepId?: string;
-	projectId?: string;
-	environmentId?: string;
-}
-
-export const isOnboardingActive = () => {
-	if (typeof window === "undefined") return false;
-	try {
-		return window.localStorage.getItem(ONBOARDING_ACTIVE_KEY) === "true";
-	} catch {
-		return false;
-	}
-};
-
-export const markOnboardingActive = () => {
-	try {
-		window.localStorage.setItem(ONBOARDING_ACTIVE_KEY, "true");
-	} catch {}
-};
-
-export const clearOnboardingActive = () => {
-	try {
-		window.localStorage.removeItem(ONBOARDING_ACTIVE_KEY);
-		window.localStorage.removeItem(ONBOARDING_STATE_KEY);
-	} catch {}
-};
-
-export const getOnboardingState = (): OnboardingState => {
-	if (typeof window === "undefined") return {};
-	try {
-		const raw = window.localStorage.getItem(ONBOARDING_STATE_KEY);
-		return raw ? JSON.parse(raw) : {};
-	} catch {
-		return {};
-	}
-};
-
-export const setOnboardingState = (state: OnboardingState) => {
-	try {
-		window.localStorage.setItem(
-			ONBOARDING_STATE_KEY,
-			JSON.stringify({ ...getOnboardingState(), ...state }),
-		);
-	} catch {}
-};

apps/dokploy/components/dashboard/onboarding/onboarding-wizard.tsx

@@ -1,296 +0,0 @@
-import { defineStepper } from "@stepperize/react";
-import { CheckIcon } from "lucide-react";
-import Link from "next/link";
-import { useRouter } from "next/router";
-import { useEffect, useState } from "react";
-import { GithubIcon } from "@/components/icons/data-tools-icons";
-import { Logo } from "@/components/shared/logo";
-import { Button } from "@/components/ui/button";
-import {
-	Dialog,
-	DialogContent,
-	DialogDescription,
-	DialogFooter,
-	DialogHeader,
-	DialogTitle,
-} from "@/components/ui/dialog";
-import { api } from "@/utils/api";
-import { getOnboardingState, setOnboardingState } from "./onboarding-lock";
-import { CompleteStep } from "./steps/complete-step";
-import { DeployStep } from "./steps/deploy-step";
-import { PlanStep } from "./steps/plan-step";
-import { ProjectStep } from "./steps/project-step";
-import { ServerStep } from "./steps/server-step";
-import { WelcomeStep } from "./steps/welcome-step";
-
-const { useStepper, steps, Scoped } = defineStepper(
-	{ id: "welcome", title: "Welcome" },
-	{ id: "plan", title: "Pick a plan" },
-	{ id: "project", title: "New project" },
-	{ id: "server", title: "Connect server" },
-	{ id: "deploy", title: "Ship something" },
-	{ id: "complete", title: "You're live" },
-);
-
-type StepId = (typeof steps)[number]["id"];
-const isStepId = (id: string | undefined): id is StepId =>
-	!!id && steps.some((step) => step.id === id);
-
-interface Props {
-	onClose: () => void | Promise<void>;
-}
-
-export const OnboardingWizard = ({ onClose }: Props) => {
-	const router = useRouter();
-	const persisted = getOnboardingState();
-	const stepper = useStepper(
-		isStepId(persisted.stepId) ? persisted.stepId : undefined,
-	);
-	const [projectId, setProjectId] = useState<string | undefined>(
-		persisted.projectId,
-	);
-	const [environmentId, setEnvironmentId] = useState<string | undefined>(
-		persisted.environmentId,
-	);
-
-	const { data: isCloud = true } = api.settings.isCloud.useQuery();
-	const visibleStepIds = isCloud
-		? steps.map((step) => step.id)
-		: steps
-				.filter((step) => step.id !== "plan" && step.id !== "server")
-				.map((step) => step.id);
-	const visibleIndex = visibleStepIds.indexOf(stepper.current.id);
-	const isLastVisible = visibleIndex === visibleStepIds.length - 1;
-	const goToNextVisible = () => {
-		const nextId = visibleStepIds[visibleIndex + 1];
-		if (nextId) stepper.goTo(nextId);
-	};
-
-	const [skipAllOpen, setSkipAllOpen] = useState(false);
-	const handleSkipAll = async () => {
-		await onClose();
-		router.push(
-			projectId && environmentId
-				? `/dashboard/project/${projectId}/environment/${environmentId}`
-				: "/dashboard/projects",
-		);
-	};
-
-	useEffect(() => {
-		setOnboardingState({ stepId: stepper.current.id });
-	}, [stepper.current.id]);
-
-	const { error: projectCheckError } = api.project.one.useQuery(
-		{ projectId: projectId ?? "" },
-		{ enabled: !!projectId, retry: false },
-	);
-	useEffect(() => {
-		if (!projectCheckError || !projectId) return;
-		setProjectId(undefined);
-		setEnvironmentId(undefined);
-		setOnboardingState({ projectId: undefined, environmentId: undefined });
-		stepper.goTo("project");
-	}, [projectCheckError, projectId]);
-
-	return (
-		<>
-			<div className="fixed inset-0 z-50 flex flex-col md:flex-row bg-background text-foreground">
-				<aside className="relative shrink-0 md:w-[300px] lg:w-[340px] overflow-hidden bg-zinc-950 text-zinc-400">
-					<div
-						className="pointer-events-none absolute inset-0 opacity-[0.07]"
-						style={{
-							backgroundImage:
-								"linear-gradient(to right, white 1px, transparent 1px), linear-gradient(to bottom, white 1px, transparent 1px)",
-							backgroundSize: "28px 28px",
-						}}
-					/>
-					<div className="pointer-events-none absolute -top-24 -left-24 size-72 rounded-full bg-white/10 blur-[100px]" />
-
-					<div className="relative flex md:h-full flex-col p-6 lg:p-8">
-						<div className="flex items-center justify-between md:block">
-							<div className="flex items-center gap-2.5 text-zinc-50 [&_path]:!fill-white [&_path]:!stroke-white">
-								<Logo className="size-7" />
-								<span className="text-lg font-semibold tracking-tight">
-									Dokploy
-								</span>
-							</div>
-							{!isLastVisible && (
-								<button
-									type="button"
-									onClick={() => setSkipAllOpen(true)}
-									className="font-mono text-[11px] uppercase tracking-wider text-zinc-400 hover:text-zinc-100 transition-colors md:hidden"
-								>
-									Skip all
-								</button>
-							)}
-						</div>
-
-						<Scoped>
-							<ol className="hidden md:flex flex-col gap-0.5 mt-12">
-								{visibleStepIds.map((id, index) => {
-									const step = steps.find((s) => s.id === id)!;
-									const isDone = index < visibleIndex;
-									const isCurrent = stepper.current.id === step.id;
-									return (
-										<li key={step.id} className="flex gap-3.5">
-											<div className="flex flex-col items-center">
-												<span
-													className={`flex items-center justify-center font-mono text-[11px] tabular-nums size-5 rounded-full ${
-														isCurrent
-															? "bg-white text-zinc-950 font-semibold"
-															: isDone
-																? "text-zinc-100"
-																: "text-zinc-400"
-													}`}
-												>
-													{isDone ? (
-														<CheckIcon className="size-3" />
-													) : (
-														String(index + 1).padStart(2, "0")
-													)}
-												</span>
-												{index < visibleStepIds.length - 1 && (
-													<span
-														className={`w-px flex-1 min-h-7 my-1.5 ${
-															isDone ? "bg-zinc-400" : "bg-zinc-700"
-														}`}
-													/>
-												)}
-											</div>
-											{isDone ? (
-												<button
-													type="button"
-													onClick={() => stepper.goTo(step.id)}
-													className="text-sm font-medium transition-colors pb-6 last:pb-0 text-zinc-100 hover:text-white text-left"
-												>
-													{step.title}
-												</button>
-											) : (
-												<p
-													className={`text-sm font-medium transition-colors pb-6 last:pb-0 ${
-														isCurrent ? "text-white" : "text-zinc-400"
-													}`}
-												>
-													{step.title}
-												</p>
-											)}
-										</li>
-									);
-								})}
-							</ol>
-						</Scoped>
-
-						<div className="hidden md:flex flex-col gap-4 mt-auto pt-8 border-t border-zinc-800">
-							{!isLastVisible && (
-								<button
-									type="button"
-									onClick={() => setSkipAllOpen(true)}
-									className="w-fit font-mono text-[11px] uppercase tracking-wider text-zinc-400 hover:text-zinc-100 transition-colors"
-								>
-									Skip all →
-								</button>
-							)}
-							<div className="flex items-center gap-3 text-zinc-500">
-								<Link
-									href="https://github.com/dokploy/dokploy"
-									target="_blank"
-									className="hover:text-zinc-200 transition-colors"
-								>
-									<GithubIcon />
-								</Link>
-								<Link
-									href="https://x.com/getdokploy"
-									target="_blank"
-									className="hover:text-zinc-200 transition-colors"
-								>
-									<svg
-										stroke="currentColor"
-										fill="currentColor"
-										strokeWidth="0"
-										viewBox="0 0 24 24"
-										xmlns="http://www.w3.org/2000/svg"
-										className="size-4"
-									>
-										<path d="M10.4883 14.651L15.25 21H22.25L14.3917 10.5223L20.9308 3H18.2808L13.1643 8.88578L8.75 3H1.75L9.26086 13.0145L2.31915 21H4.96917L10.4883 14.651ZM16.25 19L5.75 5H7.75L18.25 19H16.25Z" />
-									</svg>
-								</Link>
-								<Link
-									href="https://discord.com/invite/2tBnJ3jDJc"
-									target="_blank"
-									className="hover:text-zinc-200 transition-colors"
-								>
-									<svg
-										xmlns="http://www.w3.org/2000/svg"
-										viewBox="0 0 48 48"
-										className="size-4"
-									>
-										<path
-											fill="currentColor"
-											d="M39.248,10.177c-2.804-1.287-5.812-2.235-8.956-2.778c-0.057-0.01-0.114,0.016-0.144,0.068	c-0.387,0.688-0.815,1.585-1.115,2.291c-3.382-0.506-6.747-0.506-10.059,0c-0.3-0.721-0.744-1.603-1.133-2.291	c-0.03-0.051-0.087-0.077-0.144-0.068c-3.143,0.541-6.15,1.489-8.956,2.778c-0.024,0.01-0.045,0.028-0.059,0.051	c-5.704,8.522-7.267,16.835-6.5,25.044c0.003,0.04,0.026,0.079,0.057,0.103c3.763,2.764,7.409,4.442,10.987,5.554	c0.057,0.017,0.118-0.003,0.154-0.051c0.846-1.156,1.601-2.374,2.248-3.656c0.038-0.075,0.002-0.164-0.076-0.194	c-1.197-0.454-2.336-1.007-3.432-1.636c-0.087-0.051-0.094-0.175-0.014-0.234c0.231-0.173,0.461-0.353,0.682-0.534	c0.04-0.033,0.095-0.04,0.142-0.019c7.201,3.288,14.997,3.288,22.113,0c0.047-0.023,0.102-0.016,0.144,0.017	c0.22,0.182,0.451,0.363,0.683,0.536c0.08,0.059,0.075,0.183-0.012,0.234c-1.096,0.641-2.236,1.182-3.434,1.634	c-0.078,0.03-0.113,0.12-0.075,0.196c0.661,1.28,1.415,2.498,2.246,3.654c0.035,0.049,0.097,0.07,0.154,0.052	c3.595-1.112,7.241-2.79,11.004-5.554c0.033-0.024,0.054-0.061,0.057-0.101c0.917-9.491-1.537-17.735-6.505-25.044	C39.293,10.205,39.272,10.187,39.248,10.177z M16.703,30.273c-2.168,0-3.954-1.99-3.954-4.435s1.752-4.435,3.954-4.435	c2.22,0,3.989,2.008,3.954,4.435C20.658,28.282,18.906,30.273,16.703,30.273z M31.324,30.273c-2.168,0-3.954-1.99-3.954-4.435	s1.752-4.435,3.954-4.435c2.22,0,3.989,2.008,3.954,4.435C35.278,28.282,33.544,30.273,31.324,30.273z"
-										/>
-									</svg>
-								</Link>
-							</div>
-						</div>
-					</div>
-				</aside>
-
-				<div className="flex-1 overflow-y-auto">
-					<div className="mx-auto w-full max-w-2xl px-6 py-14 lg:py-20">
-						{stepper.switch({
-							welcome: () => <WelcomeStep onNext={goToNextVisible} />,
-							plan: () => <PlanStep onNext={goToNextVisible} />,
-							project: () => (
-								<ProjectStep
-									onNext={(project) => {
-										setProjectId(project.projectId);
-										setEnvironmentId(project.environmentId);
-										setOnboardingState({
-											projectId: project.projectId,
-											environmentId: project.environmentId,
-										});
-										goToNextVisible();
-									}}
-								/>
-							),
-							server: () => <ServerStep onNext={goToNextVisible} />,
-							deploy: () => (
-								<DeployStep
-									environmentId={environmentId}
-									onNext={goToNextVisible}
-								/>
-							),
-							complete: () => (
-								<CompleteStep
-									projectId={projectId}
-									environmentId={environmentId}
-									onFinish={onClose}
-								/>
-							),
-						})}
-					</div>
-				</div>
-			</div>
-
-			<Dialog open={skipAllOpen} onOpenChange={setSkipAllOpen}>
-				<DialogContent>
-					<DialogHeader>
-						<DialogTitle>Skip onboarding?</DialogTitle>
-						<DialogDescription>
-							If this is your first time using Dokploy, we recommend going
-							through these steps – it only takes a couple of minutes and gives
-							you a feel for how projects, servers, and deployments fit
-							together.
-						</DialogDescription>
-					</DialogHeader>
-					<DialogFooter>
-						<Button variant="outline" onClick={() => setSkipAllOpen(false)}>
-							Continue setup
-						</Button>
-						<Button onClick={handleSkipAll}>Skip anyway</Button>
-					</DialogFooter>
-				</DialogContent>
-			</Dialog>
-		</>
-	);
-};

apps/dokploy/components/dashboard/onboarding/steps/complete-step.tsx

@@ -1,133 +0,0 @@
-import {
-	BookIcon,
-	DatabaseIcon,
-	GitMergeIcon,
-	GlobeIcon,
-	UsersIcon,
-} from "lucide-react";
-import Link from "next/link";
-import { useRouter } from "next/router";
-import { useEffect, useState } from "react";
-import ConfettiExplosion from "react-confetti-explosion";
-import { Button } from "@/components/ui/button";
-import { displayFont } from "../font";
-
-interface Props {
-	projectId?: string;
-	environmentId?: string;
-	onFinish: () => void | Promise<void>;
-}
-
-const features = [
-	{
-		icon: DatabaseIcon,
-		title: "Databases",
-		description: "Postgres, MySQL, MongoDB, Redis and more, one click away.",
-	},
-	{
-		icon: GlobeIcon,
-		title: "Custom domains",
-		description: "Attach your own domains and get automatic HTTPS.",
-	},
-	{
-		icon: GitMergeIcon,
-		title: "CI/CD",
-		description: "Auto-deploy on every push from GitHub, GitLab or Bitbucket.",
-	},
-	{
-		icon: UsersIcon,
-		title: "Team collaboration",
-		description: "Invite teammates with fine-grained permissions.",
-	},
-];
-
-export const CompleteStep = ({ projectId, environmentId, onFinish }: Props) => {
-	const router = useRouter();
-	const [showConfetti, setShowConfetti] = useState(false);
-	const [isFinishing, setIsFinishing] = useState(false);
-
-	useEffect(() => {
-		setShowConfetti(true);
-	}, []);
-
-	const projectHref =
-		projectId && environmentId
-			? `/dashboard/project/${projectId}/environment/${environmentId}`
-			: "/dashboard/projects";
-
-	const handleFinish = async () => {
-		setIsFinishing(true);
-		await onFinish();
-		router.push(projectHref);
-	};
-
-	return (
-		<div className="flex flex-col gap-10">
-			<div className="fixed inset-x-0 top-0 flex justify-center pointer-events-none">
-				{showConfetti && (
-					<ConfettiExplosion
-						duration={3000}
-						force={0.35}
-						particleCount={200}
-						width={1200}
-						zIndex={60}
-					/>
-				)}
-			</div>
-
-			<div className="flex flex-col gap-4">
-				<span className="font-mono text-xs uppercase tracking-[0.2em] text-primary">
-					Done
-				</span>
-				<h1
-					className={`${displayFont.className} text-4xl sm:text-5xl leading-[1.05] tracking-tight`}
-				>
-					You're all set.
-				</h1>
-				<p className="text-muted-foreground text-lg max-w-md leading-relaxed">
-					This is just the beginning — here's some of what else you can do.
-				</p>
-			</div>
-
-			<dl className="flex flex-col divide-y">
-				{features.map((feature, index) => (
-					<div key={feature.title} className="flex gap-6 py-5 first:pt-0">
-						<dt className="font-mono text-xs text-muted-foreground pt-1 shrink-0 w-6">
-							{String(index + 1).padStart(2, "0")}
-						</dt>
-						<dd className="flex flex-col gap-1">
-							<span className="font-medium flex items-center gap-2">
-								<feature.icon className="size-4 text-muted-foreground" />
-								{feature.title}
-							</span>
-							<span className="text-sm text-muted-foreground">
-								{feature.description}
-							</span>
-						</dd>
-					</div>
-				))}
-			</dl>
-
-			<div className="flex items-center gap-4">
-				<Button
-					size="lg"
-					className="w-fit px-8"
-					isLoading={isFinishing}
-					onClick={handleFinish}
-				>
-					Go to my project
-				</Button>
-				<Button variant="ghost" asChild>
-					<Link
-						href="https://docs.dokploy.com/docs/core"
-						target="_blank"
-						className="flex items-center gap-1.5"
-					>
-						<BookIcon size={14} />
-						Read the docs
-					</Link>
-				</Button>
-			</div>
-		</div>
-	);
-};

apps/dokploy/components/dashboard/onboarding/steps/deploy-step.tsx

@@ -1,295 +0,0 @@
-import copy from "copy-to-clipboard";
-import {
-	ArrowUpRightIcon,
-	CheckCircle2,
-	CopyIcon,
-	Loader2,
-	XCircleIcon,
-} from "lucide-react";
-import { useState } from "react";
-import { toast } from "sonner";
-import { AlertBlock } from "@/components/shared/alert-block";
-import { Button } from "@/components/ui/button";
-import { api } from "@/utils/api";
-import { displayFont } from "../font";
-
-interface Props {
-	environmentId?: string;
-	onNext: () => void;
-	/** Drops the onboarding wizard's display serif for callers (e.g. the
-	 * post-checkout welcome modal) that want the app's regular typography. */
-	plainTitle?: boolean;
-}
-
-const CURATED_TEMPLATES = [
-	{ id: "wordpress", name: "WordPress", logo: "wordpress.png" },
-	{ id: "ghost", name: "Ghost", logo: "ghost.jpeg" },
-	{ id: "n8n", name: "n8n", logo: "n8n.png" },
-	{ id: "uptime-kuma", name: "Uptime Kuma", logo: "uptime-kuma.png" },
-];
-
-type Deploying = { kind: "app" | "template"; id: string; url: string };
-
-export const DeployStep = ({ environmentId, onNext, plainTitle }: Props) => {
-	const titleClassName = plainTitle
-		? "text-xl font-semibold tracking-tight"
-		: `${displayFont.className} text-4xl sm:text-5xl leading-[1.05] tracking-tight`;
-	const { data: isCloud = true } = api.settings.isCloud.useQuery();
-	const { data: servers } = api.server.withSSHKey.useQuery();
-	const serverId = servers?.[0]?.serverId;
-
-	const [deploying, setDeploying] = useState<Deploying | null>(null);
-	const [starting, setStarting] = useState<string | null>(null);
-
-	const { mutateAsync: deployNginx } =
-		api.application.deployNginxQuickstart.useMutation();
-	const { mutateAsync: deployTemplate } =
-		api.compose.deployTemplate.useMutation();
-	const { mutateAsync: deployCompose } = api.compose.deploy.useMutation();
-	const utils = api.useUtils();
-
-	const { data: application } = api.application.one.useQuery(
-		{ applicationId: deploying?.id ?? "" },
-		{
-			enabled: deploying?.kind === "app",
-			refetchInterval: (query) => {
-				const status = query.state.data?.applicationStatus;
-				return status === "done" || status === "error" ? false : 2500;
-			},
-		},
-	);
-	const { data: compose } = api.compose.one.useQuery(
-		{ composeId: deploying?.id ?? "" },
-		{
-			enabled: deploying?.kind === "template",
-			refetchInterval: (query) => {
-				const status = query.state.data?.composeStatus;
-				return status === "done" || status === "error" ? false : 2500;
-			},
-		},
-	);
-
-	const status =
-		deploying?.kind === "app"
-			? application?.applicationStatus
-			: compose?.composeStatus;
-
-	if (!environmentId || (isCloud && !serverId)) {
-		return (
-			<div className="flex flex-col gap-8">
-				<div className="flex flex-col gap-4">
-					<span className="font-mono text-xs uppercase tracking-[0.2em] text-primary">
-						First deploy
-					</span>
-					<h1 className={titleClassName}>Deploy something.</h1>
-				</div>
-				<AlertBlock type="info" className="max-w-md">
-					{isCloud
-						? "You'll need a project and a connected server before deploying — you can do that anytime from the dashboard."
-						: "You'll need a project before deploying — you can do that anytime from the dashboard."}
-				</AlertBlock>
-				<Button onClick={onNext} className="w-fit px-8">
-					Continue
-				</Button>
-			</div>
-		);
-	}
-
-	const handleNginx = async () => {
-		setStarting("nginx");
-		try {
-			const res = await deployNginx({ environmentId, serverId });
-			setDeploying({ kind: "app", id: res.applicationId, url: res.domainUrl });
-		} catch (error) {
-			toast.error(
-				error instanceof Error ? error.message : "Error deploying the app",
-			);
-		} finally {
-			setStarting(null);
-		}
-	};
-
-	const handleTemplate = async (id: string) => {
-		setStarting(id);
-		try {
-			const composeResult = await deployTemplate({
-				environmentId,
-				serverId,
-				id,
-			});
-			await deployCompose({ composeId: composeResult.composeId });
-			const domains = await utils.domain.byComposeId.fetch({
-				composeId: composeResult.composeId,
-			});
-			const host = domains?.[0]?.host;
-			setDeploying({
-				kind: "template",
-				id: composeResult.composeId,
-				url: host ? `http://${host}` : "",
-			});
-		} catch (error) {
-			toast.error(
-				error instanceof Error ? error.message : "Error deploying the template",
-			);
-		} finally {
-			setStarting(null);
-		}
-	};
-
-	if (deploying) {
-		const isDone = status === "done";
-		const isError = status === "error";
-
-		return (
-			<div className="flex flex-col gap-8">
-				<div className="flex flex-col gap-4">
-					<span
-						className={`font-mono text-xs uppercase tracking-[0.2em] flex items-center gap-2 ${
-							isError ? "text-destructive" : "text-primary"
-						}`}
-					>
-						{isDone ? (
-							<CheckCircle2 className="size-3.5" />
-						) : isError ? (
-							<XCircleIcon className="size-3.5" />
-						) : (
-							<Loader2 className="size-3.5 animate-spin" />
-						)}
-						{isDone ? "Live" : isError ? "Deploy failed" : "Deploying"}
-					</span>
-					<h1 className={titleClassName}>
-						{isDone
-							? "It's live."
-							: isError
-								? "Something went wrong."
-								: "Building your app..."}
-					</h1>
-					<p className="text-muted-foreground text-lg max-w-md leading-relaxed">
-						{isDone
-							? "Your app is up and reachable at:"
-							: isError
-								? "The deployment failed — you can check the logs from the dashboard later."
-								: "This usually takes a minute or two the first time."}
-					</p>
-				</div>
-
-				{isDone && deploying.url ? (
-					<div className="flex flex-col rounded-2xl border overflow-hidden max-w-md">
-						<div className="flex items-center gap-2 px-5 py-3 border-b bg-muted/30">
-							<span className="size-2 rounded-full bg-green-500 shrink-0" />
-							<span className="font-mono text-xs text-muted-foreground">
-								Reachable now
-							</span>
-						</div>
-						<div className="flex items-center justify-between gap-3 p-5">
-							<span className="font-mono text-sm truncate">
-								{deploying.url}
-							</span>
-							<div className="flex items-center gap-1 shrink-0">
-								<Button
-									variant="ghost"
-									size="icon"
-									onClick={() => {
-										copy(deploying.url);
-										toast.success("Copied to clipboard");
-									}}
-								>
-									<CopyIcon className="size-4" />
-								</Button>
-								<Button variant="ghost" size="icon" asChild>
-									<a href={deploying.url} target="_blank" rel="noreferrer">
-										<ArrowUpRightIcon className="size-4" />
-									</a>
-								</Button>
-							</div>
-						</div>
-					</div>
-				) : !isDone && !isError ? (
-					<div className="rounded-2xl border p-5 max-w-md">
-						<div className="flex items-center gap-3 text-sm text-muted-foreground">
-							<Loader2 className="size-4 animate-spin shrink-0" />
-							Waiting for the build to finish...
-						</div>
-					</div>
-				) : null}
-
-				<Button
-					onClick={onNext}
-					className="w-fit px-8"
-					disabled={!isDone && !isError}
-				>
-					Continue
-				</Button>
-			</div>
-		);
-	}
-
-	return (
-		<div className="flex flex-col gap-10">
-			<div className="flex flex-col gap-4">
-				<span className="font-mono text-xs uppercase tracking-[0.2em] text-primary">
-					First deploy
-				</span>
-				<h1 className={titleClassName}>Ship something.</h1>
-				<p className="text-muted-foreground text-lg max-w-md leading-relaxed">
-					Pick a quickstart — we'll generate a domain and deploy it for you.
-				</p>
-			</div>
-
-			<div className="grid grid-cols-1 sm:grid-cols-2 gap-px bg-border rounded-2xl overflow-hidden border">
-				<button
-					type="button"
-					onClick={handleNginx}
-					disabled={!!starting}
-					className="flex flex-col items-start justify-between gap-8 bg-background p-7 text-left hover:bg-muted/40 transition-colors disabled:opacity-60"
-				>
-					<div>
-						<p className="font-medium">Simple app</p>
-						<p className="text-sm text-muted-foreground mt-1">
-							A "Hello World" demo app, live in seconds.
-						</p>
-					</div>
-					<span className="font-mono text-xs uppercase tracking-wider text-muted-foreground flex items-center gap-2">
-						{starting === "nginx" ? (
-							<>
-								<Loader2 className="size-3.5 animate-spin" />
-								Starting...
-							</>
-						) : (
-							"Deploy now →"
-						)}
-					</span>
-				</button>
-
-				<div className="flex flex-col justify-between gap-8 bg-background p-7">
-					<div>
-						<p className="font-medium">Docker Compose template</p>
-						<p className="text-sm text-muted-foreground mt-1">
-							Popular open source stacks, one click away.
-						</p>
-					</div>
-					<div className="flex flex-col gap-2">
-						{CURATED_TEMPLATES.map((template) => (
-							<Button
-								key={template.id}
-								variant="outline"
-								size="sm"
-								disabled={!!starting}
-								isLoading={starting === template.id}
-								onClick={() => handleTemplate(template.id)}
-								className="justify-start"
-							>
-								<img
-									src={`https://templates.dokploy.com/blueprints/${template.id}/${template.logo}`}
-									alt={template.name}
-									className="size-4 object-contain shrink-0"
-								/>
-								{template.name}
-							</Button>
-						))}
-					</div>
-				</div>
-			</div>
-		</div>
-	);
-};

apps/dokploy/components/dashboard/onboarding/steps/plan-step.tsx

@@ -1,188 +0,0 @@
-import { loadStripe } from "@stripe/stripe-js";
-import { ArrowRightIcon, CheckIcon } from "lucide-react";
-import { useState } from "react";
-import { toast } from "sonner";
-import {
-	calculatePriceHobby,
-	calculatePriceStartup,
-	STARTUP_SERVERS_INCLUDED,
-} from "@/components/dashboard/settings/billing/show-billing";
-import { Button } from "@/components/ui/button";
-import { api } from "@/utils/api";
-import { displayFont } from "../font";
-
-const stripePromise = loadStripe(
-	process.env.NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY!,
-);
-
-type Tier = "hobby" | "startup";
-
-const PLANS: {
-	tier: Tier;
-	name: string;
-	description: string;
-	price: number;
-	features: string[];
-	recommended?: boolean;
-}[] = [
-	{
-		tier: "hobby",
-		name: "Hobby",
-		description: "For individual developers",
-		price: calculatePriceHobby(1, false),
-		features: [
-			"Setup 1 server",
-			"Unlimited apps & databases",
-			"2 environments",
-			"Community support",
-		],
-	},
-	{
-		tier: "startup",
-		name: "Startup",
-		description: "For small to mid-size teams",
-		price: calculatePriceStartup(STARTUP_SERVERS_INCLUDED, false),
-		recommended: true,
-		features: [
-			`Setup up to ${STARTUP_SERVERS_INCLUDED} servers`,
-			"Unlimited users & environments",
-			"Basic RBAC + 2FA",
-			"Email & chat support",
-		],
-	},
-];
-
-interface Props {
-	onNext: () => void;
-}
-
-export const PlanStep = ({ onNext }: Props) => {
-	const [loading, setLoading] = useState<
-		`${"trial" | "checkout"}:${Tier}` | null
-	>(null);
-	const { data } = api.stripe.getProducts.useQuery();
-	const { mutateAsync: createCheckoutSession } =
-		api.stripe.createCheckoutSession.useMutation();
-	const { mutateAsync: startFreeTrial } =
-		api.stripe.startFreeTrial.useMutation();
-	const utils = api.useUtils();
-
-	const handleCheckout = async (tier: Tier) => {
-		if (!data) return;
-		const productId =
-			tier === "hobby" ? data.hobbyProductId : data.startupProductId;
-		if (!productId) return;
-		setLoading(`checkout:${tier}`);
-		try {
-			const stripe = await stripePromise;
-			const session = await createCheckoutSession({
-				tier,
-				productId,
-				serverQuantity: tier === "startup" ? STARTUP_SERVERS_INCLUDED : 1,
-				isAnnual: false,
-			});
-			await stripe?.redirectToCheckout({ sessionId: session.sessionId });
-		} catch {
-			toast.error("Error starting checkout");
-			setLoading(null);
-		}
-	};
-
-	const handleTrial = async (tier: Tier) => {
-		setLoading(`trial:${tier}`);
-		try {
-			await startFreeTrial({ tier });
-			await utils.project.onboardingStatus.invalidate();
-			toast.success("Your 7-day trial has started");
-			onNext();
-		} catch (error) {
-			toast.error(
-				error instanceof Error ? error.message : "Error starting trial",
-			);
-		} finally {
-			setLoading(null);
-		}
-	};
-
-	return (
-		<div className="flex flex-col gap-10">
-			<div className="flex flex-col gap-4">
-				<span className="font-mono text-xs uppercase tracking-[0.2em] text-primary">
-					Billing
-				</span>
-				<h1
-					className={`${displayFont.className} text-4xl sm:text-5xl leading-[1.05] tracking-tight`}
-				>
-					Start free, upgrade when ready.
-				</h1>
-				<p className="text-muted-foreground text-lg max-w-md leading-relaxed">
-					Try any plan free for 7 days. No credit card required — add one only
-					if you decide to stay.
-				</p>
-			</div>
-
-			<div className="grid grid-cols-1 sm:grid-cols-2 gap-px bg-border rounded-2xl overflow-hidden border">
-				{PLANS.map((plan) => {
-					const productId =
-						plan.tier === "hobby"
-							? data?.hobbyProductId
-							: data?.startupProductId;
-					return (
-						<div
-							key={plan.tier}
-							className="flex flex-col justify-between gap-6 bg-background p-7"
-						>
-							<div>
-								{plan.recommended && (
-									<span className="inline-flex items-center rounded-full bg-primary text-primary-foreground font-mono text-[10px] font-semibold uppercase tracking-[0.15em] px-2.5 py-1 mb-3">
-										Recommended
-									</span>
-								)}
-								<p className="font-medium">{plan.name}</p>
-								<p className="text-sm text-muted-foreground mt-1">
-									{plan.description}
-								</p>
-								<p className="text-3xl font-semibold mt-4 tabular-nums">
-									${plan.price.toFixed(2)}
-									<span className="text-sm font-normal text-muted-foreground">
-										{" "}
-										/mo
-									</span>
-								</p>
-								<ul className="flex flex-col gap-1.5 mt-4">
-									{plan.features.map((f) => (
-										<li
-											key={f}
-											className="flex items-center gap-2 text-sm text-muted-foreground"
-										>
-											<CheckIcon className="size-3.5 shrink-0" />
-											{f}
-										</li>
-									))}
-								</ul>
-							</div>
-							<div className="flex flex-col gap-2">
-								<Button
-									isLoading={loading === `trial:${plan.tier}`}
-									disabled={loading !== null}
-									onClick={() => handleTrial(plan.tier)}
-								>
-									Start 7-day free trial
-									<ArrowRightIcon className="size-4" />
-								</Button>
-								<Button
-									variant="outline"
-									isLoading={loading === `checkout:${plan.tier}`}
-									disabled={loading !== null || !productId}
-									onClick={() => handleCheckout(plan.tier)}
-								>
-									Subscribe now
-								</Button>
-							</div>
-						</div>
-					);
-				})}
-			</div>
-		</div>
-	);
-};

apps/dokploy/components/dashboard/onboarding/steps/project-step.tsx

@@ -1,118 +0,0 @@
-import { standardSchemaResolver as zodResolver } from "@hookform/resolvers/standard-schema";
-import { useForm } from "react-hook-form";
-import { toast } from "sonner";
-import { z } from "zod";
-import { Button } from "@/components/ui/button";
-import {
-	Form,
-	FormControl,
-	FormField,
-	FormItem,
-	FormLabel,
-	FormMessage,
-} from "@/components/ui/form";
-import { Input } from "@/components/ui/input";
-import { Textarea } from "@/components/ui/textarea";
-import { api } from "@/utils/api";
-import { displayFont } from "../font";
-
-const schema = z.object({
-	name: z.string().min(1, "Name is required"),
-	description: z.string().optional(),
-});
-type Schema = z.infer<typeof schema>;
-
-interface Props {
-	onNext: (project: { projectId: string; environmentId: string }) => void;
-	/** Drops the onboarding wizard's display serif for callers (e.g. the
-	 * post-checkout welcome modal) that want the app's regular typography. */
-	plainTitle?: boolean;
-}
-
-export const ProjectStep = ({ onNext, plainTitle }: Props) => {
-	const titleClassName = plainTitle
-		? "text-xl font-semibold tracking-tight"
-		: `${displayFont.className} text-4xl sm:text-5xl leading-[1.05] tracking-tight`;
-	const { mutateAsync, isPending } = api.project.create.useMutation();
-	const utils = api.useUtils();
-
-	const form = useForm<Schema>({
-		defaultValues: { name: "My First Project", description: "" },
-		resolver: zodResolver(schema),
-	});
-
-	const onSubmit = async (data: Schema) => {
-		try {
-			const result = await mutateAsync(data);
-			await utils.project.all.invalidate();
-			toast.success("Project created");
-			onNext({
-				projectId: result.project.projectId,
-				environmentId: result.environment?.environmentId ?? "",
-			});
-		} catch (error) {
-			toast.error(
-				error instanceof Error ? error.message : "Error creating the project",
-			);
-		}
-	};
-
-	return (
-		<div className="flex flex-col gap-10">
-			<div className="flex flex-col gap-4">
-				<span className="font-mono text-xs uppercase tracking-[0.2em] text-primary">
-					Workspace
-				</span>
-				<h1 className={titleClassName}>Create your first project.</h1>
-				<p className="text-muted-foreground text-lg max-w-md leading-relaxed">
-					Projects group your apps, databases, and environments together.
-				</p>
-			</div>
-
-			<Form {...form}>
-				<form
-					onSubmit={form.handleSubmit(onSubmit)}
-					className="flex flex-col gap-5 max-w-sm"
-				>
-					<FormField
-						control={form.control}
-						name="name"
-						render={({ field }) => (
-							<FormItem>
-								<FormLabel>Name</FormLabel>
-								<FormControl>
-									<Input placeholder="My First Project" {...field} />
-								</FormControl>
-								<FormMessage />
-							</FormItem>
-						)}
-					/>
-					<FormField
-						control={form.control}
-						name="description"
-						render={({ field }) => (
-							<FormItem>
-								<FormLabel>Description (optional)</FormLabel>
-								<FormControl>
-									<Textarea
-										placeholder="What is this project for?"
-										className="resize-none"
-										{...field}
-									/>
-								</FormControl>
-								<FormMessage />
-							</FormItem>
-						)}
-					/>
-					<Button
-						type="submit"
-						isLoading={isPending}
-						className="w-fit px-8 mt-2"
-					>
-						Create project
-					</Button>
-				</form>
-			</Form>
-		</div>
-	);
-};

apps/dokploy/components/dashboard/onboarding/steps/server-step.tsx

@@ -1,362 +0,0 @@
-import { standardSchemaResolver as zodResolver } from "@hookform/resolvers/standard-schema";
-import copy from "copy-to-clipboard";
-import {
-	CheckCircle2,
-	CopyIcon,
-	InfoIcon,
-	Loader2,
-	XCircle,
-} from "lucide-react";
-import { useEffect, useRef, useState } from "react";
-import { useForm } from "react-hook-form";
-import { toast } from "sonner";
-import { z } from "zod";
-import { AlertBlock } from "@/components/shared/alert-block";
-import { Button } from "@/components/ui/button";
-import {
-	Form,
-	FormControl,
-	FormField,
-	FormItem,
-	FormLabel,
-	FormMessage,
-} from "@/components/ui/form";
-import { Input } from "@/components/ui/input";
-import { api } from "@/utils/api";
-import { displayFont } from "../font";
-
-const schema = z.object({
-	name: z.string().min(1, "Name is required"),
-	ipAddress: z
-		.string()
-		.min(1, "IP address is required")
-		.refine((value) => !/\s/.test(value), "IP address cannot contain spaces"),
-});
-type Schema = z.infer<typeof schema>;
-
-interface Props {
-	onNext: () => void;
-	/** Drops the onboarding wizard's display serif for callers (e.g. the
-	 * post-checkout welcome modal) that want the app's regular typography. */
-	plainTitle?: boolean;
-}
-
-const StatusRow = ({
-	label,
-	ok,
-	pending,
-}: {
-	label: string;
-	ok?: boolean;
-	pending?: boolean;
-}) => (
-	<div className="flex items-center gap-2 text-sm">
-		{ok ? (
-			<CheckCircle2 className="size-4 text-green-600 dark:text-green-500 shrink-0" />
-		) : pending ? (
-			<Loader2 className="size-4 text-muted-foreground shrink-0 animate-spin" />
-		) : (
-			<XCircle className="size-4 text-muted-foreground shrink-0" />
-		)}
-		<span className={ok ? "" : "text-muted-foreground"}>{label}</span>
-	</div>
-);
-
-export const ServerStep = ({ onNext, plainTitle }: Props) => {
-	const titleClassName = plainTitle
-		? "text-xl font-semibold tracking-tight"
-		: `${displayFont.className} text-4xl sm:text-5xl leading-[1.05] tracking-tight`;
-
-	const { data: sshKeys, refetch: refetchSSHKeys } = api.sshKey.all.useQuery();
-	const generateSSHKey = api.sshKey.generate.useMutation();
-	const createSSHKey = api.sshKey.create.useMutation();
-	const hasCreatedKey = useRef(false);
-
-	const cloudSSHKey = sshKeys?.find(
-		(sshKey) => sshKey.name === "dokploy-onboarding-ssh-key",
-	);
-
-	useEffect(() => {
-		const ensureKey = async () => {
-			if (!sshKeys || cloudSSHKey || hasCreatedKey.current) return;
-			hasCreatedKey.current = true;
-			try {
-				const keys = await generateSSHKey.mutateAsync({ type: "rsa" });
-				await createSSHKey.mutateAsync({
-					name: "dokploy-onboarding-ssh-key",
-					description: "Used during onboarding",
-					privateKey: keys.privateKey,
-					publicKey: keys.publicKey,
-					organizationId: "",
-				});
-				await refetchSSHKeys();
-			} catch {
-				hasCreatedKey.current = false;
-			}
-		};
-		ensureKey();
-	}, [sshKeys]);
-
-	const { data: existingServers } = api.server.all.useQuery();
-	const [createdServerId, setCreatedServerId] = useState<string | null>(null);
-
-	useEffect(() => {
-		if (!createdServerId && existingServers && existingServers.length > 0) {
-			setCreatedServerId(existingServers[0]!.serverId);
-		}
-	}, [existingServers, createdServerId]);
-
-	const { data: canCreateMoreServers } =
-		api.stripe.canCreateMoreServers.useQuery();
-	const { mutateAsync: createServer, isPending: isCreating } =
-		api.server.create.useMutation();
-	const checkIsReady = (validation?: {
-		docker?: { enabled?: boolean };
-		isDokployNetworkInstalled?: boolean;
-	}) =>
-		!!validation?.docker?.enabled && !!validation?.isDokployNetworkInstalled;
-
-	const {
-		data: validation,
-		refetch: refetchValidation,
-		isFetching: isValidating,
-	} = api.server.validate.useQuery(
-		{ serverId: createdServerId ?? "" },
-		{
-			enabled: !!createdServerId,
-			refetchInterval: (query) =>
-				checkIsReady(query.state.data) ? false : 5000,
-		},
-	);
-	const isReady = checkIsReady(validation);
-
-	const [isSettingUp, setIsSettingUp] = useState(false);
-	const hasStartedSetup = useRef(false);
-
-	useEffect(() => {
-		if (createdServerId && !hasStartedSetup.current && !isReady) {
-			hasStartedSetup.current = true;
-			setIsSettingUp(true);
-		}
-	}, [createdServerId, isReady]);
-
-	useEffect(() => {
-		if (!isSettingUp) return;
-		const timeout = setTimeout(() => {
-			setIsSettingUp(false);
-			toast.error(
-				"Setup is taking too long — check the server is reachable, then try again.",
-			);
-		}, 120_000);
-		return () => clearTimeout(timeout);
-	}, [isSettingUp]);
-
-	api.server.setupWithLogs.useSubscription(
-		{ serverId: createdServerId ?? "" },
-		{
-			enabled: !!createdServerId && isSettingUp,
-			onData(log) {
-				if (typeof log === "string" && log.includes("Setup Server:")) {
-					setIsSettingUp(false);
-					refetchValidation();
-				}
-			},
-			onError(error) {
-				setIsSettingUp(false);
-				toast.error("Error setting up the server");
-				console.error(error);
-			},
-		},
-	);
-
-	const form = useForm<Schema>({
-		defaultValues: { name: "My First Server", ipAddress: "" },
-		resolver: zodResolver(schema),
-	});
-
-	const onSubmit = async (data: Schema) => {
-		if (!cloudSSHKey) {
-			toast.error("Still generating your SSH key, try again in a moment");
-			return;
-		}
-		try {
-			const server = await createServer({
-				name: data.name,
-				description: "",
-				ipAddress: data.ipAddress.trim(),
-				port: 22,
-				username: "root",
-				sshKeyId: cloudSSHKey.sshKeyId,
-				serverType: "deploy",
-				enableDockerCleanup: false,
-			});
-			setCreatedServerId(server.serverId);
-		} catch (error) {
-			toast.error(
-				error instanceof Error ? error.message : "Error creating the server",
-			);
-		}
-	};
-
-	return (
-		<div className="flex flex-col gap-10">
-			<div className="flex flex-col gap-4">
-				<span className="font-mono text-xs uppercase tracking-[0.2em] text-primary">
-					Infrastructure
-				</span>
-				<h1 className={titleClassName}>Connect a server.</h1>
-				<p className="text-muted-foreground text-lg max-w-md leading-relaxed">
-					Dokploy deploys to servers you own. Buy one from any VPS provider
-					(Hetzner, DigitalOcean, Hostinger...) and paste its IP below.
-				</p>
-				<div className="flex items-start gap-2.5 rounded-lg border p-3 max-w-md">
-					<InfoIcon className="size-4 text-muted-foreground shrink-0 mt-0.5" />
-					<div className="flex flex-col gap-0.5">
-						<span className="text-sm font-medium">Requirements</span>
-						<span className="text-sm text-muted-foreground">
-							To ensure a smooth experience with Dokploy, your server should
-							have at least 1GB of RAM and 30GB of disk space.
-						</span>
-					</div>
-				</div>
-			</div>
-
-			{!createdServerId ? (
-				<div className="flex flex-col gap-4 max-w-sm">
-					{canCreateMoreServers === false && (
-						<AlertBlock type="warning">
-							You'll need a plan or trial before connecting a server — go back
-							to the "Pick a plan" step.
-						</AlertBlock>
-					)}
-					<div className="flex flex-col gap-2 rounded-lg border p-3">
-						<span className="text-xs font-medium text-muted-foreground">
-							1. Run this on your server to authorize Dokploy
-						</span>
-						<div className="flex items-center gap-2">
-							<code className="flex-1 min-w-0 truncate rounded bg-muted px-2 py-1.5 text-xs">
-								{cloudSSHKey
-									? `echo "${cloudSSHKey.publicKey}" >> ~/.ssh/authorized_keys`
-									: "Generating..."}
-							</code>
-							{cloudSSHKey && (
-								<button
-									type="button"
-									onClick={() => {
-										copy(
-											`echo "${cloudSSHKey.publicKey}" >> ~/.ssh/authorized_keys`,
-										);
-										toast.success("Copied to clipboard");
-									}}
-								>
-									<CopyIcon className="size-4 text-muted-foreground" />
-								</button>
-							)}
-						</div>
-					</div>
-
-					<Form {...form}>
-						<form
-							onSubmit={form.handleSubmit(onSubmit)}
-							className="flex flex-col gap-4"
-						>
-							<FormField
-								control={form.control}
-								name="name"
-								render={({ field }) => (
-									<FormItem>
-										<FormLabel>Server name</FormLabel>
-										<FormControl>
-											<Input placeholder="My First Server" {...field} />
-										</FormControl>
-										<FormMessage />
-									</FormItem>
-								)}
-							/>
-							<FormField
-								control={form.control}
-								name="ipAddress"
-								render={({ field }) => (
-									<FormItem>
-										<FormLabel>2. IP address</FormLabel>
-										<FormControl>
-											<Input placeholder="192.168.1.100" {...field} />
-										</FormControl>
-										<FormMessage />
-									</FormItem>
-								)}
-							/>
-							<Button
-								type="submit"
-								isLoading={isCreating}
-								disabled={!cloudSSHKey || canCreateMoreServers === false}
-								className="mt-2"
-							>
-								Connect server
-							</Button>
-						</form>
-					</Form>
-				</div>
-			) : (
-				<div className="flex flex-col gap-4 w-full max-w-sm">
-					<div className="flex flex-col gap-3 rounded-lg border p-4">
-						{isSettingUp ? (
-							<div className="flex items-center justify-center gap-3 py-4 text-sm text-muted-foreground">
-								<Loader2 className="size-4 animate-spin shrink-0" />
-								Setting up your server – installing Docker and dependencies…
-							</div>
-						) : isValidating && !validation ? (
-							<div className="flex items-center justify-center gap-2 py-4 text-sm text-muted-foreground">
-								<Loader2 className="size-4 animate-spin" />
-								Checking your server...
-							</div>
-						) : (
-							<>
-								<StatusRow
-									label="Docker installed"
-									ok={validation?.docker?.enabled}
-									pending={!validation?.docker?.enabled && !isReady}
-								/>
-								<StatusRow
-									label="Dokploy network created"
-									ok={validation?.isDokployNetworkInstalled}
-									pending={!validation?.isDokployNetworkInstalled && !isReady}
-								/>
-							</>
-						)}
-					</div>
-					{!isReady && !isSettingUp && (
-						<AlertBlock type="info">
-							Setup runs after the server boots and this page checks for it
-							automatically. You can retry setup, or use "Skip for now" above to
-							continue and come back to this later.
-						</AlertBlock>
-					)}
-					<div className="flex gap-2">
-						<Button
-							variant="secondary"
-							className="flex-1"
-							isLoading={isValidating || isSettingUp}
-							onClick={() => {
-								if (!isReady && !isSettingUp) {
-									setIsSettingUp(true);
-								} else {
-									refetchValidation();
-								}
-							}}
-						>
-							{!isReady && !isSettingUp ? "Retry setup" : "Check now"}
-						</Button>
-						<Button
-							className="flex-1"
-							disabled={!isReady || isSettingUp}
-							onClick={onNext}
-						>
-							Continue
-						</Button>
-					</div>
-				</div>
-			)}
-		</div>
-	);
-};

apps/dokploy/components/dashboard/onboarding/steps/welcome-step.tsx

@@ -1,71 +0,0 @@
-import { GitBranchIcon, PuzzleIcon, ServerIcon } from "lucide-react";
-import { Button } from "@/components/ui/button";
-import { displayFont } from "../font";
-
-interface Props {
-	onNext: () => void;
-}
-
-const points = [
-	{
-		icon: GitBranchIcon,
-		title: "Deploy from Git or Docker",
-		description:
-			"Push a repo, a compose file, or a container image and go live.",
-	},
-	{
-		icon: PuzzleIcon,
-		title: "One-click templates",
-		description:
-			"WordPress, databases, and dozens of open source apps, pre-wired.",
-	},
-	{
-		icon: ServerIcon,
-		title: "Your own servers",
-		description: "Runs on infrastructure you control — no vendor lock-in.",
-	},
-];
-
-export const WelcomeStep = ({ onNext }: Props) => {
-	return (
-		<div className="flex flex-col gap-12">
-			<div className="flex flex-col gap-4">
-				<span className="font-mono text-xs uppercase tracking-[0.2em] text-primary">
-					Welcome
-				</span>
-				<h1
-					className={`${displayFont.className} text-4xl sm:text-5xl leading-[1.05] tracking-tight`}
-				>
-					Let's get your first app <em className="not-italic">live</em>.
-				</h1>
-				<p className="text-muted-foreground text-lg max-w-md leading-relaxed">
-					It just takes a few steps: pick a plan, connect a server, ship
-					something. You'll have a working URL by the end.
-				</p>
-			</div>
-
-			<dl className="flex flex-col divide-y">
-				{points.map((point, index) => (
-					<div key={point.title} className="flex gap-6 py-5 first:pt-0">
-						<dt className="font-mono text-xs text-muted-foreground pt-1 shrink-0 w-6">
-							{String(index + 1).padStart(2, "0")}
-						</dt>
-						<dd className="flex flex-col gap-1">
-							<span className="font-medium flex items-center gap-2">
-								<point.icon className="size-4 text-muted-foreground" />
-								{point.title}
-							</span>
-							<span className="text-sm text-muted-foreground">
-								{point.description}
-							</span>
-						</dd>
-					</div>
-				))}
-			</dl>
-
-			<Button size="lg" onClick={onNext} className="w-fit px-8">
-				Get started
-			</Button>
-		</div>
-	);
-};

apps/dokploy/components/dashboard/organization/handle-organization.tsx

@@ -1,11 +1,9 @@
 import { standardSchemaResolver as zodResolver } from "@hookform/resolvers/standard-schema";
-
-import { PenBoxIcon, Plus, X } from "lucide-react";
-import { useEffect, useRef, useState } from "react";
+import { PenBoxIcon, Plus } from "lucide-react";
+import { useEffect, useState } from "react";
 import { useForm } from "react-hook-form";
 import { toast } from "sonner";
 import { z } from "zod";
-import { Logo } from "@/components/shared/logo";
 import { Button } from "@/components/ui/button";
 import {
 	Dialog,
@@ -16,7 +14,7 @@ import {
 	DialogTitle,
 	DialogTrigger,
 } from "@/components/ui/dialog";
-import { Dropzone } from "@/components/ui/dropzone";
+import { DropdownMenuItem } from "@/components/ui/dropdown-menu";
 import {
 	Form,
 	FormControl,
@@ -27,8 +25,6 @@ import {
 } from "@/components/ui/form";
 import { Input } from "@/components/ui/input";
 import { api } from "@/utils/api";
-import { resizeImage } from "@/utils/image-processing";
-import { sanitizeSvg } from "@/utils/sanitize-svg";
 
 const organizationSchema = z.object({
 	name: z.string().min(1, {
@@ -42,24 +38,10 @@ type OrganizationFormValues = z.infer<typeof organizationSchema>;
 interface Props {
 	organizationId?: string;
 	children?: React.ReactNode;
-	open?: boolean;
-	onOpenChange?: (open: boolean) => void;
 }
 
-export function AddOrganization({
-	organizationId,
-	open: controlledOpen,
-	onOpenChange: controlledOnOpenChange,
-}: Props) {
-	const [internalOpen, setInternalOpen] = useState(false);
-	const [uploadedFileName, setUploadedFileName] = useState<string | null>(null);
-	const [isUploading, setIsUploading] = useState(false);
-	const uploadCounter = useRef(0);
-	const isControlled = controlledOpen !== undefined;
-	const open = isControlled ? controlledOpen : internalOpen;
-	const setOpen = isControlled
-		? controlledOnOpenChange || (() => {})
-		: setInternalOpen;
+export function AddOrganization({ organizationId }: Props) {
+	const [open, setOpen] = useState(false);
 	const utils = api.useUtils();
 	const { data: organization } = api.organization.one.useQuery(
 		{
@@ -67,7 +49,6 @@ export function AddOrganization({
 		},
 		{
 			enabled: !!organizationId,
-			refetchOnWindowFocus: false,
 		},
 	);
 	const { mutateAsync, isPending } = organizationId
@@ -84,18 +65,14 @@ export function AddOrganization({
 
 	useEffect(() => {
 		if (organization) {
-			uploadCounter.current++;
-			setIsUploading(false);
 			form.reset({
 				name: organization.name,
 				logo: organization.logo || "",
 			});
-			setUploadedFileName(null);
 		}
 	}, [organization, form]);
 
 	const onSubmit = async (values: OrganizationFormValues) => {
-		if (isUploading) return;
 		await mutateAsync({
 			name: values.name,
 			logo: values.logo,
@@ -103,7 +80,6 @@ export function AddOrganization({
 		})
 			.then(() => {
 				form.reset();
-				setUploadedFileName(null);
 				toast.success(
 					`Organization ${organizationId ? "updated" : "created"} successfully`,
 				);
@@ -123,109 +99,20 @@ export function AddOrganization({
 			});
 	};
 
-	const handleFileUpload = async (files: FileList | null) => {
-		if (!files || files.length === 0) return;
-		const file = files[0];
-		if (!file) return;
-
-		const currentUploadId = ++uploadCounter.current;
-		setIsUploading(true);
-
-		const allowedTypes = [
-			"image/jpeg",
-			"image/jpg",
-			"image/png",
-			"image/svg+xml",
-			"image/webp",
-		];
-		const fileExtension = file.name.split(".").pop()?.toLowerCase();
-		const allowedExtensions = ["jpg", "jpeg", "png", "svg", "webp"];
-
-		if (
-			!allowedTypes.includes(file.type) &&
-			!allowedExtensions.includes(fileExtension || "")
-		) {
-			toast.error("Only JPG, JPEG, PNG, WEBP, and SVG files are allowed");
-			setIsUploading(false);
-			return;
-		}
-
-		if (file.size > 2 * 1024 * 1024) {
-			toast.error("Image size must be less than 2MB");
-			setIsUploading(false);
-			return;
-		}
-
-		const isSvg = file.type === "image/svg+xml" || fileExtension === "svg";
-
-		if (isSvg) {
-			try {
-				const text = await file.text();
-				const sanitizedDataUrl = sanitizeSvg(text);
-				if (currentUploadId !== uploadCounter.current) return;
-				if (!sanitizedDataUrl) {
-					toast.error("Invalid SVG file");
-					return;
-				}
-				form.setValue("logo", sanitizedDataUrl);
-				form.trigger("logo");
-				setUploadedFileName(file.name);
-			} catch (error) {
-				if (currentUploadId === uploadCounter.current) {
-					toast.error("Error processing SVG");
-				}
-			} finally {
-				if (currentUploadId === uploadCounter.current) {
-					setIsUploading(false);
-				}
-			}
-			return;
-		}
-
-		// Resize raster images to max 256x256 and convert to WebP to save space
-		try {
-			const resizedDataUrl = await resizeImage(file, 256);
-			if (currentUploadId !== uploadCounter.current) return;
-			form.setValue("logo", resizedDataUrl);
-			form.trigger("logo");
-			setUploadedFileName(file.name);
-		} catch (error) {
-			if (currentUploadId === uploadCounter.current) {
-				toast.error("Error processing image");
-			}
-		} finally {
-			if (currentUploadId === uploadCounter.current) {
-				setIsUploading(false);
-			}
-		}
-	};
-
 	return (
-		<Dialog
-			open={open}
-			onOpenChange={(val) => {
-				if (!val) {
-					uploadCounter.current++;
-					setIsUploading(false);
-				}
-				setOpen(val);
-			}}
-		>
+		<Dialog open={open} onOpenChange={setOpen}>
 			<DialogTrigger asChild>
 				{organizationId ? (
-					<Button
-						type="button"
-						variant="ghost"
-						size="icon"
-						className="group hover:bg-blue-500/10"
-						title="Edit organization"
+					<DropdownMenuItem
+						className="group cursor-pointer hover:bg-blue-500/10"
+						onSelect={(e) => e.preventDefault()}
 					>
 						<PenBoxIcon className="size-3.5 text-primary group-hover:text-blue-500" />
-					</Button>
+					</DropdownMenuItem>
 				) : (
-					<button
-						type="button"
-						className="flex w-full items-center gap-2 rounded-md p-2 text-left text-sm hover:bg-accent hover:text-accent-foreground"
+					<DropdownMenuItem
+						className="gap-2 p-2"
+						onSelect={(e) => e.preventDefault()}
 					>
 						<div className="flex size-6 items-center justify-center rounded-md border bg-background">
 							<Plus className="size-4" />
@@ -233,7 +120,7 @@ export function AddOrganization({
 						<div className="font-medium text-muted-foreground">
 							Add organization
 						</div>
-					</button>
+					</DropdownMenuItem>
 				)}
 			</DialogTrigger>
 			<DialogContent className="sm:max-w-[425px]">
@@ -256,10 +143,8 @@ export function AddOrganization({
 							control={form.control}
 							name="name"
 							render={({ field }) => (
-								<FormItem className="items-center gap-4">
-									<div className="flex items-center justify-between">
-										<FormLabel className="text-right">Name</FormLabel>
-									</div>
+								<FormItem className="tems-center gap-4">
+									<FormLabel className="text-right">Name</FormLabel>
 									<FormControl>
 										<Input
 											placeholder="Organization name"
@@ -274,78 +159,23 @@ export function AddOrganization({
 						<FormField
 							control={form.control}
 							name="logo"
-							render={({ field }) => {
-								const isDataUrl = field.value?.startsWith("data:");
-								const displayValue = isDataUrl
-									? uploadedFileName || "Uploaded image"
-									: field.value || "";
-
-								return (
-									<FormItem className="gap-4">
-										<FormLabel className="text-right">
-											Logo URL or Upload
-										</FormLabel>
-										<FormControl>
-											<div className="col-span-3 flex flex-col gap-3">
-												<div className="flex items-center gap-3">
-													<div className="flex size-10 shrink-0 items-center justify-center rounded-md border bg-muted/50 overflow-hidden">
-														{field.value ? (
-															// biome-ignore lint/performance/noImgElement: user uploaded logo preview
-															<img
-																src={field.value}
-																alt="Logo preview"
-																className="size-full object-cover"
-															/>
-														) : (
-															<Logo className="size-7" />
-														)}
-													</div>
-													<div className="relative flex-1">
-														<Input
-															placeholder="https://example.com/logo.png"
-															{...field}
-															value={displayValue}
-															readOnly={isDataUrl}
-															onChange={(e) => {
-																uploadCounter.current++;
-																setIsUploading(false);
-																field.onChange(e);
-																if (isDataUrl) setUploadedFileName(null);
-															}}
-															className="w-full pr-8"
-														/>
-														{field.value && (
-															<button
-																type="button"
-																onClick={() => {
-																	uploadCounter.current++;
-																	setIsUploading(false);
-																	form.setValue("logo", "");
-																	setUploadedFileName(null);
-																}}
-																className="absolute right-2 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground"
-															>
-																<X className="size-4" />
-															</button>
-														)}
-													</div>
-												</div>
-												<Dropzone
-													dropMessage="Drag & drop a logo or click to upload"
-													accept=".jpg,.jpeg,.png,.svg,.webp,image/jpeg,image/png,image/svg+xml,image/webp"
-													onChange={handleFileUpload}
-													classNameWrapper="border-2 border-dashed border-border hover:border-primary bg-muted/30 hover:bg-muted/50 transition-all rounded-lg"
-													classNameContent="h-32"
-												/>
-											</div>
-										</FormControl>
-										<FormMessage className="col-span-3 col-start-2" />
-									</FormItem>
-								);
-							}}
+							render={({ field }) => (
+								<FormItem className="gap-4">
+									<FormLabel className="text-right">Logo URL</FormLabel>
+									<FormControl>
+										<Input
+											placeholder="https://example.com/logo.png"
+											{...field}
+											value={field.value || ""}
+											className="col-span-3"
+										/>
+									</FormControl>
+									<FormMessage className="col-span-3 col-start-2" />
+								</FormItem>
+							)}
 						/>
 						<DialogFooter>
-							<Button type="submit" isLoading={isPending || isUploading}>
+							<Button type="submit" isLoading={isPending}>
 								{organizationId ? "Update organization" : "Create organization"}
 							</Button>
 						</DialogFooter>

apps/dokploy/components/dashboard/overview/show-overview-backups.tsx

@@ -1,254 +0,0 @@
-import type { OverviewBackup } from "@dokploy/server/services/overview-shared";
-import { getBackupOverviewIcon } from "@dokploy/server/services/overview-shared";
-import {
-	ArrowUpDown,
-	CircuitBoard,
-	GlobeIcon,
-	Loader2,
-	RefreshCw,
-	ServerIcon,
-} from "lucide-react";
-import Link from "next/link";
-import { useMemo, useState } from "react";
-import { DB_ENGINE_ICONS } from "@/components/icons/data-tools-icons";
-import { Badge } from "@/components/ui/badge";
-import { Button } from "@/components/ui/button";
-import { Card } from "@/components/ui/card";
-import {
-	Select,
-	SelectContent,
-	SelectItem,
-	SelectTrigger,
-	SelectValue,
-} from "@/components/ui/select";
-import {
-	Table,
-	TableBody,
-	TableCell,
-	TableHead,
-	TableHeader,
-	TableRow,
-} from "@/components/ui/table";
-import { api } from "@/utils/api";
-
-const STATUS_VARIANT: Record<string, "default" | "destructive" | "secondary"> =
-	{
-		done: "default",
-		running: "secondary",
-		error: "destructive",
-		cancelled: "destructive",
-	};
-
-const renderRowIcon = (row: OverviewBackup) => {
-	const icon = getBackupOverviewIcon(row);
-	if (icon.kind === "db") {
-		const Icon = DB_ENGINE_ICONS[icon.engine as keyof typeof DB_ENGINE_ICONS];
-		return Icon ? <Icon className="h-5 w-5" /> : null;
-	}
-	if (icon.kind === "webServer") {
-		return <ServerIcon className="h-5 w-5 text-muted-foreground" />;
-	}
-	return icon.type === "compose" ? (
-		<CircuitBoard className="h-5 w-5" />
-	) : (
-		<GlobeIcon className="h-5 w-5" />
-	);
-};
-
-const detailHref = (row: OverviewBackup) => {
-	if (!row.projectId || !row.environmentId || !row.serviceOwnerId) return null;
-	return `/dashboard/project/${row.projectId}/environment/${row.environmentId}/services/${row.serviceOwnerType}/${row.serviceOwnerId}`;
-};
-
-export const ShowOverviewBackups = () => {
-	const {
-		data: backups,
-		isFetching,
-		isFetched,
-		isError,
-		refetch,
-	} = api.overview.backups.useQuery(undefined, {
-		staleTime: Number.POSITIVE_INFINITY,
-		refetchOnWindowFocus: false,
-	});
-
-	const [destinationId, setDestinationId] = useState("all");
-	const [serviceOwnerId, setServiceOwnerId] = useState("all");
-	const [sortDirection, setSortDirection] = useState<"asc" | "desc">("desc");
-
-	const destinations = useMemo(() => {
-		if (!backups) return [];
-		const map = new Map<string, string>();
-		for (const row of backups) map.set(row.destinationId, row.destinationName);
-		return Array.from(map.entries()).map(([id, name]) => ({ id, name }));
-	}, [backups]);
-
-	const services = useMemo(() => {
-		if (!backups) return [];
-		const map = new Map<string, string>();
-		for (const row of backups) {
-			if (row.serviceOwnerId) map.set(row.serviceOwnerId, row.serviceName);
-		}
-		return Array.from(map.entries()).map(([id, name]) => ({ id, name }));
-	}, [backups]);
-
-	const rows = useMemo(() => {
-		if (!backups) return [];
-		const filtered = backups.filter(
-			(row) =>
-				(destinationId === "all" || row.destinationId === destinationId) &&
-				(serviceOwnerId === "all" || row.serviceOwnerId === serviceOwnerId),
-		);
-		const sorted = [...filtered].sort(
-			(a, b) =>
-				new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime(),
-		);
-		return sortDirection === "asc" ? sorted : sorted.reverse();
-	}, [backups, destinationId, serviceOwnerId, sortDirection]);
-
-	return (
-		<Card className="bg-sidebar p-2.5 rounded-xl w-full">
-			<div className="rounded-xl bg-background shadow-md p-6 flex flex-col gap-4">
-				<div className="flex flex-wrap items-center gap-3 justify-between">
-					<h3 className="text-lg font-medium">
-						Backups{" "}
-						{isFetched && (
-							<span className="text-sm font-normal text-muted-foreground">
-								({rows.length})
-							</span>
-						)}
-					</h3>
-					<div className="flex flex-wrap items-center gap-2">
-						{isFetched && (
-							<>
-								<Select value={destinationId} onValueChange={setDestinationId}>
-									<SelectTrigger className="w-[180px]">
-										<SelectValue placeholder="Destination" />
-									</SelectTrigger>
-									<SelectContent>
-										<SelectItem value="all">All destinations</SelectItem>
-										{destinations.map((d) => (
-											<SelectItem key={d.id} value={d.id}>
-												{d.name}
-											</SelectItem>
-										))}
-									</SelectContent>
-								</Select>
-								<Select
-									value={serviceOwnerId}
-									onValueChange={setServiceOwnerId}
-								>
-									<SelectTrigger className="w-[180px]">
-										<SelectValue placeholder="Service" />
-									</SelectTrigger>
-									<SelectContent>
-										<SelectItem value="all">All services</SelectItem>
-										{services.map((s) => (
-											<SelectItem key={s.id} value={s.id}>
-												{s.name}
-											</SelectItem>
-										))}
-									</SelectContent>
-								</Select>
-								<Button
-									variant="outline"
-									size="sm"
-									onClick={() =>
-										setSortDirection((d) => (d === "desc" ? "asc" : "desc"))
-									}
-								>
-									<ArrowUpDown className="size-4 mr-2" />
-									{sortDirection === "desc" ? "Newest first" : "Oldest first"}
-								</Button>
-							</>
-						)}
-						<Button onClick={() => refetch()} disabled={isFetching} size="sm">
-							{isFetching ? (
-								<Loader2 className="size-4 animate-spin mr-2" />
-							) : (
-								<RefreshCw className="size-4 mr-2" />
-							)}
-							Refresh
-						</Button>
-					</div>
-				</div>
-
-				{isFetching && !isFetched && (
-					<div className="flex items-center justify-center gap-2 py-16 text-muted-foreground">
-						<Loader2 className="size-4 animate-spin" />
-						Loading backups...
-					</div>
-				)}
-
-				{isFetched && isError && (
-					<div className="flex flex-col items-center justify-center gap-2 py-16 text-muted-foreground">
-						<span>Failed to load backups.</span>
-						<Button variant="outline" size="sm" onClick={() => refetch()}>
-							Retry
-						</Button>
-					</div>
-				)}
-
-				{isFetched && !isError && rows.length === 0 && (
-					<div className="flex items-center justify-center py-16 text-muted-foreground">
-						No backups match the current filters.
-					</div>
-				)}
-
-				{isFetched && !isError && rows.length > 0 && (
-					<Table>
-						<TableHeader>
-							<TableRow>
-								<TableHead>Date</TableHead>
-								<TableHead>Service</TableHead>
-								<TableHead>Destination</TableHead>
-								<TableHead>Kind</TableHead>
-								<TableHead>Status</TableHead>
-							</TableRow>
-						</TableHeader>
-						<TableBody>
-							{rows.map((row) => {
-								const href = detailHref(row);
-								const name = href ? (
-									<Link href={href} className="hover:underline">
-										{row.serviceName}
-									</Link>
-								) : (
-									row.serviceName
-								);
-								return (
-									<TableRow key={row.deploymentId}>
-										<TableCell className="whitespace-nowrap text-sm">
-											{new Date(row.createdAt).toLocaleString()}
-										</TableCell>
-										<TableCell>
-											<div className="flex items-center gap-2">
-												{renderRowIcon(row)}
-												{name}
-											</div>
-										</TableCell>
-										<TableCell>{row.destinationName}</TableCell>
-										<TableCell>
-											<Badge variant="outline">
-												{row.kind === "backup" ? "Database" : "Volume"}
-											</Badge>
-										</TableCell>
-										<TableCell>
-											{row.status && (
-												<Badge
-													variant={STATUS_VARIANT[row.status] ?? "secondary"}
-												>
-													{row.status}
-												</Badge>
-											)}
-										</TableCell>
-									</TableRow>
-								);
-							})}
-						</TableBody>
-					</Table>
-				)}
-			</div>
-		</Card>
-	);
-};

apps/dokploy/components/dashboard/overview/show-overview-deployments.tsx

@@ -1,77 +0,0 @@
-import { Rocket } from "lucide-react";
-import { useRouter } from "next/router";
-import { ShowDeploymentsTable } from "@/components/dashboard/deployments/show-deployments-table";
-import { ShowQueueTable } from "@/components/dashboard/deployments/show-queue-table";
-import {
-	Card,
-	CardDescription,
-	CardHeader,
-	CardTitle,
-} from "@/components/ui/card";
-import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
-
-const SUBTAB_VALUES = ["deployments", "queue"] as const;
-type SubtabValue = (typeof SUBTAB_VALUES)[number];
-const DEFAULT_SUBTAB: SubtabValue = "deployments";
-
-function isValidSubtab(t: string): t is SubtabValue {
-	return SUBTAB_VALUES.includes(t as SubtabValue);
-}
-
-export const ShowOverviewDeployments = () => {
-	const router = useRouter();
-	const subtab =
-		typeof router.query.subtab === "string" &&
-		isValidSubtab(router.query.subtab)
-			? router.query.subtab
-			: DEFAULT_SUBTAB;
-
-	const setSubtab = (value: string) => {
-		if (!isValidSubtab(value)) return;
-		const { subtab: _current, ...query } = router.query;
-		router.replace(
-			{
-				pathname: router.pathname,
-				query: value === DEFAULT_SUBTAB ? query : { ...query, subtab: value },
-			},
-			undefined,
-			{ shallow: true },
-		);
-	};
-
-	return (
-		<Card className="h-full bg-sidebar p-2.5 rounded-xl min-h-[45vh]">
-			<div className="rounded-xl bg-background shadow-md h-full">
-				<CardHeader>
-					<div className="flex flex-col gap-2 sm:flex-row sm:items-center sm:justify-between">
-						<div>
-							<CardTitle className="text-xl font-bold flex items-center gap-2">
-								<Rocket className="size-5" />
-								Deployments
-							</CardTitle>
-							<CardDescription>
-								All application and compose deployments in one place.
-							</CardDescription>
-						</div>
-					</div>
-					<Tabs
-						value={subtab}
-						onValueChange={setSubtab}
-						className="w-full min-w-0"
-					>
-						<TabsList className="mt-2">
-							<TabsTrigger value="deployments">Deployments</TabsTrigger>
-							<TabsTrigger value="queue">Queue</TabsTrigger>
-						</TabsList>
-						<TabsContent value="deployments" className="mt-0 min-w-0 pt-4">
-							<ShowDeploymentsTable />
-						</TabsContent>
-						<TabsContent value="queue" className="mt-0 pt-4">
-							<ShowQueueTable />
-						</TabsContent>
-					</Tabs>
-				</CardHeader>
-			</div>
-		</Card>
-	);
-};