@karmaniverous/jeeves-server 3.0.0-0

package/dist/src/routes/api/directory.js

@@ -0,0 +1,93 @@
+/**
+ * Directory listing API route.
+ *
+ * Handles: GET /api/path/*
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { _directoryVisibleUnderScopes, _pathMatchesPatterns, _pathMatchesScopes, } from '../../auth/keys.js';
+import { getConfig } from '../../config/index.js';
+import { filterBreadcrumbsForOutsider } from '../../util/breadcrumbs.js';
+import { breadcrumbParts, fsPathToUrl, getRoots, urlPathToFs, } from '../../util/platform.js';
+// eslint-disable-next-line @typescript-eslint/require-await
+export const directoryRoutes = async (fastify) => {
+    const roots = getRoots(getConfig().roots);
+    fastify.get('/api/path/*', async (request, reply) => {
+        const reqPath = request.params['*'];
+        if (!reqPath)
+            return reply.redirect('/api/drives');
+        const fsPath = urlPathToFs(reqPath, roots);
+        if (!fsPath)
+            return reply.code(404).send({ error: 'Invalid path' });
+        const resolved = path.resolve(fsPath);
+        if (!fs.existsSync(resolved)) {
+            return reply.code(404).send({ error: 'Not found', path: resolved });
+        }
+        const stats = fs.statSync(resolved);
+        if (!stats.isDirectory()) {
+            const ext = path.extname(resolved).toLowerCase();
+            return reply.send({
+                type: 'file',
+                path: reqPath,
+                ext,
+                size: stats.size,
+                mtime: stats.mtime.toISOString().split('T')[0],
+            });
+        }
+        const isInsider = request.accessMode === 'insider';
+        const insiderScopes = request.insiderScopes ?? null;
+        const allEntries = fs.readdirSync(resolved, { withFileTypes: true });
+        const entries = insiderScopes
+            ? allEntries.filter((entry) => {
+                const entryPath = path.join(resolved, entry.name);
+                const entryUrlPath = fsPathToUrl(entryPath, roots);
+                if (insiderScopes.deny.length > 0) {
+                    if (_pathMatchesPatterns(entryUrlPath, insiderScopes.deny))
+                        return false;
+                }
+                if (entry.isDirectory()) {
+                    return _directoryVisibleUnderScopes(entryUrlPath, insiderScopes.allow);
+                }
+                return _pathMatchesScopes(entryUrlPath, insiderScopes);
+            })
+            : allEntries;
+        const sorted = entries.sort((a, b) => {
+            if (a.isDirectory() && !b.isDirectory())
+                return -1;
+            if (!a.isDirectory() && b.isDirectory())
+                return 1;
+            return a.name.localeCompare(b.name);
+        });
+        const result = sorted.map((entry) => {
+            const entryPath = path.join(resolved, entry.name);
+            let size = null;
+            let mtime = null;
+            const ext = path.extname(entry.name).toLowerCase();
+            try {
+                const entryStats = fs.statSync(entryPath);
+                mtime = entryStats.mtime.toISOString().split('T')[0];
+                if (!entry.isDirectory())
+                    size = entryStats.size;
+            }
+            catch {
+                /* ignore */
+            }
+            return {
+                name: entry.name,
+                type: entry.isDirectory() ? 'directory' : 'file',
+                ext,
+                size,
+                mtime,
+            };
+        });
+        const breadcrumbs = breadcrumbParts(resolved, roots);
+        const matchedPath = request.authMatchedPath ?? null;
+        const filteredBreadcrumbs = filterBreadcrumbsForOutsider(breadcrumbs, isInsider, matchedPath, true);
+        return reply.send({
+            path: reqPath,
+            entries: result,
+            breadcrumbs: filteredBreadcrumbs,
+            isInsider,
+        });
+    });
+};

package/dist/src/routes/api/drives.js

@@ -0,0 +1,15 @@
+/**
+ * Drive listing API route.
+ *
+ * Handles: GET /api/drives
+ */
+import { getConfig } from '../../config/index.js';
+import { getRoots } from '../../util/platform.js';
+// eslint-disable-next-line @typescript-eslint/require-await
+export const drivesRoutes = async (fastify) => {
+    const roots = getRoots(getConfig().roots);
+    fastify.get('/api/drives', async (_request, reply) => {
+        const drives = roots.map((r) => ({ letter: r.id, label: r.label }));
+        return reply.send(drives);
+    });
+};

package/dist/src/routes/api/export.js

@@ -0,0 +1,218 @@
+/**
+ * Export API routes.
+ *
+ * Handles: /api/export/*, /api/mermaid-export/*, /api/plantuml-export/*
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import archiver from 'archiver';
+import { getConfig } from '../../config/index.js';
+import { cacheDiagramBuffer, getCachedDiagramBuffer, } from '../../services/diagramCache.js';
+import { appendEvent } from '../../services/eventQueue.js';
+import { exportPage } from '../../services/export.js';
+import { cacheExport, clearDiagramCacheForFile, clearExportCache, clearStandaloneDiagramCache, getCachedExport, } from '../../services/exportCache.js';
+import { renderMermaidToFile } from '../../services/mermaid.js';
+import { getPlantUmlFormats, renderPlantUmlToBuffer, } from '../../services/plantuml.js';
+import { DIAGRAM_CONTENT_TYPES } from '../../util/fileDetection.js';
+import { getDirSize, getRoots, urlPathToFs } from '../../util/platform.js';
+// eslint-disable-next-line @typescript-eslint/require-await
+export const exportRoutes = async (fastify) => {
+    const roots = getRoots(getConfig().roots);
+    // GET /api/export/*
+    fastify.get('/api/export/*', async (request, reply) => {
+        const reqPath = request.params['*'];
+        if (!reqPath)
+            return reply.code(400).send({ error: 'Path required' });
+        const exportFsPath = urlPathToFs(reqPath, roots);
+        if (!exportFsPath)
+            return reply.code(404).send({ error: 'Invalid path' });
+        const resolved = path.resolve(exportFsPath);
+        if (!fs.existsSync(resolved))
+            return reply.code(404).send({ error: 'Not found', path: resolved });
+        const format = request.query.format ?? 'pdf';
+        const stats = fs.statSync(resolved);
+        // ZIP export for directories
+        if (stats.isDirectory()) {
+            if (format !== 'zip')
+                return reply
+                    .code(400)
+                    .send({ error: 'Directories only support ZIP export' });
+            const isInsider = request.accessMode === 'insider';
+            if (!isInsider)
+                return reply
+                    .code(403)
+                    .send({ error: 'ZIP export requires insider access' });
+            const config = getConfig();
+            const totalSize = getDirSize(resolved);
+            const maxSizeBytes = config.maxZipSizeMb * 1024 * 1024;
+            if (totalSize > maxSizeBytes) {
+                return reply.code(413).send({
+                    error: `Directory too large for ZIP export (${String(Math.round(totalSize / 1024 / 1024))}MB, max ${String(config.maxZipSizeMb)}MB)`,
+                });
+            }
+            const dirName = path.basename(resolved);
+            const archive = archiver('zip', { zlib: { level: 6 } });
+            reply.header('Content-Type', 'application/zip');
+            reply.header('Content-Disposition', `attachment; filename="${dirName}.zip"`);
+            reply.send(archive);
+            archive.directory(resolved, dirName);
+            void archive.finalize();
+            return;
+        }
+        // PDF/DOCX export for files
+        if (format !== 'pdf' && format !== 'docx') {
+            return reply
+                .code(400)
+                .send({ error: 'Files support pdf or docx export' });
+        }
+        const ext = path.extname(resolved).toLowerCase();
+        if (ext !== '.md')
+            return reply
+                .code(400)
+                .send({ error: 'Only markdown files support PDF/DOCX export' });
+        const config = getConfig();
+        const internalKey = config.internalInsiderKey;
+        const { port } = config;
+        const exportKey = request.query.key || internalKey;
+        if (!exportKey)
+            return reply
+                .code(500)
+                .send({ error: 'Export unavailable — no internal key configured' });
+        const exportUrl = `http://localhost:${String(port)}/browse/${reqPath}?key=${exportKey}&render_diagrams=1&plain_code=1`;
+        const fileName = path.basename(resolved);
+        const baseName = fileName.replace(/\.md$/i, '');
+        try {
+            const contentType = format === 'pdf'
+                ? 'application/pdf'
+                : 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+            const fileExt = format === 'pdf' ? 'pdf' : 'docx';
+            // Check export cache
+            const cached = getCachedExport(resolved, format);
+            if (cached) {
+                return await reply
+                    .header('Content-Type', contentType)
+                    .header('Content-Disposition', `attachment; filename="${baseName}.${fileExt}"`)
+                    .header('Content-Length', cached.length)
+                    .send(cached);
+            }
+            const buffer = await exportPage({
+                url: exportUrl,
+                fileName,
+                format: format,
+            });
+            // Cache the result
+            cacheExport(resolved, format, buffer);
+            return await reply
+                .header('Content-Type', contentType)
+                .header('Content-Disposition', `attachment; filename="${baseName}.${fileExt}"`)
+                .header('Content-Length', buffer.length)
+                .send(buffer);
+        }
+        catch (err) {
+            appendEvent({ kind: `${format}_export_error`, error: String(err) });
+            return reply.code(500).send({
+                error: `${format.toUpperCase()} export failed`,
+                details: String(err),
+            });
+        }
+    });
+    // DELETE /api/export-cache/* — clear all caches for a file (insider-only)
+    fastify.delete('/api/export-cache/*', async (request, reply) => {
+        if (request.accessMode !== 'insider') {
+            return reply.code(403).send({ error: 'Insider access required' });
+        }
+        const reqPath = request.params['*'];
+        if (!reqPath)
+            return reply.code(400).send({ error: 'Path required' });
+        const fsPath = urlPathToFs(reqPath, roots);
+        if (!fsPath)
+            return reply.code(404).send({ error: 'Invalid path' });
+        const resolved = path.resolve(fsPath);
+        const { getDiagramCacheDir } = await import('../../services/diagramCache.js');
+        const diagCacheDir = getDiagramCacheDir();
+        const exportCount = clearExportCache(resolved);
+        const embeddedCount = clearDiagramCacheForFile(resolved, diagCacheDir);
+        const standaloneCount = clearStandaloneDiagramCache(resolved, diagCacheDir);
+        return reply.send({
+            cleared: {
+                exports: exportCount,
+                diagrams: embeddedCount + standaloneCount,
+            },
+        });
+    });
+    // GET /api/mermaid-export/*
+    fastify.get('/api/mermaid-export/*', async (request, reply) => {
+        const reqPath = request.params['*'];
+        if (!reqPath)
+            return reply.code(400).send({ error: 'Path required' });
+        const mmdFsPath = urlPathToFs(reqPath, roots);
+        if (!mmdFsPath)
+            return reply.code(404).send({ error: 'Invalid path' });
+        const resolved = path.resolve(mmdFsPath);
+        if (!fs.existsSync(resolved) ||
+            !resolved.toLowerCase().endsWith('.mmd')) {
+            return reply.code(404).send({ error: 'Mermaid file not found' });
+        }
+        const mermaidFormats = ['svg', 'png', 'pdf'];
+        const format = mermaidFormats.includes(request.query.format ?? '')
+            ? request.query.format
+            : 'svg';
+        const source = fs.readFileSync(resolved, 'utf8');
+        // Check cache
+        const cachedBuffer = getCachedDiagramBuffer('mermaid', source, format);
+        if (cachedBuffer) {
+            const downloadName = `${path.basename(resolved, '.mmd')}.${format}`;
+            return reply
+                .header('Content-Type', DIAGRAM_CONTENT_TYPES[format] ?? 'application/octet-stream')
+                .header('Content-Disposition', `attachment; filename="${downloadName}"`)
+                .send(cachedBuffer);
+        }
+        const outFile = await renderMermaidToFile(resolved, format);
+        if (!outFile)
+            return reply.code(500).send({ error: 'Mermaid render failed' });
+        const content = fs.readFileSync(outFile);
+        cacheDiagramBuffer('mermaid', source, content, format);
+        const downloadName = path.basename(outFile);
+        return reply
+            .header('Content-Type', DIAGRAM_CONTENT_TYPES[format] ?? 'application/octet-stream')
+            .header('Content-Disposition', `attachment; filename="${downloadName}"`)
+            .send(content);
+    });
+    // GET /api/plantuml-export/*
+    fastify.get('/api/plantuml-export/*', async (request, reply) => {
+        const reqPath = request.params['*'];
+        if (!reqPath)
+            return reply.code(400).send({ error: 'Path required' });
+        const pumlFsPath = urlPathToFs(reqPath, roots);
+        if (!pumlFsPath)
+            return reply.code(404).send({ error: 'Invalid path' });
+        const resolved = path.resolve(pumlFsPath);
+        const ext = path.extname(resolved).toLowerCase();
+        if (!fs.existsSync(resolved) ||
+            !['.puml', '.plantuml', '.pu'].includes(ext)) {
+            return reply.code(404).send({ error: 'PlantUML file not found' });
+        }
+        const supported = getPlantUmlFormats();
+        const format = supported.includes(request.query.format ?? '')
+            ? request.query.format
+            : 'svg';
+        const source = fs.readFileSync(resolved, 'utf8');
+        const cachedBuffer = getCachedDiagramBuffer('plantuml', source, format);
+        if (cachedBuffer) {
+            const baseName = path.basename(resolved, ext);
+            return reply
+                .header('Content-Type', DIAGRAM_CONTENT_TYPES[format] ?? 'application/octet-stream')
+                .header('Content-Disposition', `attachment; filename="${baseName}.${format}"`)
+                .send(cachedBuffer);
+        }
+        const buffer = await renderPlantUmlToBuffer(resolved, format);
+        if (!buffer)
+            return reply.code(500).send({ error: 'PlantUML render failed' });
+        cacheDiagramBuffer('plantuml', source, buffer, format);
+        const baseName = path.basename(resolved, ext);
+        return reply
+            .header('Content-Type', DIAGRAM_CONTENT_TYPES[format] ?? 'application/octet-stream')
+            .header('Content-Disposition', `attachment; filename="${baseName}.${format}"`)
+            .send(buffer);
+    });
+};

package/dist/src/routes/api/fileContent.js

@@ -0,0 +1,286 @@
+/**
+ * File content API routes.
+ *
+ * Handles: GET /api/file/*, PUT /api/file/*
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { getConfig } from '../../config/index.js';
+import { rewriteLinksForDeepShare } from '../../services/deepShareLinks.js';
+import { getOrRenderDiagram } from '../../services/diagramCache.js';
+import { renderEmbeddedDiagrams, setDiagramContext, } from '../../services/embeddedDiagrams.js';
+import { registerDiagramHashes } from '../../services/exportCache.js';
+import { parseMarkdown } from '../../services/markdown.js';
+import { renderMermaidSvg } from '../../services/mermaid.js';
+import { renderPlantUmlSvg } from '../../services/plantuml.js';
+import { filterBreadcrumbsForOutsider } from '../../util/breadcrumbs.js';
+import { looksLikeText } from '../../util/fileDetection.js';
+import { breadcrumbParts, getRoots, urlPathToFs } from '../../util/platform.js';
+/** Image extensions recognized for type detection. */
+const IMAGE_EXTS = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.ico'];
+/** PlantUML file extensions. */
+const PLANTUML_EXTS = ['.puml', '.plantuml', '.pu'];
+// eslint-disable-next-line @typescript-eslint/require-await
+export const fileContentRoutes = async (fastify) => {
+    const roots = getRoots(getConfig().roots);
+    // GET /api/file/*
+    fastify.get('/api/file/*', async (request, reply) => {
+        const rawOnly = request.query.raw === '1';
+        const reqPath = request.params['*'];
+        if (!reqPath)
+            return reply.code(400).send({ error: 'Path required' });
+        const fsFilePath = urlPathToFs(reqPath, roots);
+        if (!fsFilePath)
+            return reply.code(404).send({ error: 'Invalid path' });
+        const resolved = path.resolve(fsFilePath);
+        if (!fs.existsSync(resolved))
+            return reply.code(404).send({ error: 'Not found' });
+        const stats = fs.statSync(resolved);
+        if (stats.isDirectory())
+            return reply
+                .code(400)
+                .send({ error: 'Use /api/path/ for directories' });
+        const ext = path.extname(resolved).toLowerCase();
+        const fileName = path.basename(resolved);
+        const isInsider = request.accessMode === 'insider';
+        const matchedPath = request.authMatchedPath ?? null;
+        const breadcrumbs = filterBreadcrumbsForOutsider(breadcrumbParts(resolved, roots), isInsider, matchedPath, false);
+        // Markdown
+        if (ext === '.md') {
+            return handleMarkdown(request, reply, resolved, reqPath, rawOnly, fileName, breadcrumbs, isInsider);
+        }
+        // Mermaid
+        if (ext === '.mmd') {
+            const content = fs.readFileSync(resolved, 'utf8');
+            if (rawOnly)
+                return reply.send({
+                    type: 'mermaid',
+                    content,
+                    fileName,
+                    breadcrumbs,
+                    isInsider,
+                });
+            const renderedMermaid = await getOrRenderDiagram('mermaid', content, () => renderMermaidSvg(resolved));
+            return reply.send({
+                type: 'mermaid',
+                content,
+                html: renderedMermaid,
+                fileName,
+                breadcrumbs,
+                isInsider,
+            });
+        }
+        // PlantUML
+        if (PLANTUML_EXTS.includes(ext)) {
+            const content = fs.readFileSync(resolved, 'utf8');
+            if (rawOnly)
+                return reply.send({
+                    type: 'plantuml',
+                    content,
+                    fileName,
+                    breadcrumbs,
+                    isInsider,
+                });
+            const renderedPuml = await getOrRenderDiagram('plantuml', content, () => renderPlantUmlSvg(resolved));
+            return reply.send({
+                type: 'plantuml',
+                content,
+                html: renderedPuml,
+                fileName,
+                breadcrumbs,
+                isInsider,
+            });
+        }
+        // SVG
+        if (ext === '.svg') {
+            const content = fs.readFileSync(resolved, 'utf8');
+            return reply.send({
+                type: 'svg',
+                content,
+                fileName,
+                breadcrumbs,
+                isInsider,
+            });
+        }
+        // Text files
+        const buffer = fs.readFileSync(resolved);
+        if (looksLikeText(buffer)) {
+            // Try watcher render for non-natively-renderable text files
+            if (!rawOnly) {
+                const renderResult = await tryWatcherRender(resolved);
+                if (renderResult && renderResult.renderAs === 'md') {
+                    const { html, headings } = await renderMarkdownContent(renderResult.content, request, resolved, reqPath, isInsider);
+                    return await reply.send({
+                        type: 'markdown',
+                        content: buffer.toString('utf8'),
+                        html,
+                        headings,
+                        fileName,
+                        breadcrumbs,
+                        isInsider,
+                        renderAs: renderResult.renderAs,
+                        matchedRules: renderResult.rules,
+                    });
+                }
+            }
+            return handleText(reply, buffer, ext, rawOnly, fileName, breadcrumbs, isInsider);
+        }
+        // Images
+        if (IMAGE_EXTS.includes(ext)) {
+            return reply.send({ type: 'image', fileName, breadcrumbs, isInsider });
+        }
+        // Binary
+        return reply.send({
+            type: 'binary',
+            fileName,
+            size: stats.size,
+            breadcrumbs,
+            isInsider,
+        });
+    });
+    // PUT /api/file/*
+    fastify.put('/api/file/*', async (request, reply) => {
+        if (request.accessMode !== 'insider') {
+            return reply.code(403).send({ error: 'Insider access required' });
+        }
+        const reqPath = request.params['*'];
+        const fsPath = urlPathToFs(reqPath, roots);
+        if (!fsPath)
+            return reply.code(404).send({ error: 'Invalid path' });
+        const resolved = path.resolve(fsPath);
+        try {
+            const stat = await fs.promises.stat(resolved);
+            if (!stat.isFile())
+                return await reply
+                    .code(400)
+                    .send({ error: 'Can only write to files' });
+        }
+        catch {
+            return reply.code(404).send({ error: 'File not found' });
+        }
+        const body = request.body;
+        if (!body || typeof body.content !== 'string') {
+            return reply
+                .code(400)
+                .send({ error: 'Request body must include "content" string' });
+        }
+        try {
+            await fs.promises.writeFile(resolved, body.content, 'utf8');
+            return await reply.send({
+                ok: true,
+                path: resolved,
+                size: Buffer.byteLength(body.content, 'utf8'),
+            });
+        }
+        catch (err) {
+            return reply
+                .code(500)
+                .send({ error: `Write failed: ${err.message}` });
+        }
+    });
+};
+/**
+ * Try to render a file via the watcher's render endpoint.
+ * Returns null if watcher is not configured, unreachable, or no rules match.
+ */
+async function tryWatcherRender(fsPath) {
+    const config = getConfig();
+    if (!config.watcherUrl)
+        return null;
+    try {
+        const res = await fetch(`${config.watcherUrl}/render`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ path: fsPath }),
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        if (data.rules.length === 0)
+            return null;
+        return data;
+    }
+    catch (err) {
+        console.warn('Watcher render failed for ' + fsPath + ':', err);
+        return null;
+    }
+}
+/**
+ * Shared markdown rendering pipeline: parse → diagram hashes → optional
+ * diagram rendering → optional deep share link rewriting.
+ */
+async function renderMarkdownContent(markdownSource, request, resolved, reqPath, isInsider) {
+    const urlDir = reqPath.includes('/')
+        ? reqPath.substring(0, reqPath.lastIndexOf('/'))
+        : '';
+    const fsDir = path.dirname(resolved);
+    setDiagramContext(fsDir);
+    const { headings, html: parsedHtml } = parseMarkdown(markdownSource, {
+        linkWindowsPaths: true,
+        basePath: urlDir,
+    });
+    let html = parsedHtml;
+    // Register diagram hashes for cache-clear reverse index
+    const diagramHashMatches = [
+        ...html.matchAll(/data-diagram-hash="([a-f0-9]{64})"/g),
+    ];
+    if (diagramHashMatches.length > 0) {
+        registerDiagramHashes(resolved, diagramHashMatches.map((m) => m[1]));
+    }
+    if (request.query.render_diagrams === '1') {
+        html = await renderEmbeddedDiagrams(html, fsDir);
+    }
+    const deepShare = request.deepShareParams;
+    const seed = request.authSeed;
+    if (!isInsider && deepShare && seed) {
+        const maxDepth = parseInt(deepShare.d, 10);
+        const dirs = deepShare.dirs === '1';
+        const currentPath = `/${reqPath}`;
+        if (!isNaN(maxDepth) && maxDepth > 0) {
+            html = rewriteLinksForDeepShare(html, seed, currentPath, maxDepth, dirs, deepShare.s, request.query.exp);
+        }
+    }
+    return { html, headings };
+}
+/** Handle markdown file content. */
+async function handleMarkdown(request, reply, resolved, reqPath, rawOnly, fileName, breadcrumbs, isInsider) {
+    const markdown = fs.readFileSync(resolved, 'utf8');
+    if (rawOnly)
+        return reply.send({
+            type: 'markdown',
+            content: markdown,
+            fileName,
+            breadcrumbs,
+            isInsider,
+        });
+    const { html, headings } = await renderMarkdownContent(markdown, request, resolved, reqPath, isInsider);
+    return reply.send({
+        type: 'markdown',
+        content: markdown,
+        html,
+        headings,
+        fileName,
+        breadcrumbs,
+        isInsider,
+    });
+}
+/** Handle text file content with optional syntax highlighting. */
+function handleText(reply, buffer, ext, rawOnly, fileName, breadcrumbs, isInsider) {
+    const textContent = buffer.toString('utf8');
+    if (rawOnly)
+        return reply.send({
+            type: 'text',
+            content: textContent,
+            fileName,
+            breadcrumbs,
+            isInsider,
+        });
+    return reply.send({
+        type: 'text',
+        content: textContent,
+        fileName,
+        breadcrumbs,
+        isInsider,
+    });
+}

package/dist/src/routes/api/index.js

@@ -0,0 +1,33 @@
+/**
+ * API route registrar — composes all API sub-plugins.
+ */
+import { authStatusRoutes } from './auth-status.js';
+import { diagramsRoutes } from './diagrams.js';
+import { directoryRoutes } from './directory.js';
+import { drivesRoutes } from './drives.js';
+import { exportRoutes } from './export.js';
+import { fileContentRoutes } from './fileContent.js';
+import { linkInfoRoutes } from './linkInfo.js';
+import { addAuthMiddleware } from './middleware.js';
+import { rawRoutes } from './raw.js';
+import { runnerRoutes } from './runner.js';
+import { searchRoutes } from './search.js';
+import { sharingRoutes } from './sharing.js';
+import { statusRoutes } from './status.js';
+export const apiRoute = async (fastify) => {
+    // Add auth hook directly to this context (not as a child plugin)
+    // so it applies to all routes registered below.
+    addAuthMiddleware(fastify);
+    await fastify.register(drivesRoutes);
+    await fastify.register(directoryRoutes);
+    await fastify.register(fileContentRoutes);
+    await fastify.register(linkInfoRoutes);
+    await fastify.register(rawRoutes);
+    await fastify.register(exportRoutes);
+    await fastify.register(diagramsRoutes);
+    await fastify.register(runnerRoutes);
+    await fastify.register(searchRoutes);
+    await fastify.register(sharingRoutes);
+    await fastify.register(authStatusRoutes);
+    await fastify.register(statusRoutes);
+};