From 07320a3925d3592b432a3ce0309bd0d7b9451347 Mon Sep 17 00:00:00 2001
From: Bradley Nelson <bradley@nel.family>
Date: Thu, 25 Jun 2026 01:07:03 -0600
Subject: [PATCH] =?UTF-8?q?feat(mounts):=20P4=20=E2=80=94=20admin=20CRUD?=
 =?UTF-8?q?=20endpoints=20+=20frontend=20admin=20tab?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Mounts are now configurable at runtime without DB surgery.

Backend (admin-gated, /api/admin/external-mounts):
- GET    list all configured mounts
- POST   create: validate the provider config up front, create a mount-root
         folder under the admin's drive, insert the row, hot-reload the registry
- DELETE remove the mount row + its root folder (host content is left intact),
         then hot-reload
- ExternalMountRepositoryPort gains create/delete (PG impl); registry.reload()
  runs in-process so changes are live immediately
- audit lines event="external_mount.config" action=create|delete

Frontend:
- admin.ts endpoints: listExternalMounts / createExternalMount / deleteExternalMount
- new "External Mounts" tab in the admin page: add form (name + host path +
  read-only) and a list with delete

Integration test for the repo create/delete round-trip (testcontainers).
---
 frontend/src/lib/api/endpoints/admin.ts       |  49 ++++
 frontend/src/routes/admin/+page.svelte        | 139 +++++++++++-
 src/application/ports/external_mount_ports.rs |  35 +++
 .../pg/external_mount_repository.rs           |  66 +++++-
 .../api/handlers/admin_external_mounts.rs     | 214 ++++++++++++++++++
 src/interfaces/api/handlers/admin_handler.rs  |  10 +
 src/interfaces/api/handlers/mod.rs            |   1 +
 7 files changed, 510 insertions(+), 4 deletions(-)
 create mode 100644 src/interfaces/api/handlers/admin_external_mounts.rs

diff --git a/frontend/src/lib/api/endpoints/admin.ts b/frontend/src/lib/api/endpoints/admin.ts
index f29e74e1..686178a2 100644
--- a/frontend/src/lib/api/endpoints/admin.ts
+++ b/frontend/src/lib/api/endpoints/admin.ts
@@ -512,3 +512,52 @@ export function getPluginLogs(
 		credentials: 'same-origin'
 	});
 }
+
+// ── External file mounts ────────────────────────────────────────────────────
+
+/** A configured external mount as returned by the admin API. */
+export interface ExternalMount {
+	mount_folder_id: string;
+	name: string;
+	kind: string;
+	owner_id: string;
+	read_only: boolean;
+	drive_id: string;
+	mount_path: string;
+	config: Record<string, unknown>;
+}
+
+/** Request body for creating an external mount. */
+export interface CreateExternalMountInput {
+	name: string;
+	host_path: string;
+	kind?: string;
+	read_only?: boolean;
+}
+
+/** GET /api/admin/external-mounts — list all configured mounts. */
+export function listExternalMounts(): Promise<ExternalMount[]> {
+	return apiJson<ExternalMount[]>('/api/admin/external-mounts', {
+		credentials: 'same-origin'
+	});
+}
+
+/** POST /api/admin/external-mounts — create a mount in the admin's drive. */
+export async function createExternalMount(input: CreateExternalMountInput): Promise<ExternalMount> {
+	const res = await apiFetch('/api/admin/external-mounts', {
+		method: 'POST',
+		credentials: 'same-origin',
+		headers: { ...JSON_HEADERS, ...getCsrfHeaders() },
+		body: JSON.stringify(input)
+	});
+	if (!res.ok) {
+		const e = (await res.json().catch(() => ({}))) as { message?: string };
+		throw new Error(e.message || `Create mount failed: ${res.status}`);
+	}
+	return (await res.json()) as ExternalMount;
+}
+
+/** DELETE /api/admin/external-mounts/{id} — remove a mount (host content kept). */
+export function deleteExternalMount(mountFolderId: string): Promise<void> {
+	return mutate(`/api/admin/external-mounts/${mountFolderId}`, 'DELETE');
+}
diff --git a/frontend/src/routes/admin/+page.svelte b/frontend/src/routes/admin/+page.svelte
index 528741e8..e96c1892 100644
--- a/frontend/src/routes/admin/+page.svelte
+++ b/frontend/src/routes/admin/+page.svelte
@@ -32,6 +32,11 @@
 		testOidc,
 		testStorage,
 		verifyMigration,
+		createExternalMount,
+		deleteExternalMount,
+		listExternalMounts,
+		type ExternalMount,
+		type CreateExternalMountInput,
 		type AdminDashboard,
 		type GeneratedKey,
 		type MigrationStatus,
@@ -114,13 +119,53 @@
 		confirmState = null;
 	}
 
-	type Tab = 'dashboard' | 'users' | 'drives' | 'plugins' | 'oidc' | 'storage' | 'smtp';
+	type Tab = 'dashboard' | 'users' | 'drives' | 'mounts' | 'plugins' | 'oidc' | 'storage' | 'smtp';
 	let tab = $state<Tab>('dashboard');
 
 	// Dashboard
 	let dashboard = $state<AdminDashboard | null>(null);
 	let dashboardError = $state<string | null>(null);
 
+	// External mounts
+	let mounts = $state<ExternalMount[] | null>(null);
+	let mountsError = $state<string | null>(null);
+	let newMount = $state<CreateExternalMountInput>({ name: '', host_path: '', read_only: false });
+	let mountCreating = $state(false);
+
+	async function loadMounts() {
+		mountsError = null;
+		try {
+			mounts = await listExternalMounts();
+		} catch (e) {
+			mountsError = errorMessage(e);
+		}
+	}
+
+	async function createMount() {
+		if (!newMount.name.trim() || !newMount.host_path.trim()) return;
+		mountCreating = true;
+		try {
+			const created = await createExternalMount(newMount);
+			mounts = [...(mounts ?? []), created];
+			newMount = { name: '', host_path: '', read_only: false };
+		} catch (e) {
+			mountsError = errorMessage(e);
+		} finally {
+			mountCreating = false;
+		}
+	}
+
+	async function deleteMount(id: string) {
+		if (!(await showConfirm('Remove this mount? Files on the host are kept.'))) return;
+		try {
+			await deleteExternalMount(id);
+			mounts = mounts?.filter((m) => m.mount_folder_id !== id) ?? null;
+		} catch (e) {
+			reportError(e);
+			await loadMounts();
+		}
+	}
+
 	// SMTP
 	let smtp = $state<SmtpInfo | null>(null);
 	let smtpTo = $state('');
@@ -1136,6 +1181,7 @@
 		dashboard: false,
 		users: false,
 		drives: false,
+		mounts: false,
 		plugins: false,
 		oidc: false,
 		storage: false,
@@ -1148,6 +1194,7 @@
 		if (tab === 'dashboard') void loadDashboard();
 		else if (tab === 'users') void loadUsers();
 		else if (tab === 'drives') void loadDrivesTab();
+		else if (tab === 'mounts') void loadMounts();
 		else if (tab === 'plugins') void loadPlugins();
 		else if (tab === 'oidc') void loadOidc();
 		else if (tab === 'storage') {
@@ -1210,6 +1257,15 @@
 			<Icon name="folder" />
 			{t('admin.drives', 'Drives')}
 		</button>
+		<button
+			role="tab"
+			data-testid="admin-mounts-tab"
+			aria-selected={tab === 'mounts'}
+			onclick={() => (tab = 'mounts')}
+		>
+			<Icon name="folder" />
+			{t('admin.mounts', 'External Mounts')}
+		</button>
 		<button
 			role="tab"
 			data-testid="admin-oidc-tab"
@@ -2103,6 +2159,87 @@
 				>
 			</div>
 		{/if}
+	{:else if tab === 'mounts'}
+		<section class="admin-section" data-testid="admin-mounts-section">
+			<h2>{t('admin.mounts.title', 'External File Mounts')}</h2>
+			<p class="muted">
+				{t(
+					'admin.mounts.help',
+					'Mount a host directory as a folder in your drive. Files stay on the host and are read live; deletes here are permanent.'
+				)}
+			</p>
+
+			<form
+				class="mount-form"
+				onsubmit={(e) => {
+					e.preventDefault();
+					void createMount();
+				}}
+			>
+				<input
+					type="text"
+					placeholder={t('admin.mounts.name', 'Name')}
+					bind:value={newMount.name}
+					data-testid="mount-name"
+				/>
+				<input
+					type="text"
+					placeholder={t('admin.mounts.path', 'Host path (e.g. /srv/media)')}
+					bind:value={newMount.host_path}
+					data-testid="mount-path"
+				/>
+				<label>
+					<input type="checkbox" bind:checked={newMount.read_only} />
+					{t('admin.mounts.readonly', 'Read-only')}
+				</label>
+				<button type="submit" disabled={mountCreating} data-testid="mount-create">
+					{t('admin.mounts.add', 'Add mount')}
+				</button>
+			</form>
+
+			{#if mountsError}
+				<p class="error" data-testid="mount-error">{mountsError}</p>
+			{/if}
+
+			{#if mounts}
+				{#if mounts.length === 0}
+					<p class="muted">{t('admin.mounts.empty', 'No mounts configured.')}</p>
+				{:else}
+					<table class="table">
+						<thead>
+							<tr>
+								<th>{t('admin.mounts.name', 'Name')}</th>
+								<th>{t('admin.mounts.kind', 'Kind')}</th>
+								<th>{t('admin.mounts.path', 'Path')}</th>
+								<th>{t('admin.mounts.readonly', 'Read-only')}</th>
+								<th></th>
+							</tr>
+						</thead>
+						<tbody>
+							{#each mounts as m (m.mount_folder_id)}
+								<tr>
+									<td>{m.name}</td>
+									<td>{m.kind}</td>
+									<td class="muted">{m.mount_path}</td>
+									<td>{m.read_only ? t('common.yes', 'Yes') : t('common.no', 'No')}</td>
+									<td>
+										<button
+											class="danger"
+											onclick={() => void deleteMount(m.mount_folder_id)}
+											data-testid="mount-delete"
+										>
+											{t('common.delete', 'Delete')}
+										</button>
+									</td>
+								</tr>
+							{/each}
+						</tbody>
+					</table>
+				{/if}
+			{:else}
+				<p class="muted">{t('common.loading', 'Loading…')}</p>
+			{/if}
+		</section>
 	{:else if tab === 'drives'}
 		<div class="bar">
 			<button
diff --git a/src/application/ports/external_mount_ports.rs b/src/application/ports/external_mount_ports.rs
index c87d5980..861e7202 100644
--- a/src/application/ports/external_mount_ports.rs
+++ b/src/application/ports/external_mount_ports.rs
@@ -168,11 +168,46 @@ pub struct ExternalMountRecord {
     pub mount_path: String,
 }
 
+/// The persistable columns of an `external_mounts` row (admin create).
+#[derive(Debug, Clone)]
+pub struct NewExternalMount {
+    /// The mount-root folder UUID this mount attaches to.
+    pub mount_folder_id: Uuid,
+    /// Provider kind.
+    pub kind: String,
+    /// Provider-specific connection config.
+    pub config: serde_json::Value,
+    /// Display name.
+    pub name: String,
+    /// Owner of the mount configuration.
+    pub owner_id: Uuid,
+    /// Whether the mount is read-only.
+    pub read_only: bool,
+}
+
 /// Persistence port for external mount configuration.
 #[async_trait]
 pub trait ExternalMountRepositoryPort: Send + Sync {
     /// Load every (non-trashed) mount joined with its folder, for registry build.
     async fn list_all(&self) -> Result<Vec<ExternalMountRecord>, DomainError>;
+
+    /// Insert a new mount row. Default errors — only the PG repo implements it
+    /// (test doubles need `list_all` only).
+    async fn create(&self, _mount: &NewExternalMount) -> Result<(), DomainError> {
+        Err(DomainError::operation_not_supported(
+            "ExternalMount",
+            "create is not supported by this repository",
+        ))
+    }
+
+    /// Delete a mount row by its mount-root folder id. Returns `true` when a
+    /// row was removed. Default errors (see `create`).
+    async fn delete(&self, _mount_folder_id: Uuid) -> Result<bool, DomainError> {
+        Err(DomainError::operation_not_supported(
+            "ExternalMount",
+            "delete is not supported by this repository",
+        ))
+    }
 }
 
 /// Builds [`ExternalMountProvider`]s from a `kind` + `config` pair.
diff --git a/src/infrastructure/repositories/pg/external_mount_repository.rs b/src/infrastructure/repositories/pg/external_mount_repository.rs
index a18ae48f..366f1294 100644
--- a/src/infrastructure/repositories/pg/external_mount_repository.rs
+++ b/src/infrastructure/repositories/pg/external_mount_repository.rs
@@ -1,7 +1,7 @@
 //! PostgreSQL persistence for external mount configuration.
 //!
-//! P1 only needs [`ExternalMountRepositoryPort::list_all`] to (re)build the
-//! in-memory registry; admin CRUD lands with P4.
+//! `list_all` (re)builds the in-memory registry; `create`/`delete` back the
+//! admin CRUD endpoints.
 
 use std::sync::Arc;
 
@@ -10,7 +10,7 @@ use sqlx::{PgPool, Row};
 use uuid::Uuid;
 
 use crate::application::ports::external_mount_ports::{
-    ExternalMountRecord, ExternalMountRepositoryPort,
+    ExternalMountRecord, ExternalMountRepositoryPort, NewExternalMount,
 };
 use crate::domain::errors::DomainError;
 
@@ -91,6 +91,37 @@ impl ExternalMountRepositoryPort for ExternalMountPgRepository {
         }
         Ok(out)
     }
+
+    async fn create(&self, mount: &NewExternalMount) -> Result<(), DomainError> {
+        sqlx::query(
+            "INSERT INTO storage.external_mounts
+                (mount_folder_id, kind, config, name, owner_id, read_only)
+             VALUES ($1, $2, $3, $4, $5, $6)",
+        )
+        .bind(mount.mount_folder_id)
+        .bind(&mount.kind)
+        .bind(&mount.config)
+        .bind(&mount.name)
+        .bind(mount.owner_id)
+        .bind(mount.read_only)
+        .execute(self.pool.as_ref())
+        .await
+        .map_err(|e| {
+            DomainError::database_error(format!("failed to create external mount: {e}"))
+        })?;
+        Ok(())
+    }
+
+    async fn delete(&self, mount_folder_id: Uuid) -> Result<bool, DomainError> {
+        let res = sqlx::query("DELETE FROM storage.external_mounts WHERE mount_folder_id = $1")
+            .bind(mount_folder_id)
+            .execute(self.pool.as_ref())
+            .await
+            .map_err(|e| {
+                DomainError::database_error(format!("failed to delete external mount: {e}"))
+            })?;
+        Ok(res.rows_affected() > 0)
+    }
 }
 
 // Gated on `test` too: the module uses the `testcontainers` dev-dependency,
@@ -151,4 +182,33 @@ mod integration_tests {
         let repo = ExternalMountPgRepository::new(pool.clone());
         assert!(repo.list_all().await.expect("list_all").is_empty());
     }
+
+    #[tokio::test]
+    async fn create_and_delete_round_trip() {
+        use crate::application::ports::external_mount_ports::NewExternalMount;
+        let (_c, pool) = fresh_db().await;
+        let p = provision_folder(&pool, "owner", "Media").await;
+        let repo = ExternalMountPgRepository::new(pool.clone());
+
+        repo.create(&NewExternalMount {
+            mount_folder_id: p.mount_folder_id,
+            kind: "local_fs".to_string(),
+            config: serde_json::json!({ "path": "/srv/x" }),
+            name: "Media".to_string(),
+            owner_id: p.owner_id,
+            read_only: true,
+        })
+        .await
+        .expect("create");
+
+        let mounts = repo.list_all().await.expect("list");
+        assert_eq!(mounts.len(), 1);
+        assert!(mounts[0].read_only);
+        assert_eq!(mounts[0].mount_folder_id, p.mount_folder_id);
+
+        assert!(repo.delete(p.mount_folder_id).await.expect("delete"));
+        assert!(repo.list_all().await.expect("list").is_empty());
+        // Deleting a non-existent mount returns false.
+        assert!(!repo.delete(p.mount_folder_id).await.expect("delete again"));
+    }
 }
diff --git a/src/interfaces/api/handlers/admin_external_mounts.rs b/src/interfaces/api/handlers/admin_external_mounts.rs
new file mode 100644
index 00000000..c4a3c21b
--- /dev/null
+++ b/src/interfaces/api/handlers/admin_external_mounts.rs
@@ -0,0 +1,214 @@
+//! Admin CRUD for external file mounts (`/api/admin/external-mounts`).
+//!
+//! Creating a mount: validate the backend config, create a mount-root folder
+//! under the admin's drive, insert the `external_mounts` row, then hot-reload
+//! the in-memory registry. Deleting: remove the row + the folder and reload.
+//! Every endpoint is admin-gated.
+
+use std::sync::Arc;
+
+use axum::{
+    Json,
+    extract::{Path, State},
+    http::{HeaderMap, StatusCode},
+    response::IntoResponse,
+};
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use crate::application::ports::external_mount_ports::{
+    ExternalMountRecord, ExternalMountRepositoryPort, MountProviderFactory, NewExternalMount,
+};
+use crate::common::di::AppState;
+use crate::domain::repositories::drive_repository::DriveRepository;
+use crate::domain::repositories::folder_repository::FolderRepository;
+use crate::infrastructure::repositories::pg::ExternalMountPgRepository;
+use crate::infrastructure::services::mount_provider_factory::DefaultMountProviderFactory;
+use crate::interfaces::errors::AppError;
+use crate::interfaces::middleware::admin::require_admin;
+
+/// JSON view of a configured mount.
+#[derive(Debug, Serialize)]
+pub struct ExternalMountResponse {
+    pub mount_folder_id: String,
+    pub name: String,
+    pub kind: String,
+    pub owner_id: String,
+    pub read_only: bool,
+    pub drive_id: String,
+    pub mount_path: String,
+    pub config: serde_json::Value,
+}
+
+impl From<ExternalMountRecord> for ExternalMountResponse {
+    fn from(r: ExternalMountRecord) -> Self {
+        Self {
+            mount_folder_id: r.mount_folder_id.to_string(),
+            name: r.name,
+            kind: r.kind,
+            owner_id: r.owner_id.to_string(),
+            read_only: r.read_only,
+            drive_id: r.drive_id.to_string(),
+            mount_path: r.mount_path,
+            config: r.config,
+        }
+    }
+}
+
+/// Request body for creating a mount.
+#[derive(Debug, Deserialize)]
+pub struct CreateExternalMountRequest {
+    /// Display name (also the mount-root folder name).
+    pub name: String,
+    /// Absolute host path for the `local_fs` provider.
+    pub host_path: String,
+    /// Provider kind. Defaults to `local_fs`.
+    #[serde(default = "default_kind")]
+    pub kind: String,
+    /// When true, the mount refuses all mutations.
+    #[serde(default)]
+    pub read_only: bool,
+}
+
+fn default_kind() -> String {
+    "local_fs".to_string()
+}
+
+fn pool(state: &AppState) -> Result<Arc<sqlx::PgPool>, AppError> {
+    state
+        .db_pool
+        .clone()
+        .ok_or_else(|| AppError::internal_error("Database not available"))
+}
+
+/// `GET /api/admin/external-mounts` — list all configured mounts.
+pub async fn list_external_mounts(
+    State(state): State<Arc<AppState>>,
+    headers: HeaderMap,
+) -> Result<impl IntoResponse, AppError> {
+    require_admin(&state, &headers).await?;
+    let repo = ExternalMountPgRepository::new(pool(&state)?);
+    let mounts = repo
+        .list_all()
+        .await
+        .map_err(|e| AppError::internal_error(format!("list external mounts: {e}")))?;
+    let out: Vec<ExternalMountResponse> = mounts.into_iter().map(Into::into).collect();
+    Ok(Json(out))
+}
+
+/// `POST /api/admin/external-mounts` — create a mount in the admin's drive.
+pub async fn create_external_mount(
+    State(state): State<Arc<AppState>>,
+    headers: HeaderMap,
+    Json(req): Json<CreateExternalMountRequest>,
+) -> Result<impl IntoResponse, AppError> {
+    let (admin_id, _role) = require_admin(&state, &headers).await?;
+
+    if req.name.trim().is_empty() {
+        return Err(AppError::bad_request("Mount name must not be empty"));
+    }
+
+    // Build the provider config and validate it up front (path exists, etc.).
+    let config = serde_json::json!({ "path": req.host_path, "read_only": req.read_only });
+    let factory = DefaultMountProviderFactory::new();
+    factory
+        .build(&req.kind, &config)
+        .await
+        .map_err(|e| AppError::bad_request(format!("invalid mount configuration: {e}")))?;
+
+    // Create the mount-root folder under the admin's default drive root.
+    let drive = state
+        .drive_repo
+        .find_default_for_user(admin_id)
+        .await
+        .map_err(|e| AppError::internal_error(format!("find default drive: {e}")))?;
+    let root_folder_id = drive.drive.root_folder_id.to_string();
+
+    let folder = state
+        .repositories
+        .folder_repository
+        .create_folder(req.name.clone(), Some(root_folder_id), admin_id)
+        .await
+        .map_err(AppError::from)?;
+    let mount_folder_id =
+        Uuid::parse_str(folder.id()).map_err(|_| AppError::internal_error("bad folder id"))?;
+
+    let repo = ExternalMountPgRepository::new(pool(&state)?);
+    repo.create(&NewExternalMount {
+        mount_folder_id,
+        kind: req.kind.clone(),
+        config,
+        name: req.name.clone(),
+        owner_id: admin_id,
+        read_only: req.read_only,
+    })
+    .await
+    .map_err(|e| AppError::internal_error(format!("create mount row: {e}")))?;
+
+    // Hot-reload so the new mount is live immediately.
+    state.mount_router.registry().reload(&repo, &factory).await;
+
+    tracing::info!(
+        target: "audit",
+        event = "external_mount.config",
+        action = "create",
+        mount_id = %mount_folder_id,
+        caller_id = %admin_id,
+        kind = %req.kind,
+        reason = "external_mount_admin",
+        "👮🏻‍♂️ external mount created",
+    );
+
+    // Return the freshly created mount.
+    let created = repo
+        .list_all()
+        .await
+        .map_err(|e| AppError::internal_error(format!("reload mounts: {e}")))?
+        .into_iter()
+        .find(|m| m.mount_folder_id == mount_folder_id)
+        .map(ExternalMountResponse::from)
+        .ok_or_else(|| AppError::internal_error("created mount not found"))?;
+    Ok((StatusCode::CREATED, Json(created)))
+}
+
+/// `DELETE /api/admin/external-mounts/{id}` — remove a mount (and its root
+/// folder). The host filesystem content is untouched.
+pub async fn delete_external_mount(
+    State(state): State<Arc<AppState>>,
+    headers: HeaderMap,
+    Path(id): Path<Uuid>,
+) -> Result<impl IntoResponse, AppError> {
+    let (admin_id, _role) = require_admin(&state, &headers).await?;
+
+    let repo = ExternalMountPgRepository::new(pool(&state)?);
+    let removed = repo
+        .delete(id)
+        .await
+        .map_err(|e| AppError::internal_error(format!("delete mount row: {e}")))?;
+    if !removed {
+        return Err(AppError::not_found("Mount not found"));
+    }
+
+    // Remove the mount-root folder row (host content is left intact).
+    state
+        .repositories
+        .folder_repository
+        .delete_folder(&id.to_string())
+        .await
+        .map_err(AppError::from)?;
+
+    let factory = DefaultMountProviderFactory::new();
+    state.mount_router.registry().reload(&repo, &factory).await;
+
+    tracing::info!(
+        target: "audit",
+        event = "external_mount.config",
+        action = "delete",
+        mount_id = %id,
+        caller_id = %admin_id,
+        reason = "external_mount_admin",
+        "👮🏻‍♂️ external mount deleted",
+    );
+
+    Ok(StatusCode::NO_CONTENT)
+}
diff --git a/src/interfaces/api/handlers/admin_handler.rs b/src/interfaces/api/handlers/admin_handler.rs
index 39611695..6e3af628 100644
--- a/src/interfaces/api/handlers/admin_handler.rs
+++ b/src/interfaces/api/handlers/admin_handler.rs
@@ -33,7 +33,17 @@ use uuid::Uuid;
 
 /// Admin API routes — all require admin role.
 pub fn admin_routes() -> Router<Arc<AppState>> {
+    use super::admin_external_mounts as ext_mounts;
     Router::new()
+        // External file mounts
+        .route(
+            "/external-mounts",
+            get(ext_mounts::list_external_mounts).post(ext_mounts::create_external_mount),
+        )
+        .route(
+            "/external-mounts/{id}",
+            delete(ext_mounts::delete_external_mount),
+        )
         // OIDC settings
         .route("/settings/oidc", get(get_oidc_settings))
         .route("/settings/oidc", put(save_oidc_settings))
diff --git a/src/interfaces/api/handlers/mod.rs b/src/interfaces/api/handlers/mod.rs
index d31d688d..e5e5ab68 100644
--- a/src/interfaces/api/handlers/mod.rs
+++ b/src/interfaces/api/handlers/mod.rs
@@ -1,3 +1,4 @@
+pub mod admin_external_mounts;
 pub mod admin_handler;
 pub mod app_password_handler;
 pub mod auth_handler;