chore: release 1.23.0

Dev

.github/workflows/docker.yml

@@ -73,7 +73,7 @@ jobs:
           tags: ${{ steps.prep.outputs.image }}
           target: ${{ inputs.target }}
           cache-from: type=gha,scope=build-${{ matrix.platform }}
-          cache-to: type=gha,mode=max,scope=build-${{ matrix.platform }}
+          cache-to: type=gha,mode=max,scope=build-${{ matrix.platform }},ignore-error=true
 
       - name: Save image name for manifest
         run: echo "${{ steps.prep.outputs.image }}" > image.txt

CITATION.cff

@@ -33,5 +33,5 @@ keywords:
   - web-ui
   - agent
 license: Apache-2.0
-version: 1.20.3
+version: 1.23.0
 date-released: '2026-03-02'

README.md

@@ -78,6 +78,7 @@ You have 5 ways to install Portabase:
 | **Valkey**         | ✅ Stable  | 7.2+                          | No      |
 | **Firebird**       | ✅ Stable  | 3.0, 4.0, 5.0                 | Yes     |
 | **MSSQL Server**   | ✅ Stable  | 2017, 2019, 2022, Azure SQL         | Yes     |
+| **Docker Volume**  | ✅ Stable  | Docker Engine 20.10+  | Yes |
 
 See the [Database Servers documentation](https://portabase.io/docs/agent/db) for version-specific backup and restore details.
 
@@ -111,4 +112,3 @@ Distributed under the Apache License. See `LICENSE.txt` for more details.
 [ShadcnUI-url]: https://ui.shadcn.com/
 
 [Docker-url]: https://www.docker.com/
-

app/(customer)/dashboard/(admin)/agents/[agentId]/page.tsx

@@ -81,7 +81,7 @@ export default async function RoutePage(
         </PageDescription>
       )}
       <PageContent className="flex flex-col w-full h-full justify-between gap-6">
-        <AgentContentPage agent={agent} edgeKey={edgeKey} />
+        <AgentContentPage agent={agent} edgeKey={edgeKey} canDeleteDatabases={true} />
       </PageContent>
     </Page>
   );

app/(customer)/dashboard/(organization)/projects/[projectId]/database/[databaseId]/page.tsx

@@ -2,7 +2,7 @@ import { PageParams } from "@/types/next";
 import { notFound, redirect } from "next/navigation";
 import { Page } from "@/features/layout/components/page";
 import { db } from "@/db";
-import { eq, and, inArray } from "drizzle-orm";
+import { eq, and, inArray, isNull } from "drizzle-orm";
 import * as drizzleDb from "@/db";
 import { getOrganizationProjectDatabases } from "@/db/services/project";
 import { getActiveMember, getOrganization } from "@/lib/auth/auth";
@@ -49,38 +49,22 @@ export default async function RoutePage(
     redirect("/dashboard/projects");
   }
 
-  const backups = await db.query.backup.findMany({
-    where: eq(drizzleDb.schemas.backup.databaseId, dbItem.id),
-    with: {
-      restorations: true,
-      storages: {
-        with: {
-          storageChannel: true,
-        },
-      },
-      logs: true,
-    },
-    orderBy: (b, { desc }) => [desc(b.createdAt)],
-  });
-
-  const restorations = await db.query.restoration.findMany({
-    where: eq(drizzleDb.schemas.restoration.databaseId, dbItem.id),
-    with: {
-      logs: true,
-    },
-    orderBy: (r, { desc }) => [desc(r.createdAt)],
-  });
-
-  //const isAlreadyBackup = backups.some((b) => b.status === "waiting" || b.status === "ongoing");
-  const isAlreadyRestore = restorations.some((r) => r.status === "waiting");
-
   const totalBackups = await db
     .select({ count: drizzleDb.schemas.backup.id })
     .from(drizzleDb.schemas.backup)
     .where(eq(drizzleDb.schemas.backup.databaseId, dbItem.id))
     .then((rows) => rows.length);
 
-  const availableBackups = backups.filter((b) => !b.deletedAt).length;
+  const availableBackups = await db
+    .select({ count: drizzleDb.schemas.backup.id })
+    .from(drizzleDb.schemas.backup)
+    .where(
+      and(
+        eq(drizzleDb.schemas.backup.databaseId, dbItem.id),
+        isNull(drizzleDb.schemas.backup.deletedAt),
+      ),
+    )
+    .then((rows) => rows.length);
 
   const successfulBackups = await db
     .select({ count: drizzleDb.schemas.backup.id })
@@ -93,6 +77,17 @@ export default async function RoutePage(
     )
     .then((rows) => rows.length);
 
+  const isAlreadyRestore = await db
+    .select({ count: drizzleDb.schemas.restoration.id })
+    .from(drizzleDb.schemas.restoration)
+    .where(
+      and(
+        eq(drizzleDb.schemas.restoration.databaseId, dbItem.id),
+        eq(drizzleDb.schemas.restoration.status, "waiting"),
+      ),
+    )
+    .then((rows) => rows.length > 0);
+
   const [settings] = await db
     .select()
     .from(drizzleDb.schemas.setting)
@@ -109,8 +104,6 @@ export default async function RoutePage(
   const successRate =
     totalBackups > 0 ? (successfulBackups / totalBackups) * 100 : null;
 
-  //const isMember = activeMember?.role === "member";
-
   return (
     <Page>
       <LogsModalProvider>
@@ -121,8 +114,6 @@ export default async function RoutePage(
             database={dbItem}
             databaseHealthLogs={databaseHealthLogs}
             isAlreadyRestore={isAlreadyRestore}
-            restorations={restorations}
-            backups={backups}
             totalBackups={totalBackups}
             availableBackups={availableBackups}
             successRate={successRate}

app/(customer)/dashboard/(organization)/projects/[projectId]/page.tsx

@@ -3,6 +3,7 @@ import { Page, PageContent, PageTitle } from "@/features/layout/components/page"
 import { ButtonDeleteProject } from "@/features/projects/components/project-delete-button";
 import { CardsWithPagination } from "@/components/common/cards-with-pagination";
 import { ProjectDatabaseCard } from "@/features/projects/components/project-database-card";
+import { ProjectDatabaseSelection } from "@/features/projects/components/project-database-selection";
 import { notFound, redirect } from "next/navigation";
 import { db } from "@/db";
 import { eq } from "drizzle-orm";
@@ -87,20 +88,27 @@ export default async function RoutePage(
       </div>
       <PageContent className="flex flex-col w-full h-full">
         {proj.databases.length > 0 ? (
-          <CardsWithPagination
-            data={[...proj.databases].sort(
-              (a, b) =>
-                new Date(b.createdAt).getTime() -
-                new Date(a.createdAt).getTime(),
-            )}
-            organizationSlug={organization.slug}
-            // @ts-ignore
-            cardItem={ProjectDatabaseCard}
-            cardsPerPage={20}
-            numberOfColumns={3}
-            pageSizeOptions={[10, 20, 50]}
-            extendedProps={proj}
-          />
+          isMember ? (
+            <CardsWithPagination
+              data={[...proj.databases].sort(
+                (a, b) =>
+                  new Date(b.createdAt).getTime() -
+                  new Date(a.createdAt).getTime(),
+              )}
+              organizationSlug={organization.slug}
+              // @ts-ignore
+              cardItem={ProjectDatabaseCard}
+              cardsPerPage={20}
+              numberOfColumns={3}
+              pageSizeOptions={[10, 20, 50]}
+              extendedProps={proj}
+            />
+          ) : (
+            <ProjectDatabaseSelection
+              projectId={proj.id}
+              databases={proj.databases}
+            />
+          )
         ) : (
           <div className="flex flex-col items-center justify-center h-full text-muted-foreground py-20">
             <p className="text-lg font-medium">No databases found</p>

app/(customer)/dashboard/(organization)/settings/agents/[agentId]/page.tsx

@@ -94,7 +94,7 @@ export default async function RoutePage(
                 </PageDescription>
             )}
             <PageContent className="flex flex-col w-full h-full justify-between gap-6">
-                <AgentContentPage agent={agent} edgeKey={edgeKey}/>
+                <AgentContentPage agent={agent} edgeKey={edgeKey} canDeleteDatabases={!!agent.organizationId}/>
             </PageContent>
         </Page>
     );

app/(customer)/dashboard/(organization)/settings/page.tsx

@@ -47,7 +47,9 @@ export default async function RoutePage(props: PageParams<{ slug: string }>) {
     const organizationWithMembers = await db.query.organization.findFirst({
         where: eq(drizzleDb.schemas.organization.id, organization.id),
         with: {
-            projects: true,
+            projects: {
+                where: eq(drizzleDb.schemas.project.isArchived, false),
+            },
             members: {
                 with: {
                     user: true,

app/(customer)/dashboard/(organization)/statistics/page.tsx

@@ -29,7 +29,7 @@ export default async function RoutePage(props: PageParams<{}>) {
     if (!org) notFound();
 
     const projects = await db.query.project.findMany({
-        where: eq(drizzleDb.schemas.project.organizationId, org.id),
+        where: and(eq(drizzleDb.schemas.project.organizationId, org.id), eq(drizzleDb.schemas.project.isArchived, false))
     });
 
     const projectIds = projects.map(project => project.id);

app/api/agent/[agentId]/status/route.ts

@@ -1,8 +1,8 @@
 import { NextResponse } from "next/server";
-import { handleDatabases } from "./helpers";
+import { handleDatabases } from "@/features/agents/utils/status/status.helpers";
+import { Body } from "@/features/agents/types";
 import * as drizzleDb from "@/db";
 import { db } from "@/db";
-import { EDbmsSchema } from "@/db/schema/types";
 import { and, eq } from "drizzle-orm";
 import { withUpdatedAt } from "@/db/utils";
 import { logger } from "@/lib/logger";
@@ -10,18 +10,6 @@ import { isUUID } from "@/utils/text";
 
 const log = logger.child({ module: "api/agent/status/route" });
 
-export type databaseAgent = {
-  name: string;
-  dbms: EDbmsSchema;
-  generatedId: string;
-  pingStatus: boolean;
-};
-
-export type Body = {
-  version: string;
-  databases: databaseAgent[];
-};
-
 export async function POST(
   request: Request,
   { params }: { params: Promise<{ agentId: string }> },
@@ -60,7 +48,7 @@ export async function POST(
       .where(eq(drizzleDb.schemas.setting.name, "system"))
       .limit(1);
     if (!settings) {
-      return NextResponse.json({ error: "An error occured" }, { status: 404 });
+      return NextResponse.json({ error: "An error occurred" }, { status: 404 });
     }
 
     const databasesResponse = await handleDatabases(

app/api/tus/hooks/route.ts

@@ -1,11 +1,16 @@
 import {NextResponse} from "next/server";
 import fs from "fs";
 import path from "path";
+import {and, eq} from "drizzle-orm";
+import {db} from "@/db";
+import * as drizzleDb from "@/db";
 import {env} from "@/env.mjs";
 import {logger} from "@/lib/logger";
 
 const log = logger.child({module: "api/tus/hooks"});
 
+const FILE_PATH_RE = /^backups\/\d{4}-\d{2}-\d{2}\/[A-Za-z0-9._-]+$/;
+
 export async function POST(request: Request) {
     try {
         const body = await request.json();
@@ -24,17 +29,61 @@ export async function POST(request: Request) {
                 event.Upload.Offset === event.Upload.Size
             ) {
                 const id = event.Upload.ID;
-                const fileName = headers["X-File-Name"]?.[0];
                 const filePath = headers["X-File-Path"]?.[0];
 
-                if (!filePath) {
-                    return NextResponse.json({error: "Missing X-File-Path"}, {status: 500});
+                if (!filePath || !FILE_PATH_RE.test(filePath)) {
+                    log.warn({filePath}, "Rejected invalid X-File-Path in TUS hook");
+                    return NextResponse.json({error: "Invalid file path"}, {status: 400});
+                }
+
+                const generatedId = headers["X-Generated-Id"]?.[0];
+                const backupStorageId = headers["X-Backup-Storage-Id"]?.[0];
+
+
+                console.log(`Backup Storage ID : ${backupStorageId}`);
+                console.log(`generatedId : ${generatedId}`);
+
+                if (backupStorageId) {
+                    if (!generatedId) {
+                        log.warn("Missing X-Generated-Id in TUS hook");
+                        return NextResponse.json({error: "Forbidden"}, {status: 403});
+                    }
+
+                    const database = await db.query.database.findFirst({
+                        where: eq(drizzleDb.schemas.database.agentDatabaseId, generatedId),
+                    });
+
+                    if (!database) {
+                        log.warn({generatedId}, "No database for X-Generated-Id in TUS hook");
+                        return NextResponse.json({error: "Forbidden"}, {status: 403});
+                    }
+
+                    const storage = await db.query.backupStorage.findFirst({
+                        where: and(
+                            eq(drizzleDb.schemas.backupStorage.id, backupStorageId),
+                        ),
+                        with: {backup: true},
+                    });
+
+                    if (!storage || storage.backup?.databaseId !== database.id) {
+                        log.warn({backupStorageId, generatedId}, "No pending backup storage matches TUS hook");
+                        return NextResponse.json({error: "Forbidden"}, {status: 403});
+                    }
+                } else {
+                    log.warn("TUS hook without X-Backup-Storage-Id (legacy agent)");
                 }
 
                 const uploadDir = path.join(env.PRIVATE_PATH!, "/uploads/");
 
                 const oldFilePath = path.join(uploadDir, "tmp", id);
-                const newFilePath = path.join(uploadDir, filePath);
+
+                const resolvedBase = path.resolve(uploadDir);
+                const newFilePath = path.resolve(resolvedBase, filePath);
+                const rel = path.relative(resolvedBase, newFilePath);
+                if (rel.startsWith("..") || path.isAbsolute(rel)) {
+                    log.warn({filePath}, "Rejected path traversal in TUS hook");
+                    return NextResponse.json({error: "Invalid file path"}, {status: 400});
+                }
 
                 fs.mkdirSync(path.dirname(newFilePath), {recursive: true});
 
@@ -74,7 +123,7 @@ export async function POST(request: Request) {
         }
         return NextResponse.json({});
     } catch (error) {
-        log.error({error: error},"TUS Hook error");
+        log.error({error: error}, "TUS Hook error");
         return NextResponse.json({error: "Internal server error"}, {status: 500});
     }
-}
+}

app/providers.tsx

@@ -14,7 +14,12 @@ const queryClient = new QueryClient();
 export const Providers = (props: ProviderProps) => {
   return (
     <Suspense fallback={null}>
-      <ThemeProvider attribute="class" defaultTheme="system" enableSystem>
+      <ThemeProvider
+        attribute="class"
+        defaultTheme="light"
+        enableSystem
+        storageKey="portabase_theme"
+      >
         <ThemeMetaUpdater />
         <QueryClientProvider client={queryClient}>
           <ErrorLayout>

docker-compose.prod.yml

@@ -1,10 +1,10 @@
 services:
   app:
-    # build:
-    #   context: .
-    #   dockerfile: docker/dockerfile/Dockerfile
-    #   target: prod
-    image: portabase/portabase:1
+    build:
+     context: .
+     dockerfile: docker/dockerfile/Dockerfile
+     target: prod
+#    image: portabase/portabase:1
     ports:
       - "8887:80"
     environment:

docker-compose.yml

@@ -99,12 +99,58 @@ services:
   #   clientEmail: "fake@test.iam.gserviceaccount.com",
   #   privateKey: "unused-when-emulated",
 
+  rustfs:
+    image: rustfs/rustfs:latest
+    container_name: rustfs
+    environment:
+      - RUSTFS_ROOT_USER=admin
+      - RUSTFS_ROOT_PASSWORD=root-password
+      - RUSTFS_ACCESS_KEY=access-key
+      - RUSTFS_SECRET_KEY=secret-key
+      - RUSTFS_VOLUMES=/data
+      - RUSTFS_ADDRESS=:9000
+      - RUSTFS_CONSOLE_ENABLE=true
+      - RUSTFS_CONSOLE_ADDRESS=:9001
+    volumes:
+      - rustfs-data:/data
+    healthcheck:
+      test: [ "CMD", "curl", "-sf", "http://localhost:9000/health" ]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+      start_period: 10s
+    ports:
+      - "9001:9001"
+      - "9000:9000"
+    extra_hosts:
+      - "localhost:host-gateway"
+    networks:
+      - portabase
+
+  rustfs-init:
+    image: rustfs/rc:latest
+    container_name: rustfs-init
+    depends_on:
+      rustfs:
+        condition: service_healthy
+    entrypoint: >
+      /bin/sh -c "
+      until (/usr/bin/rc alias set rustfs http://rustfs:9000 access-key secret-key) do echo '...waiting...' && sleep 1; done;
+      /usr/bin/rc mb rustfs/portabase;
+      echo 'RustFS initialization complete';
+      tail -f /dev/null
+      "
+    networks:
+      - portabase
+
+
 
 volumes:
   postgres-data:
   azurite-data:
   gcs-data:
   gcs-storage:
+  rustfs-data:
 
 networks:
   portabase:

docker/dockerfile/Dockerfile

@@ -1,11 +1,33 @@
-FROM --platform=$BUILDPLATFORM node:22-bullseye AS base
+FROM --platform=$BUILDPLATFORM node:22-slim AS runtime-base
 
-RUN apt-get update && apt-get install -y \
+RUN apt-get update && apt-get install -y --no-install-recommends \
     curl \
     ca-certificates \
     bash \
     tzdata \
     libc6 \
+    nginx \
+    gnupg \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN mkdir -p /etc/apt/keyrings \
+    && curl -fsSL https://www.postgresql.org/media/keys/ACCC4CF8.asc \
+    | gpg --dearmor -o /etc/apt/keyrings/postgresql.gpg \
+    && echo "deb [signed-by=/etc/apt/keyrings/postgresql.gpg] http://apt.postgresql.org/pub/repos/apt bookworm-pgdg main" \
+    > /etc/apt/sources.list.d/pgdg.list
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    postgresql-18 \
+    postgresql-client-18 \
+    postgresql-contrib-18 \
+    && rm -rf /var/lib/apt/lists/*
+
+ENV PATH="/usr/lib/postgresql/18/bin:${PATH}"
+
+
+FROM runtime-base AS build-base
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
     build-essential \
     g++ \
     make \
@@ -13,25 +35,9 @@ RUN apt-get update && apt-get install -y \
     automake \
     libtool \
     git \
-    nginx \
     && rm -rf /var/lib/apt/lists/*
 
 
-RUN mkdir -p /etc/apt/keyrings \
-    && curl -fsSL https://www.postgresql.org/media/keys/ACCC4CF8.asc \
-    | gpg --dearmor -o /etc/apt/keyrings/postgresql.gpg \
-    && echo "deb [signed-by=/etc/apt/keyrings/postgresql.gpg] http://apt.postgresql.org/pub/repos/apt bullseye-pgdg main" \
-    > /etc/apt/sources.list.d/pgdg.list
-
-RUN apt-get update && apt-get install -y \
-    postgresql-18 \
-    postgresql-client-18 \
-    postgresql-contrib-18 \
-    && rm -rf /var/lib/apt/lists/*
-
-ENV PATH="/usr/lib/postgresql/18/bin:${PATH}"
-
-
 FROM --platform=$BUILDPLATFORM golang:1.23-bookworm AS tusd-base
 
 ARG TUSD_VERSION=2.8.0
@@ -51,7 +57,7 @@ FROM scratch AS tusd-dist
 COPY --from=tusd-base /tusddist/tusd /tusd
 
 
-FROM base AS build-env
+FROM build-base AS build-env
 
 RUN corepack enable && corepack prepare pnpm@latest --activate
 
@@ -83,7 +89,7 @@ COPY . .
 ENV NEXT_TELEMETRY_DISABLED=1
 RUN pnpm run build
 
-FROM base AS prod
+FROM runtime-base AS prod
 
 WORKDIR /app
 ENV NODE_ENV=production
@@ -105,7 +111,6 @@ COPY --from=builder /app/drizzle.config.ts ./
 COPY --from=builder --chown=1001:1001 /app/.next/standalone ./
 COPY --from=builder --chown=1001:1001 /app/.next/static ./.next/static
 COPY --chown=1001:1001 src/db ./src/db
-COPY --from=deps /app/node_modules ./node_modules
 
 COPY --from=tusd-dist /tusd /usr/local/bin/tusd
 RUN chmod +x /usr/local/bin/tusd

docker/nginx/nginx.conf

@@ -30,6 +30,11 @@ http {
             proxy_set_header         Connection "upgrade";
         }
 
+        location = /api/tus/hooks {
+            deny all;
+            return 404;
+        }
+
         location / {
             proxy_pass http://127.0.0.1:3000;
 

knip.json

@@ -0,0 +1,3 @@
+{
+  "ignoreDependencies": ["pino-pretty"]
+}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "portabase",
-  "version": "1.20.3",
+  "version": "1.23.0",
   "private": true,
   "scripts": {
     "dev": "next dev --turbopack -p 8887",
@@ -27,52 +27,38 @@
     "@onboardjs/react": "1.0.0-rc.5",
     "@radix-ui/react-accordion": "^1.2.12",
     "@radix-ui/react-alert-dialog": "^1.1.15",
-    "@radix-ui/react-aspect-ratio": "^1.1.8",
     "@radix-ui/react-avatar": "^1.1.11",
     "@radix-ui/react-checkbox": "^1.3.3",
     "@radix-ui/react-collapsible": "^1.1.12",
-    "@radix-ui/react-context-menu": "^2.2.16",
     "@radix-ui/react-dialog": "^1.1.15",
     "@radix-ui/react-dropdown-menu": "^2.1.16",
-    "@radix-ui/react-hover-card": "^1.1.15",
     "@radix-ui/react-icons": "^1.3.2",
     "@radix-ui/react-label": "^2.1.8",
-    "@radix-ui/react-menubar": "^1.1.16",
-    "@radix-ui/react-navigation-menu": "^1.2.14",
     "@radix-ui/react-popover": "^1.1.15",
     "@radix-ui/react-progress": "^1.1.8",
     "@radix-ui/react-radio-group": "^1.3.8",
     "@radix-ui/react-scroll-area": "^1.2.10",
     "@radix-ui/react-select": "^2.2.6",
     "@radix-ui/react-separator": "^1.1.8",
-    "@radix-ui/react-slider": "^1.3.6",
     "@radix-ui/react-slot": "^1.2.4",
     "@radix-ui/react-switch": "^1.2.6",
     "@radix-ui/react-tabs": "^1.1.13",
-    "@radix-ui/react-toast": "^1.2.15",
     "@radix-ui/react-toggle": "^1.1.10",
-    "@radix-ui/react-toggle-group": "^1.1.11",
     "@radix-ui/react-tooltip": "^1.2.8",
     "@react-email/components": "^0.0.41",
     "@t3-oss/env-nextjs": "^0.13.11",
     "@tanstack/react-query": "^5.100.14",
     "@tanstack/react-table": "^8.21.3",
     "@types/nodemailer": "^6.4.23",
-    "@types/ws": "^8.18.1",
-    "@zenstackhq/runtime": "2.14.2",
-    "argon2": "^0.43.1",
-    "bcrypt": "^6.0.0",
     "better-auth": "1.6.11",
     "canvas-confetti": "^1.9.4",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",
     "date-fns": "^4.3.0",
-    "dockerode": "^4.0.12",
     "dotenv": "^16.6.1",
     "drizzle-orm": "0.45.2",
     "drizzle-zod": "0.8.3",
-    "embla-carousel-react": "^8.6.0",
     "googleapis": "^170.1.0",
     "input-otp": "^1.4.2",
     "lucide-react": "^0.553.0",
@@ -82,33 +68,23 @@
     "next-safe-action": "^7.10.8",
     "next-themes": "^0.4.6",
     "node-cron": "^4.2.1",
-    "node-forge": "^1.4.0",
     "nodemailer": "8.0.5",
-    "npm-check-updates": "^18.3.1",
     "pg": "^8.21.0",
     "pino": "^10.3.1",
-    "pino-pretty": "^13.1.3",
-    "prettier": "^3.8.3",
     "react": "^19.2.6",
-    "react-day-picker": "9.7.0",
     "react-dom": "^19.2.6",
     "react-dropzone": "^14.4.1",
     "react-email": "^4.3.2",
     "react-hook-form": "^7.76.1",
     "react-qr-code": "^2.0.21",
-    "react-resizable-panels": "^3.0.6",
     "react-twc": "^1.5.1",
-    "react-use-measure": "^2.1.7",
     "recharts": "^2.15.4",
+    "server-only": "^0.0.1",
     "sharp": "^0.34.5",
-    "socket.io": "^4.8.3",
-    "socket.io-client": "^4.8.3",
     "sonner": "^2.0.7",
-    "swiper": "^12.1.4",
     "tailwind-merge": "^3.6.0",
+    "tar-stream": "^3.2.0",
     "uuid": "^11.1.1",
-    "vaul": "^1.1.2",
-    "ws": "^8.21.0",
     "zod": "4.3.6"
   },
   "devDependencies": {
@@ -119,29 +95,22 @@
     "@release-it/conventional-changelog": "^10.0.6",
     "@tailwindcss/postcss": "^4.3.0",
     "@types/canvas-confetti": "^1.9.0",
-    "@types/eslint-plugin-tailwindcss": "^3.17.0",
     "@types/node": "^22.19.19",
-    "@types/node-forge": "^1.3.14",
     "@types/pg": "^8.20.0",
     "@types/react": "^19.2.15",
     "@types/react-dom": "^19.2.3",
-    "@zenstackhq/openapi": "^2.22.1",
-    "@zenstackhq/tanstack-query": "^2.22.2",
-    "baseline-browser-mapping": "^2.10.32",
+    "@types/tar-stream": "^3.1.4",
     "drizzle-kit": "^0.31.10",
-    "esbuild": "^0.27.7",
     "eslint": "^9.39.4",
     "eslint-config-next": "^16.2.6",
-    "eslint-plugin-tailwindcss": "^3.18.3",
     "framer-motion": "^12.40.0",
-    "node-pty": "^1.1.0",
+    "pino-pretty": "^13.1.3",
     "postcss": "8.5.10",
+    "postcss-load-config": "^6.0.1",
     "release-it": "^19.2.4",
     "tailwindcss": "^4.3.0",
-    "tsx": "^4.22.3",
     "tw-animate-css": "^1.4.0",
-    "typescript": "^5.9.3",
-    "zenstack": "2.14.2"
+    "typescript": "^5.9.3"
   },
   "packageManager": "pnpm@11.8.0+sha512.c1f5e7c4cb241c8f174b743851d82f42b802324afc8b0f116b96adb15aa06664948dde36960a3ba1079ba5b4b29dd0140135b94b5b5f5263592249d68e555f26"
 }

src/components/common/data-table.tsx

@@ -9,6 +9,8 @@ import {
     SortingState,
     ColumnFiltersState,
     getFilteredRowModel,
+    PaginationState,
+    OnChangeFn,
 } from "@tanstack/react-table";
 
 import {Table, TableBody, TableCell, TableHead, TableHeader, TableRow} from "@/components/ui/table";
@@ -42,6 +44,13 @@ interface DataTableProps<TData, TValue> {
     };
     highlightRow?: (row: TData) => boolean;
     selectedActions?: (rows: TData[]) => ReactNode;
+    manualPagination?: boolean;
+    rowCount?: number;
+    paginationState?: { pageIndex: number; pageSize: number };
+    onPaginationChange?: OnChangeFn<PaginationState>;
+    sorting?: SortingState;
+    onSortingChange?: OnChangeFn<SortingState>;
+    isFetching?: boolean;
 
 }
 
@@ -56,10 +65,19 @@ export function DataTable<TData, TValue>({
                                              emptyButton,
                                              highlightRow,
                                              selectedActions,
+                                             manualPagination = false,
+                                             rowCount,
+                                             paginationState,
+                                             onPaginationChange,
+                                             sorting: controlledSorting,
+                                             onSortingChange: controlledOnSortingChange,
+                                             isFetching = false,
 
 
                                          }: DataTableProps<TData, TValue>) {
-    const [sorting, setSorting] = useState<SortingState>([]);
+    const [internalSorting, setInternalSorting] = useState<SortingState>([]);
+    const sorting = controlledSorting ?? internalSorting;
+    const setSorting = controlledOnSortingChange ?? setInternalSorting;
     const [columnFilters, setColumnFilters] = useState<ColumnFiltersState>([]);
     const [rowSelection, setRowSelection] = useState({});
 
@@ -96,7 +114,7 @@ export function DataTable<TData, TValue>({
         data,
         columns: finalColumns,
         getCoreRowModel: getCoreRowModel(),
-        getPaginationRowModel: getPaginationRowModel(),
+        getPaginationRowModel: manualPagination ? undefined : getPaginationRowModel(),
         onSortingChange: setSorting,
         getSortedRowModel: getSortedRowModel(),
         onColumnFiltersChange: setColumnFilters,
@@ -106,10 +124,15 @@ export function DataTable<TData, TValue>({
         autoResetPageIndex: false,
         autoResetExpanded: false,
         enableRowSelection: true,
+        manualPagination,
+        manualSorting: manualPagination,
+        rowCount: manualPagination ? rowCount : undefined,
+        onPaginationChange: manualPagination ? onPaginationChange : undefined,
         state: {
             sorting,
             columnFilters,
             rowSelection,
+            ...(manualPagination && paginationState ? { pagination: paginationState } : {}),
         },
     });
     const router = useRouter();
@@ -194,18 +217,22 @@ export function DataTable<TData, TValue>({
                             selected.
                         </div>
                     )}
-                    {enablePagination && table.getFilteredRowModel().rows.length >= 1 && (
+                    {enablePagination && (manualPagination ? (rowCount ?? 0) > 0 : table.getFilteredRowModel().rows.length >= 1) && (
                         <TablePagination
                             table={table}
                             maxVisiblePages={paginationOptions?.pageVisible}
-                            pageSizeOptions={(() => {
-                                const rowCount = table.getFilteredRowModel().rows.length;
-                                const allSizes = paginationOptions.pageSize.sort((a, b) => a - b);
-                                const validSizes = allSizes.filter((size) => size <= rowCount);
-                                const nextSize = allSizes.find((size) => size > rowCount);
-                                if (nextSize) validSizes.push(nextSize);
-                                return validSizes;
-                            })()}
+                            pageSizeOptions={
+                                manualPagination
+                                    ? paginationOptions.pageSize
+                                    : (() => {
+                                        const rowCountLocal = table.getFilteredRowModel().rows.length;
+                                        const allSizes = paginationOptions.pageSize.sort((a, b) => a - b);
+                                        const validSizes = allSizes.filter((size) => size <= rowCountLocal);
+                                        const nextSize = allSizes.find((size) => size > rowCountLocal);
+                                        if (nextSize) validSizes.push(nextSize);
+                                        return validSizes;
+                                    })()
+                            }
                             className={paginationOptions.className}
                         />
                     )}

src/components/common/database-card.tsx

@@ -1,6 +1,4 @@
 "use client";
-
-import Link from "next/link";
 import Image from "next/image";
 import {useState} from "react";
 import {Card} from "@/components/ui/card";
@@ -8,28 +6,54 @@ import {ConnectionIndicator} from "@/components/common/connection-indicator";
 import {formatDateLastContact} from "@/utils/date-formatting";
 import {Database} from "@/db/schema/07_database";
 import {ChevronRight, Activity, Fingerprint, Copy, Check} from "lucide-react";
+import {cn} from "@/lib/utils";
 
 export type DatabaseCardProps = {
     data: Database;
     withDetails?: boolean;
+    selectable?: boolean;
+    selected?: boolean;
+    onToggleSelect?: (databaseId: string) => void;
+    deleteButton?: React.ReactNode;
 };
 
 export const DatabaseCard = (props: DatabaseCardProps) => {
-    const {data: database, withDetails = true} = props;
+    const {data: database, withDetails = true, selectable = false, selected = false, onToggleSelect, deleteButton} = props;
     const [isCopied, setIsCopied] = useState(false);
 
     const handleCopy = (e: React.MouseEvent) => {
         e.preventDefault();
         e.stopPropagation();
-        navigator.clipboard.writeText(database.agentDatabaseId);
+        navigator.clipboard.writeText(database.agentDatabaseId ?? "");
         setIsCopied(true);
         setTimeout(() => setIsCopied(false), 2000);
     };
 
     return (
         <Card
-            className="relative h-full flex flex-col p-4 transition-all border-border/50 bg-card hover:bg-accent/50 hover:border-primary/50 group-hover:shadow-lg overflow-hidden gap-0">
-            <div className="flex items-start justify-between mb-2">
+            className={cn(
+                "relative h-full flex flex-col p-4 transition-all border-border/50 bg-card hover:bg-accent/50 hover:border-primary/50 group-hover:shadow-lg overflow-hidden gap-0",
+                selected && "ring-1 ring-primary border-primary",
+            )}>
+            {selectable && (
+                <button
+                    type="button"
+                    aria-pressed={selected}
+                    aria-label={selected ? "Deselect database" : "Select database"}
+                    onClick={(e) => {
+                        e.preventDefault();
+                        e.stopPropagation();
+                        onToggleSelect?.(database.id);
+                    }}
+                    className={cn(
+                        "absolute top-3 left-3 z-20 w-5 h-5 rounded-md border-2 flex items-center justify-center transition-colors",
+                        selected ? "bg-primary border-primary text-primary-foreground" : "border-muted-foreground/50 bg-background/70",
+                    )}
+                >
+                    {selected && <Check className="w-3 h-3" />}
+                </button>
+            )}
+            <div className={cn("flex items-start justify-between mb-2", selectable && "pl-7")}>
                 <div
                     className="relative w-12 h-12 p-2 bg-background rounded-xl border border-border/50 shadow-sm flex items-center justify-center group-hover:border-primary/30 transition-all duration-300 group-hover:scale-105">
                     <Image
@@ -82,7 +106,12 @@ export const DatabaseCard = (props: DatabaseCardProps) => {
                 </div>
             </div>
 
-            {withDetails && (
+            {deleteButton ? (
+                <div className="mt-4 flex items-center justify-end pt-3 border-t border-border/50"
+                     onClick={(e) => e.preventDefault()}>
+                    {deleteButton}
+                </div>
+            ) : withDetails ? (
                 <div className="mt-4 flex items-center justify-between pt-3 border-t border-border/50">
                 <span
                     className="text-[10px] font-black uppercase tracking-widest text-primary opacity-0 group-hover:opacity-100 transition-all duration-300 transform translate-x-[-10px] group-hover:translate-x-0">Open</span>
@@ -93,7 +122,7 @@ export const DatabaseCard = (props: DatabaseCardProps) => {
                         <ChevronRight className="w-3.5 h-3.5 group-hover:translate-x-1 transition-transform"/>
                     </div>
                 </div>
-            )}
+            ) : null}
         </Card>
     );
 };

src/components/ui/dropzone.tsx

@@ -134,9 +134,9 @@ const getRootError = (
     const errors = errorCodes.map((error) => {
         switch (error) {
             case "file-invalid-type":
-                const acceptedTypes = Object.values(limits.accept ?? {})
-                    .flat()
-                    .join(", ");
+                const acceptedTypes = Array.from(
+                    new Set(Object.values(limits.accept ?? {}).flat()),
+                ).join(", ");
                 return `only ${acceptedTypes} are allowed`;
             case "file-too-large":
                 const maxMb = limits.maxSize

src/db/migrations/0069_worried_alex_wilder.sql

@@ -0,0 +1 @@
+ALTER TYPE "public"."dbms_status" ADD VALUE 'docker-volume';

src/db/migrations/0070_illegal_joseph.sql

@@ -0,0 +1,2 @@
+ALTER TABLE "databases" ALTER COLUMN "agent_database_id" DROP NOT NULL;--> statement-breakpoint
+ALTER TABLE "databases" ALTER COLUMN "agent_id" DROP NOT NULL;

src/db/migrations/meta/_journal.json

@@ -484,6 +484,20 @@
       "when": 1782575192480,
       "tag": "0068_busy_zeigeist",
       "breakpoints": true
+    },
+    {
+      "idx": 69,
+      "version": "7",
+      "when": 1782937885439,
+      "tag": "0069_worried_alex_wilder",
+      "breakpoints": true
+    },
+    {
+      "idx": 70,
+      "version": "7",
+      "when": 1783264084846,
+      "tag": "0070_illegal_joseph",
+      "breakpoints": true
     }
   ]
 }

src/db/schema/07_database.ts

@@ -13,7 +13,7 @@ import {JobLog, jobLog} from "@/db/schema/17_job-log";
 
 export const database = pgTable("databases", {
     id: uuid("id").primaryKey().defaultRandom(),
-    agentDatabaseId: uuid("agent_database_id").notNull().defaultRandom(),
+    agentDatabaseId: uuid("agent_database_id").defaultRandom(),
     name: text("name").notNull(),
     dbms: dbmsEnum("dbms").notNull(),
     description: text("description"),
@@ -22,7 +22,6 @@ export const database = pgTable("databases", {
     backupToRestore: text("backup_to_restore"),
     healthErrorCount: integer("health_error_count"),
     agentId: uuid("agent_id")
-        .notNull()
         .references(() => agent.id, {onDelete: "cascade"}),
     lastContact: timestamp("last_contact"),
     projectId: uuid("project_id")
@@ -143,10 +142,12 @@ export type BackupWith = Backup & {
     restorations?: Restoration[] | null;
     storages?: BackupStorage[] | null;
     logs?: JobLog[] | null;
+    hasLogs?: boolean;
 };
 
 export type RestorationWith = Restoration & {
     logs?: JobLog[] | null;
+    hasLogs?: boolean;
 };
 
 

src/db/schema/types.ts

@@ -2,7 +2,7 @@ import {pgEnum} from "drizzle-orm/pg-core";
 import {createSelectSchema} from "drizzle-zod";
 import {z} from "zod";
 
-export const dbmsEnum = pgEnum("dbms_status", ["postgresql", "postgresql-cluster", "mysql", "mariadb", "mongodb", "sqlite", "redis", "valkey", "firebird", "mssql"]);
+export const dbmsEnum = pgEnum("dbms_status", ["postgresql", "postgresql-cluster", "mysql", "mariadb", "mongodb", "sqlite", "redis", "valkey", "firebird", "mssql", "docker-volume"]);
 export const statusEnum = pgEnum("status", ["waiting", "ongoing", "failed", "success"]);
 export const typeStorageEnum = pgEnum("type_storage", ["local", "s3"]);
 

src/db/services/database.ts

@@ -16,10 +16,13 @@ export async function getOrganizationAvailableDatabases(
   projectId?: string,
 ) {
   const availableDatabases = (await db.query.database.findMany({
-    where: (db, { eq, or, isNull }) =>
-      projectId
-        ? or(isNull(db.projectId), eq(db.projectId, projectId))
-        : isNull(db.projectId),
+    where: (db, { eq, or, and, isNull }) =>
+      and(
+        projectId
+          ? or(isNull(db.projectId), eq(db.projectId, projectId))
+          : isNull(db.projectId),
+        isNull(db.deletedAt),
+      ),
     with: {
       agent: {
         with: {

src/db/services/healthcheck.ts

@@ -2,7 +2,7 @@
 
 import { db } from "@/db";
 import * as drizzleDb from "@/db";
-import { and, eq, gte, isNotNull, lt } from "drizzle-orm";
+import { and, eq, gte, isNotNull, isNull, lt } from "drizzle-orm";
 import { dispatchNotification } from "@/features/notifications/utils/notifications.dispatch";
 import { EventPayload } from "@/features/notifications/types";
 import { logger } from "@/lib/logger";
@@ -113,7 +113,10 @@ export async function checkAgentsHealthError() {
 
 export async function checkDatabasesHealthError() {
   const databases = await db.query.database.findMany({
-    where: isNotNull(drizzleDb.schemas.database.lastContact),
+    where: and(
+      isNotNull(drizzleDb.schemas.database.lastContact),
+      isNull(drizzleDb.schemas.database.deletedAt),
+    ),
     with: {
       agent: true,
       alertPolicies: true,

src/db/services/project.ts

@@ -2,7 +2,7 @@
 
 import { getOrganization } from "@/lib/auth/auth";
 import { db } from "@/db";
-import { and, eq } from "drizzle-orm";
+import { and, eq, isNull } from "drizzle-orm";
 import * as drizzleDb from "@/db";
 import { project } from "@/db/schema/06_project";
 
@@ -10,7 +10,9 @@ export async function getOrganizationProject(organizationId: string) {
   return db.query.project.findFirst({
     where: eq(project.organizationId, organizationId),
     with: {
-      databases: true,
+      databases: {
+        where: isNull(drizzleDb.schemas.database.deletedAt),
+      },
     },
   });
 }
@@ -39,7 +41,9 @@ export const getOrganizationProjectDatabases = async ({
         eq(drizzleDb.schemas.project.id, projectId),
       ),
       with: {
-        databases: true,
+        databases: {
+          where: isNull(drizzleDb.schemas.database.deletedAt),
+        },
       },
     });
 

src/env.mjs

@@ -64,6 +64,7 @@ export const env = createEnv({
                 process.env.NODE_ENV === "production" ? "0 * * * *" : "* * * * *",
             ),
 
+        STALE_BACKUP_THRESHOLD_HOURS: z.coerce.number().default(6),
 
         AUTH_OIDC_ID: z.string().optional().default("oidc"),
         AUTH_OIDC_TITLE: z.string().optional(),
@@ -147,6 +148,7 @@ export const env = createEnv({
 
         RETENTION_CRON: process.env.RETENTION_CRON,
         CLEANING_HEALTHCHECK_LOGS_CRON: process.env.CLEANING_HEALTHCHECK_LOGS_CRON,
+        STALE_BACKUP_THRESHOLD_HOURS: process.env.STALE_BACKUP_THRESHOLD_HOURS,
 
         AUTH_OIDC_ID: process.env.AUTH_OIDC_ID,
         AUTH_OIDC_TITLE: process.env.AUTH_OIDC_TITLE,

src/features/agents/actions/agent-organizations.action.ts

@@ -3,7 +3,7 @@ import {userAction} from "@/lib/safe-actions/actions";
 import {z} from "zod";
 import {ServerActionResult} from "@/types/action-type";
 import {db} from "@/db";
-import {and, eq, inArray} from "drizzle-orm";
+import {and, eq, inArray, isNull} from "drizzle-orm";
 import * as drizzleDb from "@/db";
 import {AgentWith} from "@/db/schema/08_agent";
 import {withUpdatedAt} from "@/db/utils";
@@ -25,7 +25,9 @@ export const updateAgentOrganizationsAction = userAction
                 where: eq(drizzleDb.schemas.agent.id, agentId),
                 with: {
                     organizations: true,
-                    databases: true
+                    databases: {
+                        where: isNull(drizzleDb.schemas.database.deletedAt),
+                    },
                 }
             }) as AgentWith;
 
@@ -70,7 +72,7 @@ export const updateAgentOrganizationsAction = userAction
 
                 if (projectIds.length > 0) {
                     const databases = await db.query.database.findMany({
-                        where: (db, { inArray }) => inArray(db.projectId, projectIds),
+                        where: (db, { inArray, and, isNull }) => and(inArray(db.projectId, projectIds), isNull(db.deletedAt)),
                         columns: { id: true }
                     });
 

src/features/agents/actions/agents.action.ts

@@ -2,7 +2,7 @@
 import {action, ActionError, userAction} from "@/lib/safe-actions/actions";
 import {AgentSchema} from "@/features/agents/schemas/agents.schema";
 import {z} from "zod";
-import {eq, and, ne, count, desc} from "drizzle-orm";
+import {eq, and, ne, count, desc, isNull} from "drizzle-orm";
 import {db} from "@/db";
 import * as drizzleDb from "@/db";
 import {slugify} from "@/utils/slugify";
@@ -87,7 +87,9 @@ export const getAgentAction = userAction.schema(z.string()).action(async ({parse
     const agent = await db.query.agent.findFirst({
         where: eq(drizzleDb.schemas.agent.id, parsedInput),
         with: {
-            databases: true
+            databases: {
+                where: isNull(drizzleDb.schemas.database.deletedAt),
+            },
         }
     });
 

src/features/agents/components/agent-content.tsx

@@ -23,9 +23,10 @@ import {HealthcheckLog} from "@/db/schema/15_healthcheck-log";
 type AgentContentPageProps = {
     edgeKey: string;
     agent: AgentWithDatabases
+    canDeleteDatabases?: boolean
 }
 
-export const AgentContentPage = ({edgeKey, agent: initialAgent}: AgentContentPageProps) => {
+export const AgentContentPage = ({edgeKey, agent: initialAgent, canDeleteDatabases = false}: AgentContentPageProps) => {
 
     const {data} = useQuery({
         queryKey: ["agent-data", initialAgent.id],
@@ -121,6 +122,7 @@ export const AgentContentPage = ({edgeKey, agent: initialAgent}: AgentContentPag
                             new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
                         )}
                         cardItem={AgentDatabaseCard}
+                        canDeleteDatabases={canDeleteDatabases}
                     />
                 </div>
             )}

src/features/agents/components/agent-database-card.tsx

@@ -1,14 +1,29 @@
 "use client";
 
-import {Database} from "@/db/schema/07_database";
-import {DatabaseCard} from "@/components/common/database-card";
+import { Database } from "@/db/schema/07_database";
+import { DatabaseCard } from "@/components/common/database-card";
+import { DatabaseDeleteButton } from "@/features/agents/components/database-delete-button";
 
-export type agentDatabaseCardProps = {
+export type AgentDatabaseCardProps = {
     data: Database;
+    canDeleteDatabases?: boolean;
 };
 
-export const AgentDatabaseCard = (props: agentDatabaseCardProps) => {
-    const {data: database} = props;
+export const AgentDatabaseCard = (props: AgentDatabaseCardProps) => {
+    const { data: database, canDeleteDatabases = false } = props;
 
-    return <DatabaseCard withDetails={false} data={database}/>;
-};
+    return (
+        <DatabaseCard
+            withDetails={false}
+            data={database}
+            deleteButton={
+                canDeleteDatabases && database.agentId ? (
+                    <DatabaseDeleteButton
+                        databaseId={database.id}
+                        agentId={database.agentId}
+                    />
+                ) : undefined
+            }
+        />
+    );
+};

src/features/agents/components/database-delete-button.tsx

@@ -0,0 +1,61 @@
+"use client";
+
+import {Trash2} from "lucide-react";
+import {ButtonWithConfirm} from "@/components/common/button-with-confirm";
+import {useMutation, useQueryClient} from "@tanstack/react-query";
+import {toast} from "sonner";
+import {deleteDatabaseAction} from "@/features/database/actions/database-delete.action";
+
+export type DatabaseDeleteButtonProps = {
+    databaseId: string;
+    agentId: string;
+};
+
+export const DatabaseDeleteButton = (props: DatabaseDeleteButtonProps) => {
+    const queryClient = useQueryClient();
+
+    const mutation = useMutation({
+        mutationFn: () => deleteDatabaseAction({databaseId: props.databaseId}),
+        onSuccess: async (result: any) => {
+            if (result.data?.success) {
+                toast.success(result.data.actionSuccess.message);
+                await queryClient.invalidateQueries({queryKey: ["agent-data", props.agentId]});
+            } else {
+                toast.error(result.data?.actionError?.message || "Unknown error occurred.");
+            }
+        },
+        onError: () => {
+            toast.error("Failed to delete database.");
+        },
+    });
+
+    return (
+        <ButtonWithConfirm
+            title="Delete database"
+            description="Are you sure you want to delete this database? It will be unlinked from this agent."
+            button={{
+                main: {
+                    text: "",
+                    variant: "outline",
+                    size: "sm",
+                    icon: <Trash2 color="red"/>,
+                },
+                confirm: {
+                    className: "w-full",
+                    text: "Delete",
+                    icon: <Trash2/>,
+                    variant: "destructive",
+                    onClick: () => {
+                        mutation.mutate();
+                    },
+                },
+                cancel: {
+                    className: "w-full",
+                    text: "Cancel",
+                    variant: "outline",
+                },
+            }}
+            isPending={mutation.isPending}
+        />
+    );
+};

src/features/agents/types/index.ts

@@ -0,0 +1,13 @@
+import {EDbmsSchema} from "@/db/schema/types";
+
+export type databaseAgent = {
+    name: string;
+    dbms: EDbmsSchema;
+    generatedId: string;
+    pingStatus: boolean;
+};
+
+export type Body = {
+    version: string;
+    databases: databaseAgent[];
+};

src/features/agents/utils/status/restoration.helpers.ts

@@ -0,0 +1,37 @@
+import * as drizzleDb from "@/db";
+import {db as dbClient} from "@/db";
+import {eq} from "drizzle-orm";
+import {logger} from "@/lib/logger";
+import {sendNotificationsBackupRestore} from "@/features/notifications/utils/notifications.helpers";
+
+const log = logger.child({module: "api/agent/status/restoration"});
+
+export async function handleFailedRestoration(restorationId: string, databaseId: string, reason: string): Promise<void> {
+    try {
+        await dbClient
+            .insert(drizzleDb.schemas.jobLog)
+            .values({
+                backupId: null,
+                restorationId,
+                loggedAt: new Date(),
+                entryType: "log",
+                level: "error",
+                message: reason,
+                command: null,
+                output: null,
+                exitCode: null,
+                durationMs: null,
+            });
+
+        const databaseWithPolicies = await dbClient.query.database.findFirst({
+            where: eq(drizzleDb.schemas.database.id, databaseId),
+            with: {alertPolicies: true},
+        });
+
+        if (databaseWithPolicies) {
+            await sendNotificationsBackupRestore(databaseWithPolicies, "error_restore");
+        }
+    } catch (err) {
+        log.error({error: err, name: "handleFailedRestoration"}, "Failed to record restoration failure job log / notification");
+    }
+}

src/features/agents/utils/status/status.helpers.ts

@@ -1,10 +1,10 @@
 import {NextResponse} from "next/server";
-import {Body} from "./route";
+import {Body} from "@/features/agents/types";
 import {Agent} from "@/db/schema/08_agent";
 import {DatabaseWith} from "@/db/schema/07_database";
 import * as drizzleDb from "@/db";
-import {db, db as dbClient} from "@/db";
-import {and, eq, inArray} from "drizzle-orm";
+import {db as dbClient} from "@/db";
+import {and, eq, inArray, desc, sql} from "drizzle-orm";
 import {dbmsEnumSchema, EDbmsSchema} from "@/db/schema/types";
 import {withUpdatedAt} from "@/db/utils";
 import {Setting} from "@/db/schema/01_setting";
@@ -12,12 +12,22 @@ import {logger} from "@/lib/logger";
 import {isUUID} from "@/utils/text";
 import {StorageInput} from "@/features/storages/types";
 import {dispatchStorage} from "@/features/storages/utils/storages.dispatch";
+import {getMasterServerKeyContent} from "@/features/agents/actions/keys.action";
+import {getDatabaseStorageChannels, PingDatabaseStorageChannels} from "./storage-channels.helpers";
+import {applyStorageEncryption} from "./storage-encryption.helpers";
+import {handleFailedRestoration} from "./restoration.helpers";
 
 const log = logger.child({module: "api/agent/status/helpers"});
 
 export async function handleDatabases(body: Body, agent: Agent, lastContact: Date, settings: Setting) {
     const databasesResponse = [];
 
+    const masterKeyResult = await getMasterServerKeyContent();
+    const masterKey = Buffer.isBuffer(masterKeyResult) ? masterKeyResult : null;
+    if (!masterKey) {
+        log.error({name: "handleDatabases"}, "Master key unavailable; storages will be sent in plaintext");
+    }
+
     const formatDatabase = (database: DatabaseWith, backupAction: boolean, restoreAction: boolean, UrlBackup: string | null, storages: PingDatabaseStorageChannels[], urlMeta: string | null, backupSize: number | null) => ({
         generatedId: database.agentDatabaseId,
         dbms: database.dbms,
@@ -77,10 +87,7 @@ export async function handleDatabases(body: Body, agent: Agent, lastContact: Dat
                 })
                 .returning();
 
-
             if (databaseCreated) {
-
-
                 await dbClient
                     .insert(drizzleDb.schemas.healthcheckLog)
                     .values({
@@ -92,7 +99,9 @@ export async function handleDatabases(body: Body, agent: Agent, lastContact: Dat
 
                 const storages = await getDatabaseStorageChannels(databaseCreated.id)
 
-                databasesResponse.push(formatDatabase(databaseCreated, backupAction, restoreAction, urlBackup, storages, null, null));
+                const entry = formatDatabase(databaseCreated, backupAction, restoreAction, urlBackup, storages, null, null);
+                applyStorageEncryption(entry, body.version, masterKey, agent.id);
+                databasesResponse.push(entry);
             }
         } else {
 
@@ -123,7 +132,11 @@ export async function handleDatabases(body: Body, agent: Agent, lastContact: Dat
                 where: and(
                     eq(drizzleDb.schemas.backup.databaseId, databaseUpdated.id),
                     inArray(drizzleDb.schemas.backup.status, ["waiting", "ongoing"])
-                )
+                ),
+                orderBy: [
+                    sql`case when ${drizzleDb.schemas.backup.status} = 'waiting' then 0 else 1 end`,
+                    desc(drizzleDb.schemas.backup.createdAt)
+                ]
             })
 
             const restoration = await dbClient.query.restoration.findFirst({
@@ -191,6 +204,9 @@ export async function handleDatabases(body: Body, agent: Agent, lastContact: Dat
 
                         const errorMessage = "Failed to get backup URL";
                         log.error({error: errorMessage, name: "handleDatabases"}, "Restoration failed");
+
+                        await handleFailedRestoration(restoration.id, databaseUpdated.id, errorMessage);
+
                         continue;
                     }
                 } catch (err) {
@@ -199,6 +215,7 @@ export async function handleDatabases(body: Body, agent: Agent, lastContact: Dat
                         .update(drizzleDb.schemas.restoration)
                         .set(withUpdatedAt({status: "failed"}))
                         .where(eq(drizzleDb.schemas.restoration.id, restoration.id));
+                    await handleFailedRestoration(restoration.id, databaseUpdated.id, "Restoration crashed unexpectedly");
                     continue;
                 }
 
@@ -208,71 +225,10 @@ export async function handleDatabases(body: Body, agent: Agent, lastContact: Dat
                     .where(eq(drizzleDb.schemas.restoration.id, restoration.id));
             }
             const storages = await getDatabaseStorageChannels(databaseUpdated.id)
-            databasesResponse.push(formatDatabase(databaseUpdated, backupAction, restoreAction, urlBackup, storages, urlMeta, backupSize));
+            const entry = formatDatabase(databaseUpdated, backupAction, restoreAction, urlBackup, storages, urlMeta, backupSize);
+            applyStorageEncryption(entry, body.version, masterKey, agent.id);
+            databasesResponse.push(entry);
         }
     }
     return databasesResponse;
 }
-
-
-type PingDatabaseStorageChannels = {
-    id: string;
-    config: any
-    provider: string
-}
-
-async function getDatabaseStorageChannels(databaseId: string): Promise<PingDatabaseStorageChannels[]> {
-
-    const database = await db.query.database.findFirst({
-        where: eq(drizzleDb.schemas.database.id, databaseId),
-        with: {
-            project: true,
-            retentionPolicy: true,
-            alertPolicies: true,
-            storagePolicies: true
-        }
-    });
-
-    if (!database) {
-        return []
-    }
-
-    const settings = await db.query.setting.findFirst({
-        where: eq(drizzleDb.schemas.setting.name, "system"),
-        with: {storageChannel: true},
-    });
-
-    const defaultStorageChannel: PingDatabaseStorageChannels[] = settings?.storageChannel
-        ? [{
-            id: settings.storageChannel.id,
-            provider: settings.storageChannel.provider,
-            config: settings.storageChannel.config,
-        }]
-        : [];
-
-
-    const enabledDatabaseStorageChannels = await Promise.all(
-        (database.storagePolicies ?? [])
-            .filter(p => p.enabled)
-            .map(async policy => {
-                const storageChannel = await db.query.storageChannel.findFirst({
-                    where: eq(drizzleDb.schemas.storageChannel.id, policy.storageChannelId),
-                });
-
-                if (!storageChannel) return null;
-
-                return {
-                    id: storageChannel.id,
-                    config: storageChannel.config,
-                    provider: storageChannel.provider,
-                } as PingDatabaseStorageChannels;
-            })
-    );
-
-    const filteredChannels: PingDatabaseStorageChannels[] = enabledDatabaseStorageChannels.filter(
-        (c): c is PingDatabaseStorageChannels => c !== null
-    );
-
-    return filteredChannels.length > 0 ? filteredChannels : defaultStorageChannel;
-}
-

src/features/agents/utils/status/storage-channels.helpers.ts

@@ -0,0 +1,64 @@
+import * as drizzleDb from "@/db";
+import {db} from "@/db";
+import {eq} from "drizzle-orm";
+
+export type PingDatabaseStorageChannels = {
+    id: string;
+    config: any
+    provider: string
+}
+
+export async function getDatabaseStorageChannels(databaseId: string): Promise<PingDatabaseStorageChannels[]> {
+
+    const database = await db.query.database.findFirst({
+        where: eq(drizzleDb.schemas.database.id, databaseId),
+        with: {
+            project: true,
+            retentionPolicy: true,
+            alertPolicies: true,
+            storagePolicies: true
+        }
+    });
+
+    if (!database) {
+        return []
+    }
+
+    const settings = await db.query.setting.findFirst({
+        where: eq(drizzleDb.schemas.setting.name, "system"),
+        with: {storageChannel: true},
+    });
+
+    const defaultStorageChannel: PingDatabaseStorageChannels[] = settings?.storageChannel
+        ? [{
+            id: settings.storageChannel.id,
+            provider: settings.storageChannel.provider,
+            config: settings.storageChannel.config,
+        }]
+        : [];
+
+
+    const enabledDatabaseStorageChannels = await Promise.all(
+        (database.storagePolicies ?? [])
+            .filter(p => p.enabled)
+            .map(async policy => {
+                const storageChannel = await db.query.storageChannel.findFirst({
+                    where: eq(drizzleDb.schemas.storageChannel.id, policy.storageChannelId),
+                });
+
+                if (!storageChannel) return null;
+
+                return {
+                    id: storageChannel.id,
+                    config: storageChannel.config,
+                    provider: storageChannel.provider,
+                } as PingDatabaseStorageChannels;
+            })
+    );
+
+    const filteredChannels: PingDatabaseStorageChannels[] = enabledDatabaseStorageChannels.filter(
+        (c): c is PingDatabaseStorageChannels => c !== null
+    );
+
+    return filteredChannels.length > 0 ? filteredChannels : defaultStorageChannel;
+}

src/features/agents/utils/status/storage-encryption.helpers.ts

@@ -0,0 +1,33 @@
+import {logger} from "@/lib/logger";
+import {encryptStorages, isAgentVersionAtLeast, MIN_AGENT_VERSION_STORAGE_ENC} from "@/utils/status-crypto";
+
+const log = logger.child({module: "api/agent/status/storage-encryption"});
+
+export function applyStorageEncryption(
+    entry: Record<string, any>,
+    version: string | undefined,
+    masterKey: Buffer | null,
+    agentId: string,
+): void {
+    if (!masterKey) return;
+    if (!Array.isArray(entry.storages) || entry.storages.length === 0) return;
+    if (!isAgentVersionAtLeast(version, MIN_AGENT_VERSION_STORAGE_ENC)) {
+        console.log(
+            `============================================================\n` +
+            `⚠️OUTDATED AGENT — STORAGE CREDENTIALS SENT UNENCRYPTED\n` +
+            `Agent ${agentId} reports v${version ?? "unknown"} (< required v${MIN_AGENT_VERSION_STORAGE_ENC}).\n` +
+            `Update this agent to v${MIN_AGENT_VERSION_STORAGE_ENC}+ to encrypt storage credentials in transit.\n` +
+            `============================================================`
+        )
+        return;
+    }
+
+    try {
+        const ciphertext = encryptStorages(entry.storages, masterKey);
+        entry.storages_ciphertext = ciphertext;
+        entry.storages_encrypted = true;
+        entry.storages = [];
+    } catch (err) {
+        log.error({error: err, name: "applyStorageEncryption"}, "Storage encryption failed; sending plaintext");
+    }
+}

src/features/channel/components/storages/s3.form.tsx

@@ -105,7 +105,7 @@ export const StorageS3Form = ({ form }: StorageS3FormProps) => {
           <FormItem>
             <FormLabel>Use SSL</FormLabel>
             <FormControl>
-              <Switch checked={field.value} onCheckedChange={field.onChange} />
+              <Switch checked={field.value ?? true} onCheckedChange={field.onChange} />
             </FormControl>
             <FormMessage />
           </FormItem>

src/features/database/actions/backup-get-data.action.ts

@@ -2,9 +2,8 @@
 import {userAction} from "@/lib/safe-actions/actions";
 import {z} from "zod";
 import {db} from "@/db";
-import {eq} from "drizzle-orm";
+import {and, count, eq, inArray, isNull} from "drizzle-orm";
 import * as drizzleDb from "@/db";
-import {BackupWith, RestorationWith} from "@/db/schema/07_database";
 import {getOrganizationChannels} from "@/db/services/notification-channel";
 import {getOrganizationStorageChannels} from "@/db/services/storage-channel";
 import {getHealthLast12hLogs} from "@/db/services/healthcheck";
@@ -19,7 +18,10 @@ export const getDatabaseDataAction = userAction
         const {databaseId} = parsedInput;
 
         const database = await db.query.database.findFirst({
-            where: eq(drizzleDb.schemas.database.id, databaseId),
+            where: and(
+                eq(drizzleDb.schemas.database.id, databaseId),
+                isNull(drizzleDb.schemas.database.deletedAt),
+            ),
             with: {
                 project: true,
                 retentionPolicy: true,
@@ -28,33 +30,50 @@ export const getDatabaseDataAction = userAction
             }
         });
 
-        const backups = await db.query.backup.findMany({
-            where: eq(drizzleDb.schemas.backup.databaseId, databaseId),
-            with: {
-                restorations: true,
-                storages: {
-                    with: {
-                        storageChannel: true
-                    }
-                },
-                logs: true
-            },
-            orderBy: (b, {desc}) => [desc(b.createdAt)],
-        }) as BackupWith[];
+        const [totalRow] = await db
+            .select({count: count()})
+            .from(drizzleDb.schemas.backup)
+            .where(eq(drizzleDb.schemas.backup.databaseId, databaseId));
+        const totalBackups = totalRow?.count ?? 0;
 
-        const restorations = await db.query.restoration.findMany({
-            where: eq(drizzleDb.schemas.restoration.databaseId, databaseId),
-            with: {
-                logs: true
-            },
-            orderBy: (r, {desc}) => [desc(r.createdAt)],
-        }) as RestorationWith[];
+        const [availableRow] = await db
+            .select({count: count()})
+            .from(drizzleDb.schemas.backup)
+            .where(and(
+                eq(drizzleDb.schemas.backup.databaseId, databaseId),
+                isNull(drizzleDb.schemas.backup.deletedAt),
+            ));
+        const availableBackups = availableRow?.count ?? 0;
+
+        const [successRow] = await db
+            .select({count: count()})
+            .from(drizzleDb.schemas.backup)
+            .where(and(
+                eq(drizzleDb.schemas.backup.databaseId, databaseId),
+                eq(drizzleDb.schemas.backup.status, "success"),
+            ));
+        const successfulBackups = successRow?.count ?? 0;
 
-        const totalBackups = backups.length;
-        const availableBackups = backups.filter(b => !b.deletedAt).length;
-        const successfulBackups = backups.filter(b => b.status === "success").length;
         const successRate = totalBackups > 0 ? (successfulBackups / totalBackups) * 100 : null;
 
+        const [activeBackupRow] = await db
+            .select({count: count()})
+            .from(drizzleDb.schemas.backup)
+            .where(and(
+                eq(drizzleDb.schemas.backup.databaseId, databaseId),
+                inArray(drizzleDb.schemas.backup.status, ["waiting", "ongoing"]),
+            ));
+        const isAlreadyBackup = (activeBackupRow?.count ?? 0) > 0;
+
+        const [activeRestoreRow] = await db
+            .select({count: count()})
+            .from(drizzleDb.schemas.restoration)
+            .where(and(
+                eq(drizzleDb.schemas.restoration.databaseId, databaseId),
+                eq(drizzleDb.schemas.restoration.status, "waiting"),
+            ));
+        const isAlreadyRestore = (activeRestoreRow?.count ?? 0) > 0;
+
         // @ts-ignore
         let activeOrganizationChannels = [];
         // @ts-ignore
@@ -68,11 +87,8 @@ export const getDatabaseDataAction = userAction
             activeOrganizationStorageChannels = organizationStorageChannels.filter(channel => channel.enabled);
         }
 
-
         return {
             database,
-            backups,
-            restorations,
             // @ts-ignore
             activeOrganizationChannels,
             // @ts-ignore
@@ -82,6 +98,8 @@ export const getDatabaseDataAction = userAction
                 availableBackups,
                 successRate
             },
-            health: database ? await getHealthLast12hLogs({ id: database.id }) : []
+            isAlreadyRestore,
+            isAlreadyBackup,
+            health: database ? await getHealthLast12hLogs({id: database.id}) : []
         };
-    });
+    });

src/features/database/actions/backup-list.action.ts

@@ -0,0 +1,120 @@
+"use server";
+import { userAction } from "@/lib/safe-actions/actions";
+import { db } from "@/db";
+import { and, count, eq, inArray, isNotNull, isNull } from "drizzle-orm";
+import * as drizzleDb from "@/db";
+import { BackupWith, RestorationWith } from "@/db/schema/07_database";
+import {
+    FetchBackupsSchema,
+    FetchRestorationsSchema,
+} from "@/features/database/actions/backup-list.schema";
+
+export const fetchBackupsAction = userAction
+    .schema(FetchBackupsSchema)
+    .action(async ({ parsedInput }) => {
+        const { databaseId, page, pageSize, filter } = parsedInput;
+        const offset = (page - 1) * pageSize;
+
+        const deletedCondition =
+            filter === "available"
+                ? isNull(drizzleDb.schemas.backup.deletedAt)
+                : filter === "deleted"
+                    ? isNotNull(drizzleDb.schemas.backup.deletedAt)
+                    : undefined;
+
+        const where = and(
+            eq(drizzleDb.schemas.backup.databaseId, databaseId),
+            deletedCondition,
+        );
+
+        const [totalResult] = await db
+            .select({ count: count() })
+            .from(drizzleDb.schemas.backup)
+            .where(where);
+
+        const data = (await db.query.backup.findMany({
+            where,
+            with: {
+                restorations: true,
+                storages: {
+                    with: {
+                        storageChannel: true,
+                    },
+                },
+            },
+            orderBy: (b, { desc }) => [desc(b.createdAt)],
+            limit: pageSize,
+            offset,
+        })) as BackupWith[];
+
+        const backupIds = data.map((b) => b.id);
+        const backupsWithLogs = backupIds.length
+            ? await db
+                .select({ backupId: drizzleDb.schemas.jobLog.backupId })
+                .from(drizzleDb.schemas.jobLog)
+                .where(inArray(drizzleDb.schemas.jobLog.backupId, backupIds))
+                .groupBy(drizzleDb.schemas.jobLog.backupId)
+            : [];
+        const loggedBackupIds = new Set(backupsWithLogs.map((l) => l.backupId));
+        for (const b of data) {
+            b.hasLogs = loggedBackupIds.has(b.id);
+        }
+
+        const total = totalResult?.count ?? 0;
+        return {
+            data,
+            meta: {
+                total,
+                page,
+                pageSize,
+                totalPages: Math.ceil(total / pageSize),
+            },
+        };
+    });
+
+export const fetchRestorationsAction = userAction
+    .schema(FetchRestorationsSchema)
+    .action(async ({ parsedInput }) => {
+        const { databaseId, page, pageSize } = parsedInput;
+        const offset = (page - 1) * pageSize;
+
+        const where = eq(drizzleDb.schemas.restoration.databaseId, databaseId);
+
+        const [totalResult] = await db
+            .select({ count: count() })
+            .from(drizzleDb.schemas.restoration)
+            .where(where);
+
+        const data = (await db.query.restoration.findMany({
+            where,
+            orderBy: (r, { desc }) => [desc(r.createdAt)],
+            limit: pageSize,
+            offset,
+        })) as RestorationWith[];
+
+        const restorationIds = data.map((r) => r.id);
+        const restorationsWithLogs = restorationIds.length
+            ? await db
+                .select({ restorationId: drizzleDb.schemas.jobLog.restorationId })
+                .from(drizzleDb.schemas.jobLog)
+                .where(inArray(drizzleDb.schemas.jobLog.restorationId, restorationIds))
+                .groupBy(drizzleDb.schemas.jobLog.restorationId)
+            : [];
+        const loggedRestorationIds = new Set(
+            restorationsWithLogs.map((l) => l.restorationId),
+        );
+        for (const r of data) {
+            r.hasLogs = loggedRestorationIds.has(r.id);
+        }
+
+        const total = totalResult?.count ?? 0;
+        return {
+            data,
+            meta: {
+                total,
+                page,
+                pageSize,
+                totalPages: Math.ceil(total / pageSize),
+            },
+        };
+    });

src/features/database/actions/backup-list.schema.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+
+export const FetchBackupsSchema = z.object({
+    databaseId: z.string(),
+    page: z.number().int().min(1).default(1),
+    pageSize: z.number().int().min(1).max(100).default(20),
+    filter: z.enum(["available", "deleted"]).optional(),
+    sorting: z.any().optional(),
+});
+export type FetchBackupsSchema = z.infer<typeof FetchBackupsSchema>;
+
+export const FetchRestorationsSchema = z.object({
+    databaseId: z.string(),
+    page: z.number().int().min(1).default(1),
+    pageSize: z.number().int().min(1).max(100).default(20),
+    sorting: z.any().optional(),
+});
+export type FetchRestorationsSchema = z.infer<typeof FetchRestorationsSchema>;

src/features/database/actions/bulk-backup.action.ts

@@ -0,0 +1,58 @@
+"use server";
+
+import {z} from "zod";
+import {and, inArray, isNull} from "drizzle-orm";
+import {db} from "@/db";
+import * as drizzleDb from "@/db";
+import {ServerActionResult} from "@/types/action-type";
+import {userAction} from "@/lib/safe-actions/actions";
+import {assertDatabasesInOrgProject} from "@/features/database/actions/bulk-restore.action";
+
+const bulkSchema = z.object({
+    projectId: z.uuid(),
+    databaseIds: z.array(z.uuid()).min(1),
+});
+
+export const bulkBackupAction = userAction
+    .schema(bulkSchema)
+    .action(async ({parsedInput}): Promise<ServerActionResult<{queued: number; skipped: {databaseId: string; reason: string}[]}>> => {
+        try {
+            const {projectId, databaseIds} = parsedInput;
+            await assertDatabasesInOrgProject(projectId, databaseIds);
+
+            const activeBackups = await db.query.backup.findMany({
+                where: and(
+                    inArray(drizzleDb.schemas.backup.databaseId, databaseIds),
+                    inArray(drizzleDb.schemas.backup.status, ["waiting", "ongoing"]),
+                    isNull(drizzleDb.schemas.backup.deletedAt),
+                ),
+                columns: {databaseId: true},
+            });
+            const busy = new Set(activeBackups.map((b) => b.databaseId));
+            const toQueue = databaseIds.filter((id) => !busy.has(id));
+            const skipped = [...busy].map((databaseId) => ({databaseId, reason: "backup already in progress"}));
+
+            if (toQueue.length > 0) {
+                await db
+                    .insert(drizzleDb.schemas.backup)
+                    .values(toQueue.map((databaseId) => ({databaseId, status: "waiting" as const})));
+            }
+
+            return {
+                success: true,
+                value: {queued: toQueue.length, skipped},
+                actionSuccess: {
+                    message: `Queued ${toQueue.length} backup(s)${skipped.length ? `, ${skipped.length} skipped` : ""}.`,
+                },
+            };
+        } catch (error) {
+            return {
+                success: false,
+                actionError: {
+                    message: "Failed to queue backups.",
+                    status: 500,
+                    cause: error instanceof Error ? error.message : "Unknown error",
+                },
+            };
+        }
+    });

src/features/database/actions/bulk-restore.action.ts

@@ -0,0 +1,167 @@
+"use server";
+
+import {z} from "zod";
+import {and, desc, eq, inArray, isNull} from "drizzle-orm";
+import {db} from "@/db";
+import * as drizzleDb from "@/db";
+import {ServerActionResult} from "@/types/action-type";
+import {userAction, ActionError} from "@/lib/safe-actions/actions";
+import {getOrganization} from "@/lib/auth/auth";
+
+export async function assertDatabasesInOrgProject(projectId: string, databaseIds: string[]) {
+    const organization = await getOrganization({});
+    if (!organization) throw new ActionError("No active organization.");
+
+    const project = await db.query.project.findFirst({
+        where: and(
+            eq(drizzleDb.schemas.project.id, projectId),
+            eq(drizzleDb.schemas.project.organizationId, organization.id),
+        ),
+        with: {databases: {where: isNull(drizzleDb.schemas.database.deletedAt)}},
+    });
+    if (!project) throw new ActionError("Project not found.");
+
+    const allowed = new Set(project.databases.map((d) => d.id));
+    for (const id of databaseIds) {
+        if (!allowed.has(id)) throw new ActionError("Database not in project.");
+    }
+}
+
+export type RestorePreviewRow = {
+    databaseId: string;
+    name: string;
+    backupId?: string;
+    backupStorageId?: string;
+    backupDate?: string;
+    restorable: boolean;
+    reason?: string;
+};
+
+async function resolveLatestRestorable(projectId: string, databaseIds: string[]): Promise<RestorePreviewRow[]> {
+    const project = await db.query.project.findFirst({
+        where: eq(drizzleDb.schemas.project.id, projectId),
+        with: {databases: {where: isNull(drizzleDb.schemas.database.deletedAt)}},
+    });
+    const nameById = new Map((project?.databases ?? []).map((d) => [d.id, d.name] as const));
+
+    const rows: RestorePreviewRow[] = [];
+    for (const databaseId of databaseIds) {
+        const activeRestore = await db.query.restoration.findFirst({
+            where: and(
+                eq(drizzleDb.schemas.restoration.databaseId, databaseId),
+                inArray(drizzleDb.schemas.restoration.status, ["waiting", "ongoing"]),
+            ),
+        });
+        if (activeRestore) {
+            rows.push({
+                databaseId,
+                name: nameById.get(databaseId) ?? databaseId,
+                restorable: false,
+                reason: "restore already in progress",
+            });
+            continue;
+        }
+
+        const backups = await db.query.backup.findMany({
+            where: and(
+                eq(drizzleDb.schemas.backup.databaseId, databaseId),
+                isNull(drizzleDb.schemas.backup.deletedAt),
+            ),
+            orderBy: desc(drizzleDb.schemas.backup.createdAt),
+        });
+
+        let picked: RestorePreviewRow | undefined;
+        for (const backup of backups) {
+            const storage = await db.query.backupStorage.findFirst({
+                where: and(
+                    eq(drizzleDb.schemas.backupStorage.backupId, backup.id),
+                    eq(drizzleDb.schemas.backupStorage.status, "success"),
+                    isNull(drizzleDb.schemas.backupStorage.deletedAt),
+                ),
+                orderBy: desc(drizzleDb.schemas.backupStorage.createdAt),
+            });
+            if (storage) {
+                picked = {
+                    databaseId,
+                    name: nameById.get(databaseId) ?? databaseId,
+                    backupId: backup.id,
+                    backupStorageId: storage.id,
+                    backupDate: backup.createdAt?.toISOString(),
+                    restorable: true,
+                };
+                break;
+            }
+        }
+
+        rows.push(picked ?? {databaseId, name: nameById.get(databaseId) ?? databaseId, restorable: false, reason: "no successful backup"});
+    }
+    return rows;
+}
+
+const bulkSchema = z.object({
+    projectId: z.uuid(),
+    databaseIds: z.array(z.uuid()).min(1),
+});
+
+export const bulkRestorePreviewAction = userAction
+    .schema(bulkSchema)
+    .action(async ({parsedInput}): Promise<ServerActionResult<RestorePreviewRow[]>> => {
+        try {
+            const {projectId, databaseIds} = parsedInput;
+            await assertDatabasesInOrgProject(projectId, databaseIds);
+            const rows = await resolveLatestRestorable(projectId, databaseIds);
+            return {success: true, value: rows};
+        } catch (error) {
+            return {
+                success: false,
+                actionError: {
+                    message: "Failed to build restore preview.",
+                    status: 500,
+                    cause: error instanceof Error ? error.message : "Unknown error",
+                },
+            };
+        }
+    });
+
+export const bulkRestoreLatestAction = userAction
+    .schema(bulkSchema)
+    .action(async ({parsedInput}): Promise<ServerActionResult<{queued: number; skipped: {databaseId: string; reason: string}[]}>> => {
+        try {
+            const {projectId, databaseIds} = parsedInput;
+            await assertDatabasesInOrgProject(projectId, databaseIds);
+            const rows = await resolveLatestRestorable(projectId, databaseIds);
+
+            const restorable = rows.filter((r) => r.restorable);
+            const skipped = rows
+                .filter((r) => !r.restorable)
+                .map((r) => ({databaseId: r.databaseId, reason: r.reason ?? "no successful backup"}));
+
+            if (restorable.length > 0) {
+                await db.insert(drizzleDb.schemas.restoration).values(
+                    restorable.map((r) => ({
+                        databaseId: r.databaseId,
+                        backupId: r.backupId!,
+                        backupStorageId: r.backupStorageId!,
+                        status: "waiting" as const,
+                    })),
+                );
+            }
+
+            return {
+                success: true,
+                value: {queued: restorable.length, skipped},
+                actionSuccess: {
+                    message: `Queued ${restorable.length} restore(s)${skipped.length ? `, ${skipped.length} skipped` : ""}.`,
+                },
+            };
+        } catch (error) {
+            return {
+                success: false,
+                actionError: {
+                    message: "Failed to queue restores.",
+                    status: 500,
+                    cause: error instanceof Error ? error.message : "Unknown error",
+                },
+            };
+        }
+    });

src/features/database/actions/database-delete.action.ts

@@ -0,0 +1,174 @@
+"use server";
+
+import {z} from "zod";
+import {eq} from "drizzle-orm";
+import {db} from "@/db";
+import * as drizzleDb from "@/db";
+import {Database} from "@/db/schema/07_database";
+import {ServerActionResult} from "@/types/action-type";
+import {userAction} from "@/lib/safe-actions/actions";
+import {zString} from "@/lib/zod";
+import {withUpdatedAt} from "@/db/utils";
+import {currentUser} from "@/lib/auth/current-user";
+import {getActiveMember, getOrganization} from "@/lib/auth/auth";
+import {computeOrganizationPermissions} from "@/lib/acl/organization-acl";
+
+type DeleteDatabaseInput = {
+    databaseId: string;
+};
+
+class DatabaseNotFoundError extends Error {
+    constructor(databaseId: string) {
+        super(`Database not found or update failed: ${databaseId}`);
+        this.name = "DatabaseNotFoundError";
+    }
+}
+
+class UnauthorizedError extends Error {
+    constructor(databaseId: string) {
+        super(`Not authorized to delete this database: ${databaseId}`);
+        this.name = "UnauthorizedError";
+    }
+}
+
+async function assertCanDeleteDatabase(databaseId: string): Promise<void> {
+    const database = await db.query.database.findFirst({
+        where: eq(drizzleDb.schemas.database.id, databaseId),
+        with: {
+            agent: true,
+        },
+    });
+
+    if (!database || !database.agent) {
+        throw new DatabaseNotFoundError(databaseId);
+    }
+
+    const user = await currentUser();
+    if (!user) {
+        throw new UnauthorizedError(databaseId);
+    }
+
+    const agent = database.agent;
+    const isAdmin = user.role === "superadmin" || user.role === "admin";
+
+    let authorized: boolean;
+    if (agent.organizationId === null) {
+        authorized = isAdmin;
+    } else {
+        const organization = await getOrganization({});
+        const activeMember = await getActiveMember();
+        const canManage = activeMember
+            ? computeOrganizationPermissions(activeMember).canManageAgents
+            : false;
+
+        const hasAccess =
+            !!organization && agent.organizationId === organization.id;
+        authorized = canManage && hasAccess;
+    }
+
+    if (!authorized) {
+        throw new UnauthorizedError(databaseId);
+    }
+}
+
+export async function deleteDatabaseService(input: DeleteDatabaseInput): Promise<Database> {
+    const {databaseId} = input;
+
+    await assertCanDeleteDatabase(databaseId);
+
+    await db
+        .delete(drizzleDb.schemas.retentionPolicy)
+        .where(eq(drizzleDb.schemas.retentionPolicy.databaseId, databaseId))
+        .execute();
+
+    await db
+        .delete(drizzleDb.schemas.alertPolicy)
+        .where(eq(drizzleDb.schemas.alertPolicy.databaseId, databaseId))
+        .execute();
+
+    await db
+        .delete(drizzleDb.schemas.storagePolicy)
+        .where(eq(drizzleDb.schemas.storagePolicy.databaseId, databaseId))
+        .execute();
+
+    const [updatedDatabase] = await db
+        .update(drizzleDb.schemas.database)
+        .set(
+            withUpdatedAt({
+                agentId: null,
+                agentDatabaseId: null,
+                projectId: null,
+                backupPolicy: null,
+                deletedAt: new Date(),
+            })
+        )
+        .where(eq(drizzleDb.schemas.database.id, databaseId))
+        .returning();
+
+    if (!updatedDatabase) {
+        throw new DatabaseNotFoundError(databaseId);
+    }
+
+    return updatedDatabase;
+}
+
+export const deleteDatabaseAction = userAction
+    .schema(
+        z.object({
+            databaseId: zString(),
+        })
+    )
+    .action(async ({parsedInput}): Promise<ServerActionResult<Database>> => {
+        try {
+            const deletedDatabase = await deleteDatabaseService(parsedInput);
+
+            return {
+                success: true,
+                value: deletedDatabase,
+                actionSuccess: {
+                    message: "Database has been successfully deleted.",
+                    messageParams: {
+                        databaseId: parsedInput.databaseId,
+                    },
+                },
+            };
+        } catch (error) {
+            if (error instanceof UnauthorizedError) {
+                return {
+                    success: false,
+                    actionError: {
+                        message: "Not authorized to delete this database.",
+                        status: 403,
+                        messageParams: {
+                            databaseId: parsedInput.databaseId,
+                        },
+                    },
+                };
+            }
+
+            if (error instanceof DatabaseNotFoundError) {
+                return {
+                    success: false,
+                    actionError: {
+                        message: "Database not found or update failed",
+                        status: 404,
+                        messageParams: {
+                            databaseId: parsedInput.databaseId,
+                        },
+                    },
+                };
+            }
+
+            return {
+                success: false,
+                actionError: {
+                    message: "Failed to delete database.",
+                    status: 500,
+                    cause: error instanceof Error ? error.message : "Unknown error",
+                    messageParams: {
+                        databaseId: parsedInput.databaseId,
+                    },
+                },
+            };
+        }
+    });

src/features/database/actions/import.action.ts

@@ -5,10 +5,10 @@ import {db} from "@/db";
 import * as drizzleDb from "@/db";
 import {Backup} from "@/db/schema/07_database";
 import {v4 as uuidv4} from "uuid";
-import {eq} from "drizzle-orm";
+import {and, eq, isNull} from "drizzle-orm";
 import {z} from "zod";
 import {storeBackupFiles} from "@/features/storages/utils/storages.helpers";
-import {getFileExtension} from "@/utils/common";
+import {inspectUpload, InvalidUploadError, packToTarGz} from "@/features/database/utils/archive-inspect";
 
 
 export const uploadBackupAction = userAction
@@ -19,7 +19,10 @@ export const uploadBackupAction = userAction
             const databaseId = formData.get("databaseId") as string;
 
             const database = await db.query.database.findFirst({
-                where: eq(drizzleDb.schemas.database.id, databaseId),
+                where: and(
+                    eq(drizzleDb.schemas.database.id, databaseId),
+                    isNull(drizzleDb.schemas.database.deletedAt),
+                ),
                 with: {
                     project: true,
                     alertPolicies: true,
@@ -38,13 +41,45 @@ export const uploadBackupAction = userAction
                 };
             }
 
-            const fileExtension = getFileExtension(database.dbms)
+            const MAX_UPLOAD_BYTES = 2 * 1024 * 1024 * 1024; // 2 GB
+            if (file.size > MAX_UPLOAD_BYTES) {
+                return {
+                    success: false,
+                    actionError: {
+                        message: "File exceeds the 2 GB upload limit.",
+                        status: 413,
+                        cause: "File too large",
+                    },
+                };
+            }
 
             const arrayBuffer = await file.arrayBuffer();
+            const buffer = Buffer.from(arrayBuffer);
+
+            let inspection;
+            try {
+                inspection = await inspectUpload(buffer, database.dbms);
+            } catch (error) {
+                if (error instanceof InvalidUploadError) {
+                    return {
+                        success: false,
+                        actionError: {
+                            message: error.message,
+                            status: 400,
+                            cause: "Invalid backup archive",
+                        },
+                    };
+                }
+                throw error;
+            }
+
+            let fileBuffer: Buffer = buffer;
+            if (inspection.kind === "wrap" && inspection.innerName) {
+                fileBuffer = await packToTarGz(buffer, inspection.innerName);
+            }
 
             const uuid = uuidv4();
-            const fileName = `${uuid}${fileExtension}`;
-            const buffer = Buffer.from(arrayBuffer);
+            const fileName = `${uuid}${inspection.storeExtension}`;
 
 
             const [backup] = await db
@@ -56,7 +91,7 @@ export const uploadBackupAction = userAction
                 })
                 .returning();
 
-            await storeBackupFiles(backup, database, buffer, fileName)
+            await storeBackupFiles(backup, database, fileBuffer, fileName)
 
             return {
                 success: true,

src/features/database/components/backup-actions-form.tsx

@@ -101,6 +101,12 @@ export const BackupActionsForm = ({
         queryClient.invalidateQueries({
           queryKey: ["database-data", backup.databaseId],
         });
+        queryClient.invalidateQueries({
+          queryKey: ["backups", backup.databaseId],
+        });
+        queryClient.invalidateQueries({
+          queryKey: ["restorations", backup.databaseId],
+        });
         router.refresh();
         if (action === "download") {
           const url = inner.value;
@@ -121,6 +127,9 @@ export const BackupActionsForm = ({
           queryClient.invalidateQueries({
             queryKey: ["database-data", backup.databaseId],
           });
+          queryClient.invalidateQueries({
+            queryKey: ["backups", backup.databaseId],
+          });
           router.refresh();
           closeModal();
         } else {
@@ -144,6 +153,9 @@ export const BackupActionsForm = ({
         queryClient.invalidateQueries({
           queryKey: ["database-data", backup.databaseId],
         });
+        queryClient.invalidateQueries({
+          queryKey: ["backups", backup.databaseId],
+        });
         router.refresh();
         closeModal();
       } else {

src/features/database/components/backup-button.tsx

@@ -29,6 +29,9 @@ export const BackupButton = (props: BackupButtonProps) => {
         queryClient.invalidateQueries({
           queryKey: ["database-data", props.databaseId],
         });
+        queryClient.invalidateQueries({
+          queryKey: ["backups", props.databaseId],
+        });
         router.refresh();
       } else {
         toast.error(backup?.serverError || "Failed to create backup.");

src/features/database/components/backup-columns.tsx

@@ -112,8 +112,7 @@ export function backupColumns(
             accessorKey: "logs",
             header: "Logs",
             cell: ({row}) => {
-                const logs = row.original.logs ?? [];
-                return <LogsModalTrigger logs={logs}/>;
+                return <LogsModalTrigger backupId={row.original.id} hasLogs={row.original.hasLogs}/>;
             },
         },
         {

src/features/database/components/cron-advanced-select.tsx

@@ -1,4 +1,4 @@
-import { useState } from "react";
+import { useEffect, useState } from "react";
 import { Label } from "@/components/ui/label";
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
 import { Input } from "@/components/ui/input";
@@ -12,6 +12,7 @@ export const AdvancedCronSelect = ({
     value,
     defaultValue,
     onValueChange,
+    onValidityChange,
 }: {
     id: string;
     label: string;
@@ -20,11 +21,21 @@ export const AdvancedCronSelect = ({
     value: string;
     defaultValue: string;
     onValueChange: (value: string) => void;
+    onValidityChange?: (valid: boolean) => void;
 }) => {
     const [isAdvanced, setIsAdvanced] = useState(false);
-    const [customValue, setCustomValue] = useState(defaultValue || value);
+    const [customValue, setCustomValue] = useState(value || defaultValue);
     const [error, setError] = useState<string | null>(null);
 
+    useEffect(() => {
+        setCustomValue(value || defaultValue);
+    }, [value, defaultValue]);
+
+    useEffect(() => {
+        const valid = !isAdvanced || isValidCronPart(type, customValue);
+        onValidityChange?.(valid);
+    }, [isAdvanced, customValue, type, onValidityChange]);
+
     const handleBlur = () => {
         if (customValue.trim() === "") {
             setIsAdvanced(false);
@@ -46,7 +57,7 @@ export const AdvancedCronSelect = ({
                     // @ts-ignore
                     id={id}
                     className="col-span-4"
-                    value={defaultValue}
+                    value={value}
                     onValueChange={(value: string) => {
                         if (value === "advanced") {
                             setIsAdvanced(true);

src/features/database/components/cron-input.tsx

@@ -2,7 +2,7 @@ import {AdvancedCronSelect} from "@/features/database/components/cron-advanced-s
 import {updateDatabaseBackupPolicyAction} from "@/features/database/actions/cron.action";
 import {useMutation, useQueryClient} from "@tanstack/react-query";
 import {useRouter} from "next/navigation";
-import {useState} from "react";
+import {useCallback, useState} from "react";
 import {toast} from "sonner";
 import {Button} from "@/components/ui/button";
 import {Separator} from "@/components/ui/separator";
@@ -14,10 +14,17 @@ export type CronInputProps = {
 };
 
 export const CronInput = ({database, onSuccess}: CronInputProps) => {
-    const [cron, setCron] = useState<string>(database.backupPolicy ?? "* * * * *");
+    const [cron, setCron] = useState<string>(database.backupPolicy ?? "0 0 * * *");
+    const [fieldValidity, setFieldValidity] = useState<Record<string, boolean>>({});
     const queryClient = useQueryClient();
     const router = useRouter();
 
+    const setFieldValid = useCallback((id: string) => (valid: boolean) => {
+        setFieldValidity((prev) => (prev[id] === valid ? prev : {...prev, [id]: valid}));
+    }, []);
+
+    const hasInvalidField = Object.values(fieldValidity).some((valid) => !valid);
+
     const updateBackupPolicy = useMutation({
         mutationFn: (value: string) => updateDatabaseBackupPolicyAction({databaseId: database.id, backupPolicy: value}),
         onSuccess: () => {
@@ -48,38 +55,42 @@ export const CronInput = ({database, onSuccess}: CronInputProps) => {
             <AdvancedCronSelect
                 id="minute"
                 label="Minute"
-                options={Array.from({length: 60}, (_, i) => String(i).padStart(2, "0"))}
+                options={Array.from({length: 60}, (_, i) => String(i))}
                 type="minute"
                 value={cron.split(" ")[0]}
                 defaultValue={cron.split(" ")[0]}
                 onValueChange={(value) => handleChangeCron("minute", value)}
+                onValidityChange={setFieldValid("minute")}
             />
             <AdvancedCronSelect
                 id="hour"
                 label="Hour"
-                options={Array.from({length: 24}, (_, i) => String(i).padStart(2, "0"))}
+                options={Array.from({length: 24}, (_, i) => String(i))}
                 type="hour"
                 value={cron.split(" ")[1]}
                 defaultValue={cron.split(" ")[1]}
                 onValueChange={(value) => handleChangeCron("hour", value)}
+                onValidityChange={setFieldValid("hour")}
             />
             <AdvancedCronSelect
                 id="day-of-month"
                 label="Day of Month"
-                options={Array.from({length: 31}, (_, i) => String(i + 1).padStart(2, "0"))}
+                options={Array.from({length: 31}, (_, i) => String(i + 1))}
                 type="day-of-month"
                 value={cron.split(" ")[2]}
                 defaultValue={cron.split(" ")[2]}
                 onValueChange={(value) => handleChangeCron("day-of-month", value)}
+                onValidityChange={setFieldValid("day-of-month")}
             />
             <AdvancedCronSelect
                 id="month"
                 label="Month"
-                options={["01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12"]}
+                options={Array.from({length: 12}, (_, i) => String(i + 1))}
                 type="month"
                 value={cron.split(" ")[3]}
                 defaultValue={cron.split(" ")[3]}
                 onValueChange={(value) => handleChangeCron("month", value)}
+                onValidityChange={setFieldValid("month")}
             />
             <AdvancedCronSelect
                 id="day-of-week"
@@ -89,6 +100,7 @@ export const CronInput = ({database, onSuccess}: CronInputProps) => {
                 value={cron.split(" ")[4]}
                 defaultValue={cron.split(" ")[4]}
                 onValueChange={(value) => handleChangeCron("day-of-week", value)}
+                onValidityChange={setFieldValid("day-of-week")}
             />
             <Separator/>
             <div className="grid gap-2">
@@ -113,6 +125,7 @@ export const CronInput = ({database, onSuccess}: CronInputProps) => {
                     onClick={async () => {
                         await handleUpdateCron(cron);
                     }}
+                    disabled={hasInvalidField || updateBackupPolicy.isPending}
                 >
                     Save cron
                 </Button>

src/features/database/components/database-backup-list.tsx

@@ -13,23 +13,22 @@ import {toast} from "sonner";
 import {MemberWithUser} from "@/db/schema/03_organization";
 import {deleteBackupAction} from "@/features/database/actions/backup-actions.action";
 import {ButtonWithConfirm} from "@/components/common/button-with-confirm";
-
+import {useServerDataTable} from "@/hooks/use-server-data-table";
+import {fetchBackupsAction} from "@/features/database/actions/backup-list.action";
+import type {FetchBackupsSchema} from "@/features/database/actions/backup-list.schema";
 
 type DatabaseBackupListProps = {
     isAlreadyRestore: boolean;
     settings: Setting;
     database: DatabaseWith;
-    backups: BackupWith[];
-    activeMember: MemberWithUser
+    activeMember: MemberWithUser;
 }
 
-
 export const DatabaseBackupList = (props: DatabaseBackupListProps) => {
-
     const items = [
         {label: "Deleted", value: "deleted"},
         {label: "Available", value: "available"},
-    ]
+    ];
 
     const [selectedFilters, setSelectedFilters] = useState<FilterItem[]>([items[1]]);
     const [isActionsOpen, setIsActionsOpen] = useState(false);
@@ -39,20 +38,19 @@ export const DatabaseBackupList = (props: DatabaseBackupListProps) => {
         return backupColumns(props.isAlreadyRestore, props.settings, props.database, props.activeMember);
     }, [props.isAlreadyRestore, props.activeMember.id, props.activeMember.role]);
 
-    const filteredBackups = useMemo(() => {
-        if (!props.backups) return [];
-
-        return props.backups.filter(backup => {
-            if (selectedFilters.length > 0) {
-                const selectedValues = selectedFilters.map(f => f.value);
-                const status = backup.deletedAt != null ? "deleted" : "available";
-                if (!selectedValues.includes(status)) return false;
-            }
-
-            return true;
-        });
-    }, [props.backups, selectedFilters]);
+    const filter = useMemo<"available" | "deleted" | undefined>(() => {
+        const values = selectedFilters.map((f) => f.value);
+        if (values.length === 1) return values[0] as "available" | "deleted";
+        return undefined;
+    }, [selectedFilters]);
 
+    const {data, tableProps, isFetching, isLoading} = useServerDataTable<BackupWith, FetchBackupsSchema>({
+        fetchAction: fetchBackupsAction,
+        queryKey: ["backups", props.database.id],
+        extraParams: {databaseId: props.database.id, filter},
+        initialPageSize: 20,
+        refetchInterval: 4000,
+    });
 
     const handleSelectFilter = (item: FilterItem) => {
         setSelectedFilters(prev =>
@@ -64,29 +62,26 @@ export const DatabaseBackupList = (props: DatabaseBackupListProps) => {
 
     const clearFilters = () => setSelectedFilters([]);
 
-
     const mutationDeleteBackups = useMutation({
         mutationFn: async (backups: Backup[]) => {
             const results = await Promise.all(
                 backups.map(async (backup) => {
                     if (backup.deletedAt == null || backup.status == "ongoing") {
-
                         const backupDeleted = await deleteBackupAction({
                             databaseId: backup.databaseId,
                             backupId: backup.id,
-                        })
+                        });
                         return {
                             success: backupDeleted?.data?.success,
                             message: backupDeleted?.data?.success
                                 ? backupDeleted?.data?.actionSuccess?.message
-                                // @ts-ignore
-                                : restoration?.data?.actionError.message,
+                                : "Failed to delete backup.",
                         };
                     }
                     return {
                         success: true,
                         message: `Already deleted this backup (ref: ${backup.id}).`,
-                    }
+                    };
                 })
             );
             results.forEach((result) => {
@@ -96,7 +91,7 @@ export const DatabaseBackupList = (props: DatabaseBackupListProps) => {
                     toast.error(result.message);
                 }
             });
-            queryClient.invalidateQueries({queryKey: ["database-data", props.database.id]});
+            queryClient.invalidateQueries({queryKey: ["backups", props.database.id]});
         },
     });
 
@@ -106,8 +101,10 @@ export const DatabaseBackupList = (props: DatabaseBackupListProps) => {
         <DataTable
             enableSelect={!isMember}
             columns={columns}
-            data={filteredBackups}
+            data={data}
             enablePagination
+            isFetching={isFetching || isLoading}
+            {...tableProps}
             selectedActions={(rows) => (
                 <>
                     <div className="flex justify-start md:justify-between gap-3 md:gap-0 items-center w-full ml-0">
@@ -156,9 +153,8 @@ export const DatabaseBackupList = (props: DatabaseBackupListProps) => {
                             />
                         </div>
                     </div>
-
                 </>
             )}
         />
-    )
-}
+    );
+};

src/features/database/components/database-content.tsx

@@ -2,7 +2,7 @@
 import {DatabaseBackupActionsModal} from "@/features/database/components/backup-actions-modal";
 import {DatabaseTabs} from "@/features/database/components/database-tabs";
 import {Setting} from "@/db/schema/01_setting";
-import {BackupWith, DatabaseWith, RestorationWith} from "@/db/schema/07_database";
+import {DatabaseWith} from "@/db/schema/07_database";
 import {MemberWithUser} from "@/db/schema/03_organization";
 import {useBackupModal} from "@/features/database/components/backup-modal-context";
 import {DatabaseKpi} from "@/features/database/components/database-kpi";
@@ -27,8 +27,6 @@ import {LogsModal} from "@/features/logs/components/logs-modal";
 
 export type DatabaseContentProps = {
     settings: Setting;
-    backups: BackupWith[];
-    restorations: RestorationWith[];
     isAlreadyRestore: boolean;
     database: DatabaseWith;
     activeMember: MemberWithUser;
@@ -53,14 +51,11 @@ export const DatabaseContent = (props: DatabaseContentProps) => {
             return result?.data;
         },
         initialData: {
-            // TODO : to be patched
             // @ts-ignore
             database: {
                 ...props.database,
                 project: props.database.project ?? null,
             },
-            backups: props.backups,
-            restorations: props.restorations,
             activeOrganizationChannels: props.activeOrganizationChannels,
             activeOrganizationStorageChannels:
             props.activeOrganizationStorageChannels,
@@ -69,16 +64,16 @@ export const DatabaseContent = (props: DatabaseContentProps) => {
                 availableBackups: props.availableBackups,
                 successRate: props.successRate,
             },
+            isAlreadyRestore: props.isAlreadyRestore,
+            isAlreadyBackup: false,
             health: props.databaseHealthLogs
         },
         staleTime: 0,
         gcTime: 0,
-        refetchInterval: 1000,
+        refetchInterval: 4000,
     });
 
     const database = data?.database ?? props.database;
-    const backups = data?.backups ?? props.backups;
-    const restorations = data?.restorations ?? props.restorations;
     const activeOrganizationChannels =
         data?.activeOrganizationChannels ?? props.activeOrganizationChannels;
     const activeOrganizationStorageChannels =
@@ -90,10 +85,8 @@ export const DatabaseContent = (props: DatabaseContentProps) => {
         successRate: props.successRate,
     };
 
-    const isAlreadyRestore = restorations.some((r) => r.status === "waiting");
-    const isAlreadyBackup = backups.some(
-        (b) => b.status === "waiting" || b.status === "ongoing",
-    );
+    const isAlreadyRestore = data?.isAlreadyRestore ?? props.isAlreadyRestore;
+    const isAlreadyBackup = data?.isAlreadyBackup ?? false;
 
     const isMember = props.activeMember.role === "member";
 
@@ -128,7 +121,9 @@ export const DatabaseContent = (props: DatabaseContentProps) => {
                                     channels={activeOrganizationStorageChannels}
                                     organizationId={props.organizationId}
                                 />
-                                <ImportModal database={database}/>
+                                {database.dbms != "docker-volume" && (
+                                    <ImportModal database={database}/>
+                                )}
                                 <HealthModal database={database} healthLogs={data?.health ?? []}/>
                             </div>
 
@@ -164,8 +159,6 @@ export const DatabaseContent = (props: DatabaseContentProps) => {
                     settings={props.settings}
                     database={database}
                     isAlreadyRestore={isAlreadyRestore}
-                    backups={backups}
-                    restorations={restorations}
                 />
             </PageContent>
         </>

src/features/database/components/database-restore-list.tsx

@@ -4,18 +4,19 @@ import {restoreColumns} from "@/features/database/components/restore-columns";
 import {DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger} from "@/components/ui/dropdown-menu";
 import {ButtonWithLoading} from "@/components/common/button-with-loading";
 import {MoreHorizontal, Trash2} from "lucide-react";
-import {Restoration} from "@/db/schema/07_database";
+import {Restoration, RestorationWith} from "@/db/schema/07_database";
 import {useMutation, useQueryClient} from "@tanstack/react-query";
 import {deleteRestoreAction} from "@/features/database/actions/restore.action";
 import {toast} from "sonner";
 import {MemberWithUser} from "@/db/schema/03_organization";
 import {useMemo, useState} from "react";
 import {ButtonWithConfirm} from "@/components/common/button-with-confirm";
-
+import {useServerDataTable} from "@/hooks/use-server-data-table";
+import {fetchRestorationsAction} from "@/features/database/actions/backup-list.action";
+import type {FetchRestorationsSchema} from "@/features/database/actions/backup-list.schema";
 
 type DatabaseRestoreListProps = {
     isAlreadyRestore: boolean;
-    restorations: Restoration[];
     activeMember: MemberWithUser;
     databaseId: string;
 }
@@ -28,6 +29,14 @@ export const DatabaseRestoreList = (props: DatabaseRestoreListProps) => {
         return restoreColumns(props.isAlreadyRestore, props.activeMember);
     }, [props.isAlreadyRestore, props.activeMember.id, props.activeMember.role]);
 
+    const {data, tableProps, isFetching, isLoading} = useServerDataTable<RestorationWith, FetchRestorationsSchema>({
+        fetchAction: fetchRestorationsAction,
+        queryKey: ["restorations", props.databaseId],
+        extraParams: {databaseId: props.databaseId},
+        initialPageSize: 20,
+        refetchInterval: 4000,
+    });
+
     const mutationDeleteRestorations = useMutation({
         mutationFn: async (restorations: Restoration[]) => {
             const results = await Promise.all(
@@ -42,8 +51,6 @@ export const DatabaseRestoreList = (props: DatabaseRestoreListProps) => {
                             // @ts-ignore
                             : restorationDeleted?.data?.actionError.message,
                     };
-
-
                 })
             );
             results.forEach((result) => {
@@ -53,18 +60,19 @@ export const DatabaseRestoreList = (props: DatabaseRestoreListProps) => {
                     toast.error(result.message);
                 }
             });
-            queryClient.invalidateQueries({queryKey: ["database-data", props.databaseId]});
+            queryClient.invalidateQueries({queryKey: ["restorations", props.databaseId]});
         },
     });
     const isMember = props.activeMember.role === "member";
 
-
     return (
         <DataTable
             enableSelect={!isMember}
             columns={columns}
-            data={props.restorations}
+            data={data}
             enablePagination
+            isFetching={isFetching || isLoading}
+            {...tableProps}
             selectedActions={(rows) => (
                 <>
                     {!isMember && (
@@ -84,7 +92,7 @@ export const DatabaseRestoreList = (props: DatabaseRestoreListProps) => {
                                 >Actions</ButtonWithLoading>
                             </DropdownMenuTrigger>
                             <DropdownMenuContent align="start">
-                                <ButtonWithConfirm 
+                                <ButtonWithConfirm
                                     onConfirm={() => {
                                         mutationDeleteRestorations.mutate(rows)
                                         setIsActionsOpen(false);
@@ -110,5 +118,5 @@ export const DatabaseRestoreList = (props: DatabaseRestoreListProps) => {
                 </>
             )}
         />
-    )
-}
+    );
+};

src/features/database/components/database-tabs.tsx

@@ -2,8 +2,8 @@
 
 import {Tabs, TabsContent, TabsList, TabsTrigger} from "@/components/ui/tabs";
 import {useEffect, useState} from "react";
-import {useRouter, useSearchParams} from "next/navigation";
-import {BackupWith, DatabaseWith, Restoration} from "@/db/schema/07_database";
+import {useSearchParams} from "next/navigation";
+import {DatabaseWith} from "@/db/schema/07_database";
 import {Setting} from "@/db/schema/01_setting";
 import {DatabaseBackupList} from "@/features/database/components/database-backup-list";
 import {DatabaseRestoreList} from "@/features/database/components/database-restore-list";
@@ -11,8 +11,6 @@ import {MemberWithUser} from "@/db/schema/03_organization";
 
 export type DatabaseTabsProps = {
     settings: Setting,
-    backups: BackupWith[],
-    restorations: Restoration[],
     isAlreadyRestore: boolean,
     database: DatabaseWith,
     activeMember: MemberWithUser
@@ -21,24 +19,27 @@ export type DatabaseTabsProps = {
 export const backupOnly = ["redis", "valkey"];
 
 export const DatabaseTabs = (props: DatabaseTabsProps) => {
-    const router = useRouter();
     const searchParams = useSearchParams();
 
     const [tab, setTab] = useState<string>(() => searchParams.get("tab") ?? "backup");
 
     useEffect(() => {
-        const newTab = searchParams.get("tab") ?? "backup";
-        // eslint-disable-next-line react-hooks/set-state-in-effect
-        setTab(newTab);
-    }, [searchParams]);
+        const onPopState = () => {
+            const params = new URLSearchParams(window.location.search);
+            setTab(params.get("tab") ?? "backup");
+        };
+        window.addEventListener("popstate", onPopState);
+        return () => window.removeEventListener("popstate", onPopState);
+    }, []);
 
     const handleChangeTab = (value: string) => {
-        router.push(`?tab=${value}`);
+        setTab(value);
+        const params = new URLSearchParams(window.location.search);
+        params.set("tab", value);
+        window.history.pushState(null, "", `?${params.toString()}`);
     };
 
-
-    const isBackupOnly = backupOnly.some((type) => props.database.dbms === type)
-
+    const isBackupOnly = backupOnly.some((type) => props.database.dbms === type);
 
     return (
         <>
@@ -47,7 +48,6 @@ export const DatabaseTabs = (props: DatabaseTabsProps) => {
                     isAlreadyRestore={props.isAlreadyRestore}
                     settings={props.settings}
                     database={props.database}
-                    backups={props.backups}
                     activeMember={props.activeMember}
                 />
                 :
@@ -61,22 +61,18 @@ export const DatabaseTabs = (props: DatabaseTabsProps) => {
                             isAlreadyRestore={props.isAlreadyRestore}
                             settings={props.settings}
                             database={props.database}
-                            backups={props.backups}
                             activeMember={props.activeMember}
                         />
                     </TabsContent>
                     <TabsContent className="h-full justify-between" value="restore">
                         <DatabaseRestoreList
                             isAlreadyRestore={props.isAlreadyRestore}
-                            restorations={props.restorations}
                             activeMember={props.activeMember}
                             databaseId={props.database.id}
                         />
                     </TabsContent>
                 </Tabs>
             }
-
         </>
-
     );
 };

src/features/database/components/import-upload-zone.tsx

@@ -41,6 +41,7 @@ export const UploadBackupZone = ({onSuccessAction, database}: UploadRetentionZon
                     toast.success(inner.actionSuccess?.message);
                     onSuccessAction?.()
                     queryClient.invalidateQueries({queryKey: ["database-data", database.id]});
+                    queryClient.invalidateQueries({queryKey: ["backups", database.id]});
                     router.refresh();
                 } else {
                     toast.error(inner?.actionError?.message);
@@ -50,6 +51,7 @@ export const UploadBackupZone = ({onSuccessAction, database}: UploadRetentionZon
                 toast.error("An error occurred while upload in the backup");
             } finally {
                 queryClient.invalidateQueries({queryKey: ["database-data",  database.id]});
+                queryClient.invalidateQueries({queryKey: ["backups", database.id]});
                 setIsProcessing(false);
             }
         },
@@ -57,9 +59,9 @@ export const UploadBackupZone = ({onSuccessAction, database}: UploadRetentionZon
 
     const acceptDbImportFiles = getFileHeadersBasedOnDbms(database.dbms)
 
-    const fileKindDescription = Object.values(acceptDbImportFiles)
-        .flat()
-        .join(", ");
+    const fileKindDescription = Array.from(
+        new Set(Object.values(acceptDbImportFiles).flat())
+    ).join(", ");
 
 
     return (
@@ -73,7 +75,7 @@ export const UploadBackupZone = ({onSuccessAction, database}: UploadRetentionZon
                     maxFiles={1}
                     description="Import database backup"
                     fileKind={`Database file (${fileKindDescription})`}
-                    dragMessage="Click or drag a database dump here"
+                    dragMessage="Click or drag a database dump or .tar.gz here"
                     onFileDropAction={(file: File) => setFile(file)}
                 />
             )}

src/features/database/components/restore-columns.tsx

@@ -62,8 +62,7 @@ export function restoreColumns(
       accessorKey: "logs",
       header: "Logs",
       cell: ({row}) => {
-        const logs = row.original.logs ?? [];
-        return <LogsModalTrigger logs={logs}/>;
+        return <LogsModalTrigger restorationId={row.original.id} hasLogs={row.original.hasLogs}/>;
       },
     },
     {
@@ -86,6 +85,9 @@ export function restoreColumns(
               queryClient.invalidateQueries({
                 queryKey: ["database-data", rowData.databaseId],
               });
+              queryClient.invalidateQueries({
+                queryKey: ["restorations", rowData.databaseId],
+              });
             } else {
               // @ts-ignore
               toast.error(restoration.data.actionError.message);
@@ -105,6 +107,9 @@ export function restoreColumns(
               queryClient.invalidateQueries({
                 queryKey: ["database-data", rowData.databaseId],
               });
+              queryClient.invalidateQueries({
+                queryKey: ["restorations", rowData.databaseId],
+              });
             } else {
               // @ts-ignore
               toast.error(restoration.data.actionError.message);

src/features/database/utils/archive-inspect.ts

@@ -0,0 +1,126 @@
+import { Readable } from "node:stream";
+import { createGunzip, createGzip } from "node:zlib";
+import * as tar from "tar-stream";
+import { getArchiveEntryMatcher, getFileExtension } from "@/utils/common";
+import { logger } from "@/lib/logger";
+
+const log = logger.child({ module: "features/database/archive-inspect" });
+
+export type UploadKind = "raw" | "targz" | "wrap";
+
+export type InspectResult = {
+  kind: UploadKind;
+  storeExtension: string;
+  innerName?: string;
+};
+
+export class InvalidUploadError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "InvalidUploadError";
+  }
+}
+
+const GZIP_MAGIC_0 = 0x1f;
+const GZIP_MAGIC_1 = 0x8b;
+
+function isGzip(buffer: Buffer): boolean {
+  return (
+    buffer.length >= 2 &&
+    buffer[0] === GZIP_MAGIC_0 &&
+    buffer[1] === GZIP_MAGIC_1
+  );
+}
+
+function listTarEntries(buffer: Buffer): Promise<string[]> {
+  return new Promise<string[]>((resolve, reject) => {
+    const names: string[] = [];
+    const extract = tar.extract();
+
+    extract.on("entry", (header, stream, next) => {
+      names.push(header.name);
+      stream.on("end", next);
+      stream.on("error", reject);
+      stream.resume();
+    });
+    extract.on("finish", () => resolve(names));
+    extract.on("error", reject);
+
+    Readable.from(buffer)
+      .pipe(createGunzip())
+      .on("error", reject)
+      .pipe(extract);
+  });
+}
+
+export async function inspectUpload(
+  buffer: Buffer,
+  dbms: string,
+): Promise<InspectResult> {
+  log.info({ dbms, size: buffer.length }, "Inspecting uploaded backup");
+
+  if (!isGzip(buffer)) {
+    const innerName = `backup${getFileExtension(dbms)}`;
+    log.info(
+      { dbms, innerName },
+      "Native (non-gzip) upload, will wrap into tar.gz before storing",
+    );
+    return { kind: "wrap", storeExtension: ".tar.gz", innerName };
+  }
+
+  let entries: string[];
+  try {
+    entries = await listTarEntries(buffer);
+  } catch (error) {
+    log.info(
+      { dbms, error: error instanceof Error ? error.message : "unknown" },
+      "Gzip is not a tar archive, treating as raw dump",
+    );
+    return { kind: "raw", storeExtension: getFileExtension(dbms) };
+  }
+
+  if (entries.length === 0) {
+    log.info({ dbms }, "Tar archive has no entries, treating as raw dump");
+    return { kind: "raw", storeExtension: getFileExtension(dbms) };
+  }
+
+  const matcher = getArchiveEntryMatcher(dbms);
+  const hasValidEntry = entries.some((name) => matcher.test(name));
+  if (!hasValidEntry) {
+    log.warn(
+      { dbms, entries },
+      "Tar archive does not contain a valid backup for dbms",
+    );
+    throw new InvalidUploadError(
+      `Archive does not contain a valid ${dbms} backup.`,
+    );
+  }
+
+  log.info(
+    { dbms, entryCount: entries.length },
+    "Valid tar.gz backup detected",
+  );
+  return { kind: "targz", storeExtension: ".tar.gz" };
+}
+
+export function packToTarGz(buffer: Buffer, innerName: string): Promise<Buffer> {
+  return new Promise<Buffer>((resolve, reject) => {
+    const pack = tar.pack();
+    const gzip = createGzip();
+    const chunks: Buffer[] = [];
+
+    gzip.on("data", (chunk: Buffer) => chunks.push(chunk));
+    gzip.on("end", () => resolve(Buffer.concat(chunks)));
+    gzip.on("error", reject);
+    pack.on("error", reject);
+
+    pack.pipe(gzip);
+    pack.entry({ name: innerName }, buffer, (err) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      pack.finalize();
+    });
+  });
+}

src/features/logs/actions/job-logs.action.ts

@@ -0,0 +1,32 @@
+"use server";
+import { userAction } from "@/lib/safe-actions/actions";
+import { z } from "zod";
+import { db } from "@/db";
+import { eq } from "drizzle-orm";
+import * as drizzleDb from "@/db";
+import { JobLog } from "@/db/schema/17_job-log";
+
+export const fetchJobLogsAction = userAction
+    .schema(
+        z.object({
+            backupId: z.string().optional(),
+            restorationId: z.string().optional(),
+        }),
+    )
+    .action(async ({ parsedInput }): Promise<JobLog[]> => {
+        const { backupId, restorationId } = parsedInput;
+
+        if (backupId) {
+            return (await db.query.jobLog.findMany({
+                where: eq(drizzleDb.schemas.jobLog.backupId, backupId),
+                orderBy: (l, { asc }) => [asc(l.loggedAt)],
+            })) as JobLog[];
+        }
+        if (restorationId) {
+            return (await db.query.jobLog.findMany({
+                where: eq(drizzleDb.schemas.jobLog.restorationId, restorationId),
+                orderBy: (l, { asc }) => [asc(l.loggedAt)],
+            })) as JobLog[];
+        }
+        return [];
+    });

src/features/logs/components/logs-modal-context.tsx

@@ -17,7 +17,7 @@ export const LogsModalProvider = ({children}: { children: ReactNode }) => {
     const [logs, setLogs] = useState<JobLog[]>([]);
 
     const openModal = (newLogs: JobLog[]) => {
-        setLogs(newLogs);
+        setLogs(newLogs ?? []);
         setOpen(true);
     };
 

src/features/logs/components/logs-modal-trigger.tsx

@@ -1,19 +1,35 @@
-import {FileText} from "lucide-react";
-import {JobLog} from "@/db/schema/17_job-log";
+import {FileText, Loader2} from "lucide-react";
+import {useState} from "react";
+import {toast} from "sonner";
 import {Button} from "@/components/ui/button";
 import {useLogsModal} from "@/features/logs/components/logs-modal-context";
+import {fetchJobLogsAction} from "@/features/logs/actions/job-logs.action";
 
 export type LogsModalTriggerProps = {
-    logs: JobLog[]
+    backupId?: string;
+    restorationId?: string;
+    hasLogs?: boolean;
 }
 
-export const LogsModalTrigger = ({logs}: LogsModalTriggerProps) => {
+export const LogsModalTrigger = ({backupId, restorationId, hasLogs}: LogsModalTriggerProps) => {
     const {openModal} = useLogsModal();
+    const [isLoading, setIsLoading] = useState(false);
+
+    const handleClick = async () => {
+        setIsLoading(true);
+        try {
+            const result = await fetchJobLogsAction({backupId, restorationId});
+            openModal(result?.data ?? []);
+        } catch {
+            toast.error("Failed to load logs.");
+        } finally {
+            setIsLoading(false);
+        }
+    };
+
     return (
-        <Button disabled={logs.length == 0} variant="outline" size="sm" onClick={()=> {
-            openModal(logs);
-        }}>
-            <FileText />
+        <Button disabled={!hasLogs || isLoading} variant="outline" size="sm" onClick={handleClick}>
+            {isLoading ? <Loader2 className="animate-spin"/> : <FileText/>}
         </Button>
-    )
-}
+    );
+};

src/features/logs/components/logs-modal.tsx

@@ -29,11 +29,17 @@ export const LogsModal = () => {
                 </div>
 
                 <div className="min-h-0 flex-1 overflow-y-auto">
-                    <div>
-                        {logs.map((entry: JobLog) => (
-                            <LogRow key={entry.id} entry={entry} />
-                        ))}
-                    </div>
+                    {logs.length === 0 ? (
+                        <div className="flex items-center justify-center py-12 text-sm text-muted-foreground">
+                            No logs available
+                        </div>
+                    ) : (
+                        <div>
+                            {logs.map((entry: JobLog) => (
+                                <LogRow key={entry.id} entry={entry} />
+                            ))}
+                        </div>
+                    )}
                 </div>
             </DialogContent>
         </Dialog>

src/features/migration/actions/migration.action.ts

@@ -4,7 +4,7 @@ import {ServerActionResult} from "@/types/action-type";
 import {z} from "zod";
 import {db} from "@/db";
 import * as drizzleDb from "@/db";
-import {eq, inArray} from "drizzle-orm";
+import {and, eq, inArray, isNull} from "drizzle-orm";
 import {dispatchStorage} from "@/features/storages/utils/storages.dispatch";
 import {v4 as uuidv4} from "uuid";
 import {getTodayISODate} from "@/utils/date-formatting";
@@ -24,7 +24,10 @@ export const migrationAction = userAction.schema(
     try {
 
         const targetDatabase = await db.query.database.findFirst({
-            where: eq(drizzleDb.schemas.database.id, targetDatabaseId),
+            where: and(
+                eq(drizzleDb.schemas.database.id, targetDatabaseId),
+                isNull(drizzleDb.schemas.database.deletedAt),
+            ),
             with: {
                 project: true,
                 retentionPolicy: true,

src/features/onboarding/constants/steps.ts

@@ -2,6 +2,7 @@ export const STEP_IDS = {
   LOGIN: "login",
   ACCOUNT_INFO: "account-info",
   SECURITY: "security",
+  PREFERENCES: "preferences",
   ORG_CREATE: "org-create",
   //INVITE_MEMBERS: "invite-members",
   NOTIFIER: "notifier",
@@ -19,6 +20,7 @@ export const STEP_ORDER: string[] = [
   STEP_IDS.LOGIN,
   STEP_IDS.ACCOUNT_INFO,
   STEP_IDS.SECURITY,
+  STEP_IDS.PREFERENCES,
   STEP_IDS.ORG_CREATE,
   //STEP_IDS.INVITE_MEMBERS,
   STEP_IDS.NOTIFIER,

src/features/onboarding/onboarding-checklist.tsx

@@ -61,9 +61,9 @@ export const OnboardingChecklist = () => {
 
               <p
                 className={cn(
-                  "text-sm pb-4",
+                  "text-sm pb-4 ",
                   isCompleted && "text-zinc-400",
-                  isCurrent && "text-white font-medium",
+                  isCurrent && "text-primary font-medium",
                   !isCompleted && !isCurrent && "text-zinc-600",
                 )}
               >

src/features/onboarding/onboarding-state.ts

@@ -84,8 +84,8 @@ export async function resolveOnboardingState(): Promise<ResolvedOnboardingState>
 
   const org = await getUserOwnOrganization(user.id);
   if (!org) {
-    meta.resumeStepId = "org-create";
-    return { stepId: "org-create", flowData: { meta } };
+    meta.resumeStepId = "preferences";
+    return { stepId: "preferences", flowData: { meta } };
   }
 
   const orgData = { id: org.id, name: org.name };

src/features/onboarding/onboarding-steps.tsx

@@ -2,6 +2,7 @@ import { OnboardingStep } from "@onboardjs/react";
 import { StepLogin } from "@/features/onboarding/steps/step-login";
 import { StepAccountInfo } from "@/features/onboarding/steps/step-account-info";
 import { StepSecurity } from "@/features/onboarding/steps/step-security";
+import { StepPreferences } from "@/features/onboarding/steps/step-preferences";
 import { StepOrgCreate } from "@/features/onboarding/steps/step-org-create";
 import { StepInviteMembers } from "@/features/onboarding/steps/step-invite-members";
 import { StepNotifier } from "@/features/onboarding/steps/step-notifier";
@@ -20,19 +21,26 @@ export const onboardingSteps: OnboardingStep[] = [
     component: StepLogin,
     isSkippable: false,
     nextStep: (ctx: any) =>
-      ctx.flowData?.meta?.hasExistingUsers ? "org-create" : "account-info",
+      ctx.flowData?.meta?.hasExistingUsers ? "preferences" : "account-info",
   },
   {
     id: "account-info",
     component: StepAccountInfo,
     isSkippable: false,
     nextStep: (ctx: any) =>
-      ctx.flowData?.meta?.passkeyEnabled ? "org-create" : "security",
+      ctx.flowData?.meta?.passkeyEnabled ? "preferences" : "security",
   },
   {
     id: "security",
     component: StepSecurity,
     isSkippable: true,
+    skipToStep: "preferences",
+    nextStep: "preferences",
+  },
+  {
+    id: "preferences",
+    component: StepPreferences,
+    isSkippable: true,
     skipToStep: "org-create",
     nextStep: "org-create",
   },

src/features/onboarding/steps/step-agent-create.tsx

@@ -70,7 +70,16 @@ export const StepAgentCreate = () => {
         </Button>
       </div>
 
-      <Button type="button" onClick={() => next()}>
+      <Button
+        type="button"
+        onClick={() => next()}
+        disabled={!!name.trim() || createAgent.isPending}
+        title={
+          name.trim()
+            ? "Add or clear the agent name before continuing"
+            : undefined
+        }
+      >
         Continue
       </Button>
     </div>

src/features/onboarding/steps/step-defaults.tsx

@@ -35,6 +35,8 @@ export const StepDefaults = () => {
   const [storageId, setStorageId] = useState<string | undefined>(
     existingDefaults.storageId || undefined,
   );
+  const [notifierOpen, setNotifierOpen] = useState(false);
+  const [storageOpen, setStorageOpen] = useState(false);
 
   const selectNotifier = async (value: string) => {
     const prev = notifierId;
@@ -56,6 +58,26 @@ export const StepDefaults = () => {
     }
   };
 
+  const clearNotifier = async () => {
+    const prev = notifierId;
+    setNotifierId(undefined);
+    try {
+      await updateNotificationSettingsAction({
+        name: "system",
+        data: { notificationChannelId: null },
+      });
+      await updateContext({
+        flowData: {
+          ...state?.context.flowData,
+          defaults: { notifierId: undefined, storageId },
+        },
+      });
+    } catch {
+      setNotifierId(prev);
+      toast.error("Failed to clear default notifier");
+    }
+  };
+
   const selectStorage = async (value: string) => {
     const prev = storageId;
     setStorageId(value);
@@ -76,6 +98,26 @@ export const StepDefaults = () => {
     }
   };
 
+  const clearStorage = async () => {
+    const prev = storageId;
+    setStorageId(undefined);
+    try {
+      await updateStorageSettingsAction({
+        name: "system",
+        data: { storageChannelId: null, encryption: false },
+      });
+      await updateContext({
+        flowData: {
+          ...state?.context.flowData,
+          defaults: { notifierId, storageId: undefined },
+        },
+      });
+    } catch {
+      setStorageId(prev);
+      toast.error("Failed to clear default storage");
+    }
+  };
+
   const onContinue = async () => {
     await updateContext({
       flowData: {
@@ -102,8 +144,10 @@ export const StepDefaults = () => {
         <div className="flex flex-col gap-2">
           <Label>Default notifier</Label>
           <Select
-            value={selectedNotifier ? notifierId : undefined}
+            value={selectedNotifier ? notifierId : ""}
             onValueChange={selectNotifier}
+            open={notifierOpen}
+            onOpenChange={setNotifierOpen}
             disabled={notifiers.length === 0}
           >
             <SelectTrigger className="w-full">
@@ -128,7 +172,17 @@ export const StepDefaults = () => {
             </SelectTrigger>
             <SelectContent>
               {notifiers.map((n) => (
-                <SelectItem key={n.id} value={n.id}>
+                <SelectItem
+                  key={n.id}
+                  value={n.id}
+                  onPointerUp={(e) => {
+                    if (n.id === notifierId) {
+                      e.preventDefault();
+                      clearNotifier();
+                      setNotifierOpen(false);
+                    }
+                  }}
+                >
                   <div className="flex items-center gap-2 w-full min-w-0">
                     <div className="text-muted-foreground scale-90 shrink-0">
                       {getChannelIcon(n.provider)}
@@ -149,8 +203,10 @@ export const StepDefaults = () => {
         <div className="flex flex-col gap-2">
           <Label>Default storage</Label>
           <Select
-            value={selectedStorage ? storageId : undefined}
+            value={selectedStorage ? storageId : ""}
             onValueChange={selectStorage}
+            open={storageOpen}
+            onOpenChange={setStorageOpen}
             disabled={storages.length === 0}
           >
             <SelectTrigger className="w-full">
@@ -175,7 +231,17 @@ export const StepDefaults = () => {
             </SelectTrigger>
             <SelectContent>
               {storages.map((s) => (
-                <SelectItem key={s.id} value={s.id}>
+                <SelectItem
+                  key={s.id}
+                  value={s.id}
+                  onPointerUp={(e) => {
+                    if (s.id === storageId) {
+                      e.preventDefault();
+                      clearStorage();
+                      setStorageOpen(false);
+                    }
+                  }}
+                >
                   <div className="flex items-center gap-2 w-full min-w-0">
                     <div className="text-muted-foreground scale-90 shrink-0">
                       {getChannelIcon(s.provider)}

src/features/onboarding/steps/step-preferences.tsx

@@ -0,0 +1,56 @@
+"use client";
+
+import { useOnboarding } from "@onboardjs/react";
+import { useTheme } from "next-themes";
+import { toast } from "sonner";
+import { Button } from "@/components/ui/button";
+import { authClient } from "@/lib/auth/auth-client";
+import { ThemeKey, ThemeSelector } from "@/components/common/theme-selector";
+
+export const StepPreferences = () => {
+  const { next, updateContext, state } = useOnboarding();
+  const { theme: currentTheme, setTheme } = useTheme();
+  const preferences = state?.context.flowData.preferences ?? {
+    theme: (currentTheme ?? "system") as ThemeKey,
+  };
+
+  const selectTheme = async (theme: ThemeKey) => {
+    setTheme(theme);
+    try {
+      await authClient.updateUser({ theme });
+      await updateContext({
+        flowData: {
+          ...state?.context.flowData,
+          preferences: { ...preferences, theme },
+        },
+      });
+    } catch {
+      toast.error("Failed to save theme preference");
+      setTheme(preferences.theme as ThemeKey);
+    }
+  };
+
+  const onContinue = async () => {
+    await next();
+  };
+
+  return (
+    <div className="flex flex-col gap-6">
+      <div>
+        <h1 className="text-2xl font-semibold">Your preferences</h1>
+        <p className="text-sm text-muted-foreground mt-1">
+          Optional — personalise your workspace.
+        </p>
+      </div>
+
+      <div className="flex flex-col gap-2">
+        <p className="text-sm font-medium">Theme</p>
+        <ThemeSelector value={preferences.theme} onSelect={selectTheme} />
+      </div>
+
+      <Button type="button" onClick={onContinue}>
+        Continue
+      </Button>
+    </div>
+  );
+};

src/features/projects/actions/projects.action.ts

@@ -5,7 +5,7 @@ import {ProjectSchema} from "@/features/projects/schemas/projects.schema";
 import {z} from "zod";
 import {ServerActionResult} from "@/types/action-type";
 import {db} from "@/db";
-import {and, eq, inArray} from "drizzle-orm";
+import {and, eq, inArray, isNull} from "drizzle-orm";
 import {Project} from "@/db/schema/06_project";
 import * as drizzleDb from "@/db";
 import {Database} from "@/db/schema/07_database";
@@ -88,7 +88,9 @@ export const updateProjectAction = userAction
             const existing = await db.query.project.findFirst({
                 where: eq(drizzleDb.schemas.project.id, parsedInput.projectId),
                 with: {
-                    databases: true,
+                    databases: {
+                        where: isNull(drizzleDb.schemas.database.deletedAt),
+                    },
                 },
             });
 

src/features/projects/components/bulk-action-bar.tsx

@@ -0,0 +1,37 @@
+"use client";
+
+import {DatabaseZap, RotateCcw, X, Loader2} from "lucide-react";
+import {Button} from "@/components/ui/button";
+
+export type BulkActionBarProps = {
+    count: number;
+    isPending: boolean;
+    onBackup: () => void;
+    onRestore: () => void;
+    onClear: () => void;
+};
+
+export const BulkActionBar = ({count, isPending, onBackup, onRestore, onClear}: BulkActionBarProps) => {
+    if (count === 0) return null;
+    return (
+        <div
+            className="fixed bottom-4 sm:bottom-6 left-1/2 -translate-x-1/2 z-50 flex items-center gap-2 sm:gap-3 rounded-xl border border-primary/50 bg-card shadow-lg px-3 sm:px-4 py-2 sm:py-3 max-w-[calc(100vw-1.5rem)]">
+            <span className="flex-shrink-0 rounded-full bg-primary text-primary-foreground text-xs font-bold px-2.5 sm:px-3 py-1">
+                {count}
+                <span className="hidden sm:inline"> selected</span>
+            </span>
+            <Button size="sm" variant="outline" onClick={onBackup} disabled={isPending} title="Backup">
+                {isPending ? <Loader2 className="animate-spin"/> : <DatabaseZap/>}
+                <span className="hidden sm:inline">Backup</span>
+            </Button>
+            <Button size="sm" variant="outline" onClick={onRestore} disabled={isPending} title="Restore latest">
+                <RotateCcw/>
+                <span className="hidden sm:inline">Restore latest</span>
+            </Button>
+            <Button size="sm" variant="ghost" onClick={onClear} disabled={isPending} title="Clear">
+                <X/>
+                <span className="hidden sm:inline">Clear</span>
+            </Button>
+        </div>
+    );
+};

src/features/projects/components/bulk-restore-modal.tsx

@@ -0,0 +1,84 @@
+"use client";
+
+import {useState} from "react";
+import {Loader2} from "lucide-react";
+import {Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter} from "@/components/ui/dialog";
+import {Button} from "@/components/ui/button";
+import {Input} from "@/components/ui/input";
+import type {RestorePreviewRow} from "@/features/database/actions/bulk-restore.action";
+
+const CONFIRM_WORD = "restore";
+
+export type BulkRestoreModalProps = {
+    open: boolean;
+    loading: boolean;
+    submitting: boolean;
+    rows: RestorePreviewRow[];
+    onConfirm: () => void;
+    onCancel: () => void;
+};
+
+export const BulkRestoreModal = (props: BulkRestoreModalProps) => {
+    const {open, loading, submitting, rows, onConfirm, onCancel} = props;
+    const [typed, setTyped] = useState("");
+
+    const restorableCount = rows.filter((r) => r.restorable).length;
+    const canConfirm = restorableCount > 0 && typed.trim().toLowerCase() === CONFIRM_WORD && !submitting;
+
+    return (
+        <Dialog open={open} onOpenChange={(o) => (!o ? onCancel() : undefined)}>
+            <DialogContent>
+                <DialogHeader>
+                    <DialogTitle>
+                        Restore {rows.length} database(s) to latest backup
+                    </DialogTitle>
+                </DialogHeader>
+                <p className="text-sm text-muted-foreground">
+                    This overwrites current data and cannot be undone.
+                </p>
+
+                {loading ? (
+                    <div className="flex items-center justify-center py-8"><Loader2 className="animate-spin" /></div>
+                ) : (
+                    <div className="max-h-64 overflow-auto rounded-md border">
+                        <table className="w-full text-sm">
+                            <thead>
+                                <tr className="text-left text-muted-foreground border-b">
+                                    <th className="p-2">Database</th>
+                                    <th className="p-2">Will restore from</th>
+                                </tr>
+                            </thead>
+                            <tbody>
+                                {rows.map((r) => (
+                                    <tr key={r.databaseId} className="border-b last:border-0">
+                                        <td className={`p-2 ${r.restorable ? "" : "opacity-50"}`}>{r.name}</td>
+                                        <td className="p-2">
+                                            {r.restorable
+                                                ? <span className="text-green-600">{r.backupDate ? new Date(r.backupDate).toLocaleString() : "latest backup"}</span>
+                                                : <span className="text-amber-500">{r.reason ?? "no successful backup"} — skipped</span>}
+                                        </td>
+                                    </tr>
+                                ))}
+                            </tbody>
+                        </table>
+                    </div>
+                )}
+
+                {restorableCount > 0 && (
+                    <div className="space-y-1">
+                        <label className="text-xs text-muted-foreground">Type &quot;{CONFIRM_WORD}&quot; to confirm</label>
+                        <Input value={typed} onChange={(e) => setTyped(e.target.value)} placeholder={CONFIRM_WORD} />
+                    </div>
+                )}
+
+                <DialogFooter>
+                    <Button variant="outline" onClick={onCancel} disabled={submitting}>Cancel</Button>
+                    <Button  onClick={onConfirm} disabled={!canConfirm}>
+                        {submitting && <Loader2 className="animate-spin" />}
+                        {restorableCount > 0 ? `Restore ${restorableCount} database(s)` : "Nothing to restore"}
+                    </Button>
+                </DialogFooter>
+            </DialogContent>
+        </Dialog>
+    );
+};

src/features/projects/components/project-database-selection.tsx

@@ -0,0 +1,176 @@
+"use client";
+
+import {useMemo, useState} from "react";
+import Link from "next/link";
+import {useRouter} from "next/navigation";
+import {useQueryClient} from "@tanstack/react-query";
+import {toast} from "sonner";
+
+import {Database} from "@/db/schema/07_database";
+import {DatabaseCard} from "@/components/common/database-card";
+import {Button} from "@/components/ui/button";
+import {PaginationNavigation} from "@/components/common/pagination-navigation";
+import {PaginationSize} from "@/components/common/pagination-size";
+import {BulkActionBar} from "@/features/projects/components/bulk-action-bar";
+import {BulkRestoreModal} from "@/features/projects/components/bulk-restore-modal";
+import {bulkBackupAction} from "@/features/database/actions/bulk-backup.action";
+import {
+    bulkRestorePreviewAction,
+    bulkRestoreLatestAction,
+    type RestorePreviewRow,
+} from "@/features/database/actions/bulk-restore.action";
+
+export type ProjectDatabaseSelectionProps = {
+    projectId: string;
+    databases: Database[];
+};
+
+export const ProjectDatabaseSelection = ({projectId, databases}: ProjectDatabaseSelectionProps) => {
+    const router = useRouter();
+    const queryClient = useQueryClient();
+
+    const [selected, setSelected] = useState<Set<string>>(new Set());
+    const [pageSize, setPageSize] = useState(20);
+    const [currentPage, setCurrentPage] = useState(1);
+    const [pending, setPending] = useState(false);
+
+    const [restoreOpen, setRestoreOpen] = useState(false);
+    const [previewLoading, setPreviewLoading] = useState(false);
+    const [previewRows, setPreviewRows] = useState<RestorePreviewRow[]>([]);
+
+    const sorted = useMemo(
+        () => [...databases].sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()),
+        [databases],
+    );
+    const totalPages = Math.max(1, Math.ceil(sorted.length / pageSize));
+    const pageItems = sorted.slice((currentPage - 1) * pageSize, currentPage * pageSize);
+    const selectedIds = Array.from(selected);
+
+    const toggle = (id: string) =>
+        setSelected((prev) => {
+            const next = new Set(prev);
+            if (next.has(id)) {
+                next.delete(id);
+            } else {
+                next.add(id);
+            }
+            return next;
+        });
+
+    const selectAll = () => setSelected(new Set(sorted.map((d) => d.id)));
+    const clear = () => setSelected(new Set());
+
+    const afterQueue = () => {
+        clear();
+        queryClient.invalidateQueries({queryKey: ["database-data"]});
+        router.refresh();
+    };
+
+    const handleBackup = async () => {
+        setPending(true);
+        const res = await bulkBackupAction({projectId, databaseIds: selectedIds});
+        setPending(false);
+        const data = res?.data;
+        if (data?.success) {
+            toast.success(data.actionSuccess?.message ?? "Backups queued.");
+            afterQueue();
+        } else {
+            toast.error(res?.serverError ?? data?.actionError?.message ?? "Failed to queue backups.");
+        }
+    };
+
+    const openRestore = async () => {
+        setRestoreOpen(true);
+        setPreviewLoading(true);
+        const res = await bulkRestorePreviewAction({projectId, databaseIds: selectedIds});
+        setPreviewLoading(false);
+        if (res?.data?.success && res.data.value) {
+            setPreviewRows(res.data.value);
+        } else {
+            toast.error(res?.serverError ?? "Failed to build preview.");
+            setRestoreOpen(false);
+        }
+    };
+
+    const confirmRestore = async () => {
+        setPending(true);
+        const res = await bulkRestoreLatestAction({projectId, databaseIds: selectedIds});
+        setPending(false);
+        setRestoreOpen(false);
+        const data = res?.data;
+        if (data?.success) {
+            toast.success(data.actionSuccess?.message ?? "Restores queued.");
+            afterQueue();
+        } else {
+            toast.error(res?.serverError ?? data?.actionError?.message ?? "Failed to queue restores.");
+        }
+    };
+
+    return (
+        <div className="flex flex-col h-full justify-between">
+            <div>
+                <div className="flex items-center justify-between mb-3">
+                    <span className="text-sm text-muted-foreground">{selected.size} selected</span>
+                    <div className="flex gap-2">
+                        <Button variant="outline" size="sm" onClick={selectAll}>Select all</Button>
+                        <Button variant="ghost" size="sm" onClick={clear} disabled={selected.size === 0}>Clear</Button>
+                    </div>
+                </div>
+
+                <div className="grid h-max auto-rows-min gap-4 md:grid-cols-3">
+                    {pageItems.map((database) => (
+                        <Link
+                            key={database.id}
+                            className="group block transition-all duration-200 outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 rounded-xl"
+                            href={`/dashboard/projects/${projectId}/database/${database.id}`}
+                        >
+                            <DatabaseCard
+                                data={database}
+                                selectable
+                                selected={selected.has(database.id)}
+                                onToggleSelect={toggle}
+                            />
+                        </Link>
+                    ))}
+                </div>
+            </div>
+
+            <div className="flex items-center justify-end mt-4 gap-4">
+                <PaginationSize
+                    pageSize={pageSize}
+                    onPageSizeChange={(size) => {
+                        setPageSize(size);
+                        setCurrentPage(1);
+                    }}
+                    pageSizeOptions={[10, 20, 50]}
+                />
+                <PaginationNavigation
+                    className="justify-end"
+                    totalPages={totalPages}
+                    currentPage={currentPage}
+                    goToPage={setCurrentPage}
+                    goToPrevPage={() => setCurrentPage(Math.max(1, currentPage - 1))}
+                    goToNextPage={() => setCurrentPage(Math.min(totalPages, currentPage + 1))}
+                    maxVisiblePages={3}
+                />
+            </div>
+
+            <BulkActionBar
+                count={selected.size}
+                isPending={pending}
+                onBackup={handleBackup}
+                onRestore={openRestore}
+                onClear={clear}
+            />
+
+            <BulkRestoreModal
+                open={restoreOpen}
+                loading={previewLoading}
+                submitting={pending}
+                rows={previewRows}
+                onConfirm={confirmRestore}
+                onCancel={() => setRestoreOpen(false)}
+            />
+        </div>
+    );
+};

src/features/settings/actions/storage.action.ts

@@ -24,7 +24,7 @@ export const updateStorageSettingsAction = userAction
             const [updatedSettings] = await db
                 .update(drizzleDb.schemas.setting)
                 .set(withUpdatedAt({
-                    defaultStorageChannelId: data.storageChannelId,
+                    defaultStorageChannelId: data.storageChannelId ?? null,
                     encryption: data.encryption,
                 }))
                 .where(eq(drizzleDb.schemas.setting.name, name))

src/features/settings/schemas/storage.schema.ts

@@ -1,7 +1,7 @@
 import {z} from "zod";
 
 export const DefaultStorageSchema = z.object({
-    storageChannelId: z.string(),
+    storageChannelId: z.string().optional().nullable(),
     encryption: z.boolean(),
 });
 

src/features/theme/components/mode-toggle.tsx

@@ -20,11 +20,12 @@ const themes = [
 ] as const
 
 export function ModeToggle() {
-    const { theme } = useTheme()
+    const { theme, setTheme } = useTheme()
     const [mounted, setMounted] = useState(false)
     useEffect(() => setMounted(true), [])
 
     const handleThemeChange = async (newTheme: "light" | "system" | "dark") => {
+        setTheme(newTheme)
         await authClient.updateUser({ theme: newTheme })
     }
 

src/hooks/use-server-data-table.ts

@@ -0,0 +1,106 @@
+import { keepPreviousData, useQuery } from "@tanstack/react-query";
+import type { PaginationState, SortingState } from "@tanstack/react-table";
+import { useEffect, useState } from "react";
+
+interface PaginatedResult<TData> {
+    data: TData[];
+    meta: {
+        total: number;
+        page: number;
+        pageSize: number;
+        totalPages: number;
+        [key: string]: any;
+    };
+}
+
+interface UseServerDataTableProps<TData, TParams> {
+    fetchAction: any;
+    queryKey: any[];
+    extraParams?: Partial<TParams>;
+    initialPageSize?: number;
+    initialSorting?: SortingState;
+    enabled?: boolean;
+    refetchInterval?: number | false;
+}
+
+const EMPTY_ARRAY: any[] = [];
+
+export function useServerDataTable<TData, TParams>(
+    props: UseServerDataTableProps<TData, TParams>,
+) {
+    const {
+        fetchAction,
+        queryKey,
+        extraParams,
+        initialPageSize = 20,
+        initialSorting = [],
+        enabled = true,
+        refetchInterval = false,
+    } = props;
+
+    const [pagination, setPagination] = useState<PaginationState>({
+        pageIndex: 0,
+        pageSize: initialPageSize,
+    });
+    const [sorting, setSorting] = useState<SortingState>(initialSorting);
+
+    useEffect(() => {
+        setPagination((prev) => ({ ...prev, pageIndex: 0 }));
+    }, [sorting]);
+
+    useEffect(() => {
+        setPagination((prev) => ({ ...prev, pageIndex: 0 }));
+    }, [JSON.stringify(extraParams)]);
+
+    const query = useQuery({
+        queryKey: [
+            ...queryKey,
+            pagination.pageIndex,
+            pagination.pageSize,
+            sorting,
+            JSON.stringify(extraParams),
+        ],
+        queryFn: async () => {
+            const response = await fetchAction({
+                page: pagination.pageIndex + 1,
+                pageSize: pagination.pageSize,
+                sorting,
+                ...extraParams,
+            } as any);
+
+            const result = response?.data as PaginatedResult<TData> | undefined;
+            if (!result || !Array.isArray(result.data)) {
+                throw new Error("Failed to fetch paginated data");
+            }
+            return result;
+        },
+        placeholderData: keepPreviousData,
+        enabled,
+        gcTime: 2 * 60 * 1000,
+        staleTime: 30 * 1000,
+        refetchInterval,
+        refetchOnWindowFocus: true,
+        retry: 1,
+    });
+
+    return {
+        data: (query.data?.data as TData[]) || EMPTY_ARRAY,
+        rowCount: query.data?.meta?.total || 0,
+        pagination,
+        onPaginationChange: setPagination,
+        sorting,
+        onSortingChange: setSorting,
+        tableProps: {
+            manualPagination: true as const,
+            rowCount: query.data?.meta?.total || 0,
+            paginationState: pagination,
+            onPaginationChange: setPagination,
+            sorting,
+            onSortingChange: setSorting,
+        },
+        meta: query.data?.meta,
+        isLoading: query.isPending,
+        isFetching: query.isFetching,
+        refetch: query.refetch,
+    };
+}

src/lib/api-v1/services/backups.ts

@@ -1,14 +1,17 @@
 import {ApiKeyContextUser} from "@/lib/api-v1/types";
 import {getAccessibleDatabaseIds} from "@/lib/api-v1/services/databases";
 import {db} from "@/db";
-import {eq} from "drizzle-orm";
+import {and, eq, isNull} from "drizzle-orm";
 import * as drizzleDb from "@/db";
 
 export async function resolveDatabaseAccess(id: string, user: ApiKeyContextUser) {
     const accessibleIds = await getAccessibleDatabaseIds(user);
     if (accessibleIds.includes(id)) return "ok";
     const exists = await db.query.database.findFirst({
-        where: eq(drizzleDb.schemas.database.id, id),
+        where: and(
+            eq(drizzleDb.schemas.database.id, id),
+            isNull(drizzleDb.schemas.database.deletedAt),
+        ),
         columns: { id: true },
     });
     return exists ? "forbidden" : "not_found";

src/lib/tasks/cleaning/index.ts

@@ -1,8 +1,10 @@
 import {db} from "@/db";
-import {and, eq, isNotNull, isNull} from "drizzle-orm";
+import {and, eq, isNotNull, isNull, lt} from "drizzle-orm";
 import * as drizzleDb from "@/db";
 import {withUpdatedAt} from "@/db/utils";
 import {logger} from "@/lib/logger";
+import {env} from "@/env.mjs";
+import {sendNotificationsBackupRestore} from "@/features/notifications/utils/notifications.helpers";
 
 const log = logger.child({module: "tasks/cleaning"});
 
@@ -23,6 +25,39 @@ export const backupCleanTask = async () => {
                 .where(eq(drizzleDb.schemas.backup.id, backup.id));
         }
 
+        const staleCutoff = new Date(Date.now() - env.STALE_BACKUP_THRESHOLD_HOURS * 60 * 60 * 1000);
+
+        const staleOngoingBackups = await db.query.backup.findMany({
+            where: and(
+                isNull(drizzleDb.schemas.backup.deletedAt),
+                eq(drizzleDb.schemas.backup.status, "ongoing"),
+                lt(drizzleDb.schemas.backup.createdAt, staleCutoff)
+            )
+        });
+        log.debug(`Stale ongoing backups to fail: ${staleOngoingBackups.length}`);
+
+        for (const backup of staleOngoingBackups) {
+            await db.update(drizzleDb.schemas.backup).set(withUpdatedAt({
+                status: "failed",
+            }))
+                .where(eq(drizzleDb.schemas.backup.id, backup.id));
+
+            try {
+                const database = await db.query.database.findFirst({
+                    where: and(
+                        eq(drizzleDb.schemas.database.id, backup.databaseId),
+                        isNull(drizzleDb.schemas.database.deletedAt),
+                    ),
+                    with: {alertPolicies: true},
+                });
+                if (database) {
+                    await sendNotificationsBackupRestore(database, "error_backup");
+                }
+            } catch (notifyError) {
+                log.error({name: "backupCleanTask", error: notifyError}, "Stale backup notification failed");
+            }
+        }
+
         const failedBackups = await db.query.backup.findMany({
             where: and(
                 isNull(drizzleDb.schemas.backup.deletedAt),

src/lib/tasks/database/index.ts

@@ -12,6 +12,7 @@ const log = logger.child({ module: "tasks/database" });
 export const retentionCleanTask = async () => {
   try {
     const databases = await db.query.database.findMany({
+      where: isNull(drizzleDb.schemas.database.deletedAt),
       with: {
         retentionPolicy: true,
         backups: {

src/utils/common.ts

@@ -50,41 +50,77 @@ export function getFileExtension(dbType: string) {
   }
 }
 
+const GZIP_ACCEPT: Record<string, string[]> = {
+  "application/gzip": [".tar.gz", ".tgz"],
+  "application/x-gzip": [".tar.gz", ".tgz"],
+};
+
+function mergeAccept(
+  base: Record<string, string[]>,
+  extra: Record<string, string[]>,
+): Record<string, string[]> {
+  const out: Record<string, string[]> = { ...base };
+  for (const [mime, exts] of Object.entries(extra)) {
+    out[mime] = Array.from(new Set([...(out[mime] ?? []), ...exts]));
+  }
+  return out;
+}
+
 export function getFileHeadersBasedOnDbms(
   dbType: string,
 ): Record<string, string[]> {
+  let base: Record<string, string[]>;
   switch (dbType) {
     case "postgresql":
-      return {
-        "application/octet-stream": [".dump"],
-      };
+      base = { "application/octet-stream": [".dump"] };
+      break;
     case "mysql":
     case "mariadb":
-      return {
+      base = {
         "application/sql": [".sql"],
         "application/x-sql": [".sql"],
       };
+      break;
     case "mongodb":
-      return {
-        "application/gzip": [".archive.gz"],
-      };
+      base = { "application/gzip": [".archive.gz"] };
+      break;
     case "firebird":
-      return {
-        "application/octet-stream": [".fbk"],
-      };
+      base = { "application/octet-stream": [".fbk"] };
+      break;
     case "valkey":
     case "redis":
-      return {
-        "application/octet-stream": [".rdb"],
-      };
+      base = { "application/octet-stream": [".rdb"] };
+      break;
     case "sqlite":
-      return {
-        "application/octet-stream": [".backup"],
-      };
+      base = { "application/octet-stream": [".backup"] };
+      break;
     case "mssql":
-      return {
-        "application/octet-stream": [".bacpac"],
-      };
+      base = { "application/octet-stream": [".bacpac"] };
+      break;
+    default:
+      throw new Error(`Unsupported database type: ${dbType}`);
+  }
+  return mergeAccept(base, GZIP_ACCEPT);
+}
+
+export function getArchiveEntryMatcher(dbType: string): RegExp {
+  switch (dbType) {
+    case "postgresql":
+      return /(\.dump$|\.dmp$|(^|\/)toc\.dat$)/i;
+    case "mysql":
+    case "mariadb":
+      return /\.sql$/i;
+    case "mongodb":
+      return /(\.archive(\.gz)?$|\.bson(\.gz)?$)/i;
+    case "valkey":
+    case "redis":
+      return /\.rdb$/i;
+    case "sqlite":
+      return /(\.backup$|\.sqlite$|\.db$)/i;
+    case "firebird":
+      return /\.fbk$/i;
+    case "mssql":
+      return /\.bacpac$/i;
     default:
       throw new Error(`Unsupported database type: ${dbType}`);
   }

src/utils/cron.ts

@@ -1,10 +1,47 @@
+const cronBounds: Record<string, [number, number]> = {
+    minute: [0, 59],
+    hour: [0, 23],
+    "day-of-month": [1, 31],
+    month: [1, 12],
+    "day-of-week": [0, 6],
+};
+
+const isNumberInRange = (value: string, min: number, max: number): boolean => {
+    if (!/^\d+$/.test(value)) return false;
+    const n = Number(value);
+    return n >= min && n <= max;
+};
+
+const isRangeOrNumber = (value: string, min: number, max: number): boolean => {
+    const range = value.match(/^(\d+)-(\d+)$/);
+    if (range) {
+        const start = Number(range[1]);
+        const end = Number(range[2]);
+        return isNumberInRange(range[1], min, max) && isNumberInRange(range[2], min, max) && start <= end;
+    }
+    return isNumberInRange(value, min, max);
+};
+
 export const isValidCronPart = (type: string, value: string): boolean => {
-    const regexMap: Record<string, RegExp> = {
-        minute: /^(\*|([0-5]?\d)|(\d+(,\d+)*|(\d+-\d+)|(\*\/\d+)))$/,
-        hour: /^(\*|([01]?\d|2[0-3])|(\d+(,\d+)*|(\d+-\d+)|(\*\/\d+)))$/,
-        "day-of-month": /^(\*|([1-9]|[12]\d|3[01])|(\d+(,\d+)*|(\d+-\d+)|(\*\/\d+)))$/,
-        month: /^(\*|([1-9]|1[0-2])|(\d+(,\d+)*|(\d+-\d+)|(\*\/\d+)))$/,
-        "day-of-week": /^(\*|[0-6]|(\d+(,\d+)*|(\d+-\d+)|(\*\/\d+)))$/,
-    };
-    return regexMap[type]?.test(value) ?? false;
-};
+    const bounds = cronBounds[type];
+    if (!bounds) return false;
+    const [min, max] = bounds;
+
+    return value.split(",").every((rawPart) => {
+        const part = rawPart.trim();
+        if (part === "") return false;
+
+        const step = part.match(/^(.+)\/(\d+)$/);
+        if (step) {
+            const base = step[1];
+            const stepValue = Number(step[2]);
+            if (!/^\d+$/.test(step[2]) || stepValue < 1 || stepValue > max) return false;
+            if (base === "*") return true;
+            return isRangeOrNumber(base, min, max);
+        }
+
+        if (part === "*") return true;
+
+        return isRangeOrNumber(part, min, max);
+    });
+};

src/utils/status-crypto.ts

@@ -0,0 +1,50 @@
+import crypto from "node:crypto";
+
+/**
+ * Minimum agent version (its own CARGO_PKG_VERSION) that understands the
+ * encrypted storages envelope. Older agents receive legacy plaintext.
+ */
+export const MIN_AGENT_VERSION_STORAGE_ENC = "1.17.0";
+
+/**
+ * Encrypt the storages payload with AES-256-GCM using the raw 32-byte master
+ * key. Wire layout: base64( iv(12) ‖ ciphertext ‖ authTag(16) ).
+ */
+export function encryptStorages(storages: unknown, masterKey: Buffer): string {
+  const iv = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv("aes-256-gcm", masterKey, iv);
+  const plaintext = Buffer.from(JSON.stringify(storages), "utf-8");
+  const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return Buffer.concat([iv, ciphertext, tag]).toString("base64");
+}
+
+/**
+ * Numeric major.minor.patch comparison. Returns false when either version is
+ * missing or cannot be parsed as three non-negative integers (fail safe).
+ */
+export function isAgentVersionAtLeast(
+  reported: string | undefined,
+  min: string,
+): boolean {
+  const parse = (v: string): [number, number, number] | null => {
+    const core = v.trim().split(/[-+]/)[0];
+    const parts = core.split(".");
+    if (parts.length !== 3) return null;
+    if (!parts.every((p) => /^\d+$/.test(p))) return null;
+    const nums = parts.map((p) => Number(p));
+    if (nums.some((n) => !Number.isInteger(n) || n < 0)) return null;
+    return [nums[0], nums[1], nums[2]];
+  };
+
+  if (!reported) return false;
+  const a = parse(reported);
+  const b = parse(min);
+  if (!a || !b) return false;
+
+  for (let i = 0; i < 3; i++) {
+    if (a[i] > b[i]) return true;
+    if (a[i] < b[i]) return false;
+  }
+  return true;
+}

src/utils/text.ts

@@ -10,8 +10,8 @@ export function capitalizeFirstLetter(text: string): string {
 }
 
 export function isUUID(str: string) {
-  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
-    str,
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-7][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
+      str,
   );
 }