@adonis-agora/media 0.10.4 → 0.11.0

package/dist/assets/spa/index.html

@@ -0,0 +1,20 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="robots" content="noindex" />
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link
+      href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;700&family=Space+Grotesk:wght@400;500;600;700&display=swap"
+      rel="stylesheet"
+    />
+    <title>Media · Agora</title>
+    <script type="module" crossorigin src="/__MEDIA_DASHBOARD__/assets/index-Dvw2uJpF.js"></script>
+    <link rel="stylesheet" crossorigin href="/__MEDIA_DASHBOARD__/assets/index--0MZJr6W.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/dist/configure.d.ts

@@ -3,8 +3,12 @@ import type Configure from '@adonisjs/core/commands/configure';
  * `node ace configure @adonis-agora/media` — auto-wires the package:
  *
  * 1. registers the media service provider in `adonisrc.ts`;
- * 2. publishes `config/media.ts`;
- * 3. publishes the Lucid migrations for the optional `lucid` store and the resumable (TUS) session
+ * 2. registers the dashboard provider — the management console SPA ships embedded in this package
+ *    (its built assets are copied in at `pnpm build` time), so this alone is enough to get it; no
+ *    separate `@adonis-agora/media-dashboard` install is required (though that package still exists,
+ *    standalone, for hosts that prefer registering it directly);
+ * 3. publishes `config/media.ts` and `config/media_dashboard.ts`;
+ * 4. publishes the Lucid migrations for the optional `lucid` store and the resumable (TUS) session
  *    store (run `node ace migration:run`; delete either if you only use the in-memory equivalents).
  *
  * Requires `@adonisjs/drive` to be installed and configured first (`node ace add @adonisjs/drive`).

package/dist/configure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"configure.d.ts","sourceRoot":"","sources":["../configure.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,mCAAmC,CAAC;AAG/D;;;;;;;;;GASG;AACH,wBAAsB,SAAS,CAAC,OAAO,EAAE,SAAS,iBAejD"}
+{"version":3,"file":"configure.d.ts","sourceRoot":"","sources":["../configure.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,mCAAmC,CAAC;AAG/D;;;;;;;;;;;;;GAaG;AACH,wBAAsB,SAAS,CAAC,OAAO,EAAE,SAAS,iBAiBjD"}

package/dist/configure.js

@@ -3,8 +3,12 @@ import { stubsRoot } from './stubs/main.js';
  * `node ace configure @adonis-agora/media` — auto-wires the package:
  *
  * 1. registers the media service provider in `adonisrc.ts`;
- * 2. publishes `config/media.ts`;
- * 3. publishes the Lucid migrations for the optional `lucid` store and the resumable (TUS) session
+ * 2. registers the dashboard provider — the management console SPA ships embedded in this package
+ *    (its built assets are copied in at `pnpm build` time), so this alone is enough to get it; no
+ *    separate `@adonis-agora/media-dashboard` install is required (though that package still exists,
+ *    standalone, for hosts that prefer registering it directly);
+ * 3. publishes `config/media.ts` and `config/media_dashboard.ts`;
+ * 4. publishes the Lucid migrations for the optional `lucid` store and the resumable (TUS) session
  *    store (run `node ace migration:run`; delete either if you only use the in-memory equivalents).
  *
  * Requires `@adonisjs/drive` to be installed and configured first (`node ace add @adonisjs/drive`).
@@ -13,9 +17,11 @@ export async function configure(command) {
     const codemods = await command.createCodemods();
     await codemods.updateRcFile((rcFile) => {
         rcFile.addProvider('@adonis-agora/media/media_provider');
+        rcFile.addProvider('@adonis-agora/media/dashboard_provider');
     });
     const stubs = stubsRoot();
     await codemods.makeUsingStub(stubs, 'config/media.stub', {});
+    await codemods.makeUsingStub(stubs, 'config/media_dashboard.stub', {});
     await codemods.makeUsingStub(stubs, 'database/migrations/create_media_table.stub', {});
     await codemods.makeUsingStub(stubs, 'database/migrations/create_media_upload_sessions_table.stub', {});
 }

package/dist/configure.js.map

@@ -1 +1 @@
-{"version":3,"file":"configure.js","sourceRoot":"","sources":["../configure.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,OAAkB;IAChD,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,cAAc,EAAE,CAAC;IAEhD,MAAM,QAAQ,CAAC,YAAY,CAAC,CAAC,MAAM,EAAE,EAAE;QACrC,MAAM,CAAC,WAAW,CAAC,oCAAoC,CAAC,CAAC;IAC3D,CAAC,CAAC,CAAC;IAEH,MAAM,KAAK,GAAG,SAAS,EAAE,CAAC;IAC1B,MAAM,QAAQ,CAAC,aAAa,CAAC,KAAK,EAAE,mBAAmB,EAAE,EAAE,CAAC,CAAC;IAC7D,MAAM,QAAQ,CAAC,aAAa,CAAC,KAAK,EAAE,6CAA6C,EAAE,EAAE,CAAC,CAAC;IACvF,MAAM,QAAQ,CAAC,aAAa,CAC1B,KAAK,EACL,6DAA6D,EAC7D,EAAE,CACH,CAAC;AACJ,CAAC"}
+{"version":3,"file":"configure.js","sourceRoot":"","sources":["../configure.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,OAAkB;IAChD,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,cAAc,EAAE,CAAC;IAEhD,MAAM,QAAQ,CAAC,YAAY,CAAC,CAAC,MAAM,EAAE,EAAE;QACrC,MAAM,CAAC,WAAW,CAAC,oCAAoC,CAAC,CAAC;QACzD,MAAM,CAAC,WAAW,CAAC,wCAAwC,CAAC,CAAC;IAC/D,CAAC,CAAC,CAAC;IAEH,MAAM,KAAK,GAAG,SAAS,EAAE,CAAC;IAC1B,MAAM,QAAQ,CAAC,aAAa,CAAC,KAAK,EAAE,mBAAmB,EAAE,EAAE,CAAC,CAAC;IAC7D,MAAM,QAAQ,CAAC,aAAa,CAAC,KAAK,EAAE,6BAA6B,EAAE,EAAE,CAAC,CAAC;IACvE,MAAM,QAAQ,CAAC,aAAa,CAAC,KAAK,EAAE,6CAA6C,EAAE,EAAE,CAAC,CAAC;IACvF,MAAM,QAAQ,CAAC,aAAa,CAC1B,KAAK,EACL,6DAA6D,EAC7D,EAAE,CACH,CAAC;AACJ,CAAC"}

package/dist/providers/dashboard_provider.d.ts

@@ -0,0 +1,29 @@
+import type { ApplicationService } from '@adonisjs/core/types';
+/**
+ * Mounts the media-management console INTO `@adonis-agora/media` itself: a React SPA plus a JSON
+ * API, both under a configurable path and an optional host auth guard. The API delegates to the
+ * already-bound {@link MediaManager} singleton (bound by this same package's `MediaProvider`) via a
+ * pure {@link DashboardService} — disk `list`/`stat`/`copy`/`move`/`deleteMany` and the resumable
+ * session store. Nothing about storage is reimplemented here.
+ *
+ * Registering this provider is all a consuming app needs to do to get the dashboard — no separate
+ * `@adonis-agora/media-dashboard` install (its provider still exists, standalone, for hosts that
+ * prefer it — see `packages/dashboard`):
+ * ```ts
+ * providers: [
+ *   () => import('@adonis-agora/media/media_provider'),
+ *   () => import('@adonis-agora/media/dashboard_provider'),
+ * ]
+ * ```
+ *
+ * Route registration is deferred to `app.booted(...)` — same reason `MediaProvider#boot()` defers
+ * (see its long comment): the router service isn't safely resolvable synchronously inside a
+ * provider's own `boot()`.
+ */
+export default class MediaDashboardProvider {
+    #private;
+    protected app: ApplicationService;
+    constructor(app: ApplicationService);
+    boot(): Promise<void>;
+}
+//# sourceMappingURL=dashboard_provider.d.ts.map

package/dist/providers/dashboard_provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dashboard_provider.d.ts","sourceRoot":"","sources":["../../providers/dashboard_provider.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,kBAAkB,EAAqB,MAAM,sBAAsB,CAAC;AA0ClF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,OAAO,OAAO,sBAAsB;;IAC7B,SAAS,CAAC,GAAG,EAAE,kBAAkB;gBAAvB,GAAG,EAAE,kBAAkB;IAEvC,IAAI;CA4aX"}

package/dist/providers/dashboard_provider.js

@@ -0,0 +1,520 @@
+import { readFile } from 'node:fs/promises';
+import { basename, resolve as resolvePath } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { SESSION_COOKIE_NAME, parseCookieHeader, serializeSetCookie, } from '../src/dashboard/cookie.js';
+import { DashboardError, DashboardService, resolveConsoleAuth, signSessionCookie, verifySessionCookie, } from '../src/dashboard/index.js';
+import { contentTypeFor, normalizePath, renderIndexHtml } from '../src/dashboard/spa.js';
+import { MediaManager } from '../src/media_manager.js';
+/**
+ * Directory of the built SPA (`dist/spa`, copied in by `copy:stubs` — see `package.json` — from
+ * `@adonis-agora/media-dashboard`'s own build), relative to this compiled provider
+ * (`dist/providers`). Resolved lazily (not at module scope): `fileURLToPath` throws on any
+ * non-`file:` `import.meta.url`, which would make this provider unimportable under a test runner
+ * that doesn't use real file URLs.
+ */
+let spaDir;
+function spaDirectory() {
+    spaDir ??= fileURLToPath(new URL('../assets/spa/', import.meta.url));
+    return spaDir;
+}
+/** Cookie `Path` for the built-in session — deliberately `/`, not scoped to `apiBase`: the SPA's
+ *  `basePath` and its `apiBase` are independently configurable and can live at unrelated paths, and a
+ *  cookie scoped to just one would be withheld on a full-page navigation to the other. The cookie is
+ *  HttpOnly + HMAC-signed + short-lived, so the broader scope is a reasonable trade. Matches the
+ *  NestJS sibling console's own `cookiePath: '/'` for the identical reason. */
+const SESSION_COOKIE_PATH = '/';
+/**
+ * Mounts the media-management console INTO `@adonis-agora/media` itself: a React SPA plus a JSON
+ * API, both under a configurable path and an optional host auth guard. The API delegates to the
+ * already-bound {@link MediaManager} singleton (bound by this same package's `MediaProvider`) via a
+ * pure {@link DashboardService} — disk `list`/`stat`/`copy`/`move`/`deleteMany` and the resumable
+ * session store. Nothing about storage is reimplemented here.
+ *
+ * Registering this provider is all a consuming app needs to do to get the dashboard — no separate
+ * `@adonis-agora/media-dashboard` install (its provider still exists, standalone, for hosts that
+ * prefer it — see `packages/dashboard`):
+ * ```ts
+ * providers: [
+ *   () => import('@adonis-agora/media/media_provider'),
+ *   () => import('@adonis-agora/media/dashboard_provider'),
+ * ]
+ * ```
+ *
+ * Route registration is deferred to `app.booted(...)` — same reason `MediaProvider#boot()` defers
+ * (see its long comment): the router service isn't safely resolvable synchronously inside a
+ * provider's own `boot()`.
+ */
+export default class MediaDashboardProvider {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    async boot() {
+        const config = this.app.config.get('media_dashboard', {});
+        if (config.enabled === false)
+            return;
+        await this.app.booted(async () => {
+            const router = await this.app.container.make('router');
+            this.#registerRoutes(router, config);
+        });
+    }
+    #registerRoutes(router, config) {
+        const basePath = normalizePath(config.basePath ?? '/media/dashboard');
+        const apiBase = normalizePath(config.apiBasePath ?? `${basePath}/api`);
+        const uploadsBase = normalizePath(config.uploadsPrefix ?? '/media/uploads');
+        const tusBase = normalizePath(config.tusPrefix ?? '/media/uploads/tus');
+        const actions = config.actions ?? false;
+        const diskNames = this.#resolveDiskNames(config);
+        const middleware = config.middleware
+            ? Array.isArray(config.middleware)
+                ? config.middleware
+                : [config.middleware]
+            : [];
+        // Built-in session-cookie login (Mode A/B), independent of `middleware` — see
+        // `src/dashboard/auth.ts`. `null` when unconfigured, in which case every gate below is a no-op
+        // and the API stays open.
+        const auth = resolveConsoleAuth(config.auth);
+        const objectInsights = config.objectInsights ?? [];
+        const service = async () => new DashboardService(await this.app.container.make(MediaManager), { diskNames, actions }, objectInsights);
+        this.#mountAuthRoutes(router, apiBase, auth);
+        this.#mountApi(router, apiBase, service, middleware, auth);
+        this.#mountSpa(router, basePath, { apiBase, uploadsBase, tusBase, actions }, middleware);
+    }
+    /**
+     * Mints/clears the console session cookie: `GET /me`, `POST /login`, `POST /session`,
+     * `POST /logout`. Deliberately NOT gated by `middleware` NOR the session guard below — these
+     * routes CREATE the session the guard checks for (mirroring the NestJS sibling console's
+     * `MediaConsoleAuthController`, which is likewise excluded from both its own session guard and any
+     * host-supplied `guards`). A host `session` hook reads its OWN auth directly off the raw request,
+     * so it needs no help from `middleware` here. When `auth` is unset, `/me` reports
+     * `authRequired: false` and login/session/logout 404 (nothing to mint or clear).
+     */
+    #mountAuthRoutes(router, apiBase, auth) {
+        const group = router.group(() => {
+            router
+                .get('/me', async (ctx) => {
+                if (!auth) {
+                    const body = { authRequired: false };
+                    return ctx.response.status(200).json(body);
+                }
+                const session = sessionFromRequest(ctx, auth);
+                // The UNauthenticated SPA learns which login mode(s) to offer from this 401 body.
+                if (!session)
+                    return ctx.response.status(401).json({ auth: { modes: auth.modes } });
+                const body = { user: userInfoFromSession(session) };
+                return ctx.response.status(200).json(body);
+            })
+                .as('media.dashboard.me');
+            router
+                .post('/login', async (ctx) => {
+                if (!auth || !auth.login)
+                    return ctx.response.status(404).send('');
+                const raw = ctx.request.body();
+                if (typeof raw.username !== 'string' || typeof raw.password !== 'string') {
+                    return ctx.response
+                        .status(400)
+                        .json({ error: 'body must include string username and password' });
+                }
+                const user = await runAuthHook(() => auth.login?.(raw.username, raw.password));
+                // Uniform 401 for unknown user / bad password — no user-enumeration.
+                if (!user)
+                    return ctx.response.status(401).json({ error: 'invalid credentials' });
+                issueSessionCookie(ctx, user, auth);
+                const body = { user: userInfoFromUser(user) };
+                return ctx.response.status(200).json(body);
+            })
+                .as('media.dashboard.login');
+            router
+                .post('/session', async (ctx) => {
+                if (!auth || !auth.session)
+                    return ctx.response.status(404).send('');
+                const user = await runAuthHook(() => auth.session?.(ctx.request.request));
+                if (!user)
+                    return ctx.response.status(401).json({ error: 'unauthorized' });
+                issueSessionCookie(ctx, user, auth);
+                const body = { user: userInfoFromUser(user) };
+                return ctx.response.status(200).json(body);
+            })
+                .as('media.dashboard.session');
+            router
+                .post('/logout', async (ctx) => {
+                // Best-effort: even without auth configured, clearing is harmless.
+                clearSessionCookie(ctx);
+                return ctx.response.status(204).send('');
+            })
+                .as('media.dashboard.logout');
+        });
+        group.prefix(apiBase);
+    }
+    #mountApi(router, apiBase, service, middleware, auth) {
+        const json = (handler, okStatus = 200) => {
+            return async (ctx) => {
+                try {
+                    const result = await handler(await service(), ctx);
+                    if (result === undefined)
+                        return ctx.response.status(204).send('');
+                    return ctx.response.status(okStatus).json(result);
+                }
+                catch (error) {
+                    const status = error instanceof DashboardError ? error.status : 500;
+                    const message = error instanceof Error ? error.message : 'dashboard error';
+                    return ctx.response.status(status).json({ error: message });
+                }
+            };
+        };
+        const group = router.group(() => {
+            router
+                .get('/topology', json(async (svc) => svc.topology()))
+                .as('media.dashboard.topology');
+            router
+                .get('/disks', json(async (svc) => svc.disks()))
+                .as('media.dashboard.disks');
+            router
+                .get('/objects', json(async (svc, ctx) => {
+                const disk = str(ctx, 'disk');
+                if (!disk)
+                    throw new DashboardError('disk is required', 400);
+                const prefix = str(ctx, 'prefix');
+                const cursor = str(ctx, 'cursor');
+                const limit = ctx.request.input('limit');
+                return svc.objects(disk, {
+                    ...(prefix !== undefined ? { prefix } : {}),
+                    ...(cursor !== undefined ? { cursor } : {}),
+                    ...(limit !== undefined ? { limit: Number(limit) } : {}),
+                });
+            }))
+                .as('media.dashboard.objects');
+            router
+                .get('/object', json(async (svc, ctx) => {
+                const disk = str(ctx, 'disk');
+                const key = str(ctx, 'key');
+                if (!disk)
+                    throw new DashboardError('disk is required', 400);
+                return svc.object(disk, key ?? '');
+            }))
+                .as('media.dashboard.object');
+            router
+                .post('/object', async (ctx) => {
+                // Raw bytes as `application/octet-stream` so the host's JSON/urlencoded body parsers never
+                // consume the stream; `ctx.request.request` is still the untouched Node request stream for
+                // any content type the app's bodyparser wasn't configured to parse. The real MIME rides as
+                // the `type` query param and becomes the stored object's Content-Type.
+                try {
+                    const disk = str(ctx, 'disk');
+                    const key = str(ctx, 'key');
+                    const type = str(ctx, 'type');
+                    if (!disk)
+                        throw new DashboardError('disk is required', 400);
+                    if (!key)
+                        throw new DashboardError('key is required', 400);
+                    await (await service()).putObject(disk, key, ctx.request.request, type);
+                    return ctx.response.status(204).send('');
+                }
+                catch (error) {
+                    const status = error instanceof DashboardError ? error.status : 500;
+                    const message = error instanceof Error ? error.message : 'dashboard error';
+                    return ctx.response.status(status).json({ error: message });
+                }
+            })
+                .as('media.dashboard.object.upload');
+            router
+                .get('/object/raw', async (ctx) => {
+                try {
+                    const disk = str(ctx, 'disk');
+                    const key = str(ctx, 'key');
+                    if (!disk)
+                        throw new DashboardError('disk is required', 400);
+                    const { stream, contentType, size } = await (await service()).objectStream(disk, key ?? '');
+                    ctx.response.header('content-type', contentType);
+                    ctx.response.header('content-disposition', 'inline');
+                    if (Number.isFinite(size))
+                        ctx.response.header('content-length', String(size));
+                    return ctx.response.stream(stream);
+                }
+                catch (error) {
+                    const status = error instanceof DashboardError ? error.status : 500;
+                    const message = error instanceof Error ? error.message : 'dashboard error';
+                    return ctx.response.status(status).json({ error: message });
+                }
+            })
+                .as('media.dashboard.object.raw');
+            router
+                .get('/object/insights', json(async (svc, ctx) => {
+                const disk = str(ctx, 'disk');
+                const key = str(ctx, 'key');
+                if (!disk)
+                    throw new DashboardError('disk is required', 400);
+                return svc.objectInsights(disk, key ?? '');
+            }))
+                .as('media.dashboard.object.insights');
+            router
+                .get('/uploads', json(async (svc, ctx) => {
+                const disk = str(ctx, 'disk');
+                const prefix = str(ctx, 'prefix');
+                return svc.uploads({
+                    ...(disk !== undefined ? { disk } : {}),
+                    ...(prefix !== undefined ? { prefix } : {}),
+                });
+            }))
+                .as('media.dashboard.uploads');
+            router
+                .get('/uploads/:id', json(async (svc, ctx) => svc.uploadDetail(String(ctx.params.id))))
+                .as('media.dashboard.uploads.show');
+            router
+                .post('/uploads/:id/abort', json(async (svc, ctx) => {
+                await svc.abortUpload(String(ctx.params.id));
+            }))
+                .as('media.dashboard.uploads.abort');
+            router
+                .get('/collections', json(async (svc, ctx) => {
+                const collection = str(ctx, 'collection');
+                const ownerType = str(ctx, 'ownerType');
+                const ownerId = str(ctx, 'ownerId');
+                const prefix = str(ctx, 'prefix');
+                const cursor = str(ctx, 'cursor');
+                const limit = ctx.request.input('limit');
+                return svc.collections({
+                    ...(collection !== undefined ? { collection } : {}),
+                    ...(ownerType !== undefined ? { ownerType } : {}),
+                    ...(ownerId !== undefined ? { ownerId } : {}),
+                    ...(prefix !== undefined ? { prefix } : {}),
+                    ...(cursor !== undefined ? { cursor } : {}),
+                    ...(limit !== undefined ? { limit: Number(limit) } : {}),
+                });
+            }))
+                .as('media.dashboard.collections');
+            router
+                .get('/collections/summary', json(async (svc) => svc.collectionsSummary()))
+                .as('media.dashboard.collections.summary');
+            router
+                .get('/media-record', json(async (svc, ctx) => {
+                const id = str(ctx, 'id');
+                if (!id)
+                    throw new DashboardError('id is required', 400);
+                return svc.mediaRecord(id);
+            }))
+                .as('media.dashboard.media_record');
+            router
+                .post('/media-record/delete', json(async (svc, ctx) => {
+                const body = ctx.request.body();
+                if (!body.id)
+                    throw new DashboardError('id is required', 400);
+                await svc.deleteMediaRecord(body.id);
+            }))
+                .as('media.dashboard.media_record.delete');
+            router
+                .post('/copy', json(async (svc, ctx) => {
+                await svc.copy(copyMoveBody(ctx));
+            }))
+                .as('media.dashboard.copy');
+            router
+                .post('/move', json(async (svc, ctx) => {
+                await svc.move(copyMoveBody(ctx));
+            }))
+                .as('media.dashboard.move');
+            router
+                .post('/delete', json(async (svc, ctx) => {
+                const body = ctx.request.body();
+                if (!body.disk)
+                    throw new DashboardError('disk is required', 400);
+                await svc.remove({
+                    disk: body.disk,
+                    keys: Array.isArray(body.keys) ? body.keys : [],
+                });
+            }))
+                .as('media.dashboard.delete');
+            router
+                .post('/folder', json(async (svc, ctx) => {
+                await svc.createFolder(folderBody(ctx));
+            }))
+                .as('media.dashboard.folder.create');
+            router
+                .post('/folder/delete', json(async (svc, ctx) => {
+                await svc.deleteFolder(folderBody(ctx));
+            }))
+                .as('media.dashboard.folder.delete');
+            router
+                .post('/folder/copy', json(async (svc, ctx) => {
+                await svc.copyFolder(copyMoveBody(ctx));
+            }))
+                .as('media.dashboard.folder.copy');
+            router
+                .post('/folder/move', json(async (svc, ctx) => {
+                await svc.moveFolder(copyMoveBody(ctx));
+            }))
+                .as('media.dashboard.folder.move');
+        });
+        group.prefix(apiBase);
+        // Host `middleware` first (e.g. an admin check), then the built-in session guard (when `auth` is
+        // configured) — a request must pass both. The mutating routes above are further gated at the
+        // service layer by `actions` (unconditionally mounted; `DashboardService` 403s when disabled), so
+        // read-only hosts can leave them mounted without enabling `actions`.
+        applyMiddleware(group, auth ? [...middleware, sessionGuardMiddleware(auth)] : middleware);
+    }
+    #mountSpa(router, basePath, bootstrap, middleware) {
+        const serveIndex = async (ctx) => {
+            let html;
+            try {
+                html = await readFile(resolvePath(spaDirectory(), 'index.html'), 'utf8');
+            }
+            catch {
+                return ctx.response
+                    .status(404)
+                    .send('media dashboard SPA is not built (run the package build to emit dist/assets/spa)');
+            }
+            return ctx.response
+                .header('content-type', 'text/html; charset=utf-8')
+                .header('cache-control', 'no-store, must-revalidate')
+                .send(renderIndexHtml(html, basePath, bootstrap));
+        };
+        const group = router.group(() => {
+            router.get('/', serveIndex).as('media.dashboard.index');
+            router
+                .get('/assets/:file', async (ctx) => {
+                const file = basename(String(ctx.params.file));
+                const root = resolvePath(spaDirectory(), 'assets');
+                const assetPath = resolvePath(root, file);
+                if (!assetPath.startsWith(root))
+                    return ctx.response.status(404).send('');
+                let bytes;
+                try {
+                    bytes = await readFile(assetPath);
+                }
+                catch {
+                    return ctx.response.status(404).send('');
+                }
+                return ctx.response
+                    .header('content-type', contentTypeFor(file))
+                    .header('cache-control', 'public, max-age=31536000, immutable')
+                    .send(bytes);
+            })
+                .as('media.dashboard.assets');
+        });
+        group.prefix(basePath);
+        applyMiddleware(group, middleware);
+    }
+    /** Derive browsable disk names from the media config when the console config does not list them. */
+    #resolveDiskNames(config) {
+        if (config.disks && config.disks.length > 0)
+            return config.disks;
+        const media = this.app.config.get('media', {});
+        const drive = this.app.config.get('drive', {});
+        const defaultName = media.disk ?? drive.default ?? 'default';
+        const configured = media.disks ? Object.keys(media.disks) : [];
+        return Array.from(new Set([defaultName, ...configured]));
+    }
+}
+function str(ctx, key) {
+    const value = ctx.request.input(key);
+    return typeof value === 'string' && value !== '' ? value : undefined;
+}
+function copyMoveBody(ctx) {
+    const body = ctx.request.body();
+    if (!body.disk)
+        throw new DashboardError('disk is required', 400);
+    return {
+        disk: body.disk,
+        from: body.from ?? '',
+        to: body.to ?? '',
+        ...(body.toDisk !== undefined ? { toDisk: body.toDisk } : {}),
+    };
+}
+/** Body for the folder create/delete actions — a disk and the folder prefix. */
+function folderBody(ctx) {
+    const body = ctx.request.body();
+    if (!body.disk)
+        throw new DashboardError('disk is required', 400);
+    return { disk: body.disk, prefix: body.prefix ?? '' };
+}
+/** Apply host middleware to a route group without depending on Adonis's exact middleware typings. */
+function applyMiddleware(group, middleware) {
+    if (middleware.length === 0)
+        return;
+    group.use(middleware);
+}
+/* Session-cookie helpers ---------------------------------------------------------------------- */
+/** Run a host hook (login/session) defensively: a throw is a denial (null), never a 500. */
+async function runAuthHook(run) {
+    try {
+        return (await run()) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function sessionFromRequest(ctx, auth) {
+    const cookieValue = parseCookieHeader(ctx.request.header('cookie'))[SESSION_COOKIE_NAME];
+    if (cookieValue === undefined)
+        return null;
+    return verifySessionCookie(cookieValue, { secret: auth.secret });
+}
+function userInfoFromSession(session) {
+    return {
+        id: session.sub,
+        ...(session.name !== undefined ? { name: session.name } : {}),
+        roles: session.roles,
+    };
+}
+function userInfoFromUser(user) {
+    return {
+        id: user.id,
+        ...(user.name !== undefined ? { name: user.name } : {}),
+        roles: user.roles ?? [],
+    };
+}
+function issueSessionCookie(ctx, user, auth, now) {
+    const value = signSessionCookie(user, {
+        secret: auth.secret,
+        ttlMs: auth.ttlMs,
+        ...(now !== undefined ? { now } : {}),
+    });
+    ctx.response.append('set-cookie', serializeSetCookie(SESSION_COOKIE_NAME, value, {
+        path: SESSION_COOKIE_PATH,
+        maxAgeSeconds: Math.floor(auth.ttlMs / 1000),
+        secure: ctx.request.secure(),
+    }));
+}
+function clearSessionCookie(ctx) {
+    ctx.response.append('set-cookie', serializeSetCookie(SESSION_COOKIE_NAME, '', {
+        path: SESSION_COOKIE_PATH,
+        maxAgeSeconds: 0,
+        secure: ctx.request.secure(),
+        clear: true,
+    }));
+}
+/**
+ * Gates a route group on a valid session cookie. Sliding renewal + revalidation mirrors the NestJS
+ * sibling console's `MediaConsoleGuard`: past half the TTL, the host's `revalidate` hook (if any)
+ * re-checks the user before a fresh cookie is issued, so a deactivated operator loses access instead
+ * of riding a self-renewing cookie.
+ */
+function sessionGuardMiddleware(auth) {
+    return async (ctx, next) => {
+        const session = sessionFromRequest(ctx, auth);
+        // Absent/invalid/expired cookie => 401 with the login modes, same shape as `/me`'s refusal.
+        if (!session)
+            return ctx.response.status(401).json({ auth: { modes: auth.modes } });
+        const now = Date.now();
+        if (now - session.iat > auth.ttlMs / 2) {
+            const user = userInfoFromSession(session);
+            if (auth.revalidate) {
+                const allowed = await runAuthHookBoolean(() => auth.revalidate?.(user));
+                if (!allowed) {
+                    clearSessionCookie(ctx);
+                    return ctx.response.status(401).json({ auth: { modes: auth.modes } });
+                }
+            }
+            issueSessionCookie(ctx, user, auth, now);
+        }
+        return next();
+    };
+}
+async function runAuthHookBoolean(run) {
+    try {
+        return (await run()) ?? false;
+    }
+    catch {
+        return false; // Fail closed.
+    }
+}
+//# sourceMappingURL=dashboard_provider.js.map