@justyork/repo-mind 0.3.0

package/dist/ui/parse-multipart.js

@@ -0,0 +1,64 @@
+function extractBoundary(contentType) {
+    const match = /boundary=(?:"([^"]+)"|([^;\s]+))/i.exec(contentType);
+    if (!match) {
+        return null;
+    }
+    return match[1] ?? match[2] ?? null;
+}
+function parseContentDisposition(header) {
+    const result = {};
+    const nameMatch = /name="([^"]+)"/i.exec(header);
+    if (nameMatch) {
+        result.name = nameMatch[1];
+    }
+    const fileMatch = /filename="([^"]+)"/i.exec(header);
+    if (fileMatch) {
+        result.filename = fileMatch[1];
+    }
+    return result;
+}
+/** Minimal multipart/form-data parser for single-file uploads. */
+export function parseMultipartFormData(body, contentType) {
+    const boundary = extractBoundary(contentType);
+    if (!boundary) {
+        throw new Error('missing multipart boundary');
+    }
+    const delimiter = `--${boundary}`;
+    const text = body.toString('latin1');
+    const parts = text.split(delimiter).slice(1, -1);
+    const fields = new Map();
+    const files = new Map();
+    for (const rawPart of parts) {
+        const part = rawPart.replace(/^\r\n/, '').replace(/\r\n$/, '');
+        const headerEnd = part.indexOf('\r\n\r\n');
+        if (headerEnd === -1) {
+            continue;
+        }
+        const headerBlock = part.slice(0, headerEnd);
+        const bodyStart = headerEnd + 4;
+        const bodyEnd = part.length - (part.endsWith('\r\n') ? 2 : 0);
+        const partBodyLatin1 = part.slice(bodyStart, bodyEnd);
+        const partBody = Buffer.from(partBodyLatin1, 'latin1');
+        const disposition = headerBlock
+            .split('\r\n')
+            .find((line) => line.toLowerCase().startsWith('content-disposition:'));
+        if (!disposition) {
+            continue;
+        }
+        const { name, filename } = parseContentDisposition(disposition);
+        if (!name) {
+            continue;
+        }
+        if (filename) {
+            const mimeLine = headerBlock
+                .split('\r\n')
+                .find((line) => line.toLowerCase().startsWith('content-type:'));
+            const mimeType = mimeLine ? mimeLine.split(':')[1]?.trim() ?? 'application/octet-stream' : 'application/octet-stream';
+            files.set(name, { fieldName: name, fileName: filename, mimeType, data: partBody });
+        }
+        else {
+            fields.set(name, partBody.toString('utf8'));
+        }
+    }
+    return { fields, files };
+}

package/dist/ui/publish.d.ts

@@ -0,0 +1,14 @@
+import type { DocIndex } from '../index/doc-index.js';
+import type { DraftRow } from './db/drafts-db.js';
+export interface PublishResult {
+    path: string;
+    slug: string;
+}
+export interface PublishError {
+    code: 'invalid_slug' | 'invalid_type' | 'invalid_status' | 'path_conflict' | 'broken_related';
+    message: string;
+}
+export declare function resolvePublishTargetPath(index: DocIndex, draft: DraftRow): string | null;
+export declare function validateDraftForPublish(index: DocIndex, draft: DraftRow): PublishError | null;
+export declare function buildMarkdownFromDraft(draft: DraftRow): string;
+export declare function publishDraft(index: DocIndex, draft: DraftRow): PublishResult;

package/dist/ui/publish.js

@@ -0,0 +1,83 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import matter from 'gray-matter';
+import { isValidSlug, resolveDocPath } from '../index/slug.js';
+import { TYPE_TO_DIR, isDocStatus, isDocType } from '../index/types.js';
+import { resolveRelativeMdPath } from './safe-path.js';
+export function resolvePublishTargetPath(index, draft) {
+    const knowledgeRoot = index.getKnowledgeRoot();
+    if (!knowledgeRoot) {
+        return null;
+    }
+    if (draft.target_path) {
+        return resolveRelativeMdPath(knowledgeRoot, draft.target_path);
+    }
+    if (draft.forked_from) {
+        const doc = index.getDocBySlug(draft.forked_from);
+        if (doc) {
+            return doc.path;
+        }
+    }
+    const typeDir = TYPE_TO_DIR[draft.type];
+    return resolveDocPath(knowledgeRoot, typeDir, draft.slug);
+}
+export function validateDraftForPublish(index, draft) {
+    if (!isValidSlug(draft.slug)) {
+        return { code: 'invalid_slug', message: `invalid slug: ${draft.slug}` };
+    }
+    if (!isDocType(draft.type)) {
+        return { code: 'invalid_type', message: `invalid type: ${draft.type}` };
+    }
+    if (!isDocStatus(draft.status)) {
+        return { code: 'invalid_status', message: `invalid status: ${draft.status}` };
+    }
+    const knowledgeRoot = index.getKnowledgeRoot();
+    if (!knowledgeRoot) {
+        return { code: 'path_conflict', message: 'no knowledge root' };
+    }
+    const targetPath = resolvePublishTargetPath(index, draft);
+    if (!targetPath) {
+        return { code: 'invalid_slug', message: `cannot resolve path for slug: ${draft.slug}` };
+    }
+    const slugSet = new Set(index.refresh().map((doc) => doc.slug));
+    for (const related of draft.related) {
+        if (!slugSet.has(related) && related !== draft.slug) {
+            return {
+                code: 'broken_related',
+                message: `broken related slug: ${related}`,
+            };
+        }
+    }
+    if (fs.existsSync(targetPath) && !draft.forked_from) {
+        return {
+            code: 'path_conflict',
+            message: `file already exists: ${targetPath}`,
+        };
+    }
+    return null;
+}
+export function buildMarkdownFromDraft(draft) {
+    const frontmatter = {
+        type: draft.type,
+        slug: draft.slug,
+        status: draft.status,
+        title: draft.title,
+        tags: draft.tags,
+        related: draft.related,
+        updated: new Date().toISOString().slice(0, 10),
+    };
+    return matter.stringify(draft.body, frontmatter);
+}
+export function publishDraft(index, draft) {
+    const validation = validateDraftForPublish(index, draft);
+    if (validation) {
+        throw new Error(validation.message);
+    }
+    const knowledgeRoot = index.getKnowledgeRoot();
+    const targetPath = resolvePublishTargetPath(index, draft);
+    const markdown = buildMarkdownFromDraft(draft);
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+    fs.writeFileSync(targetPath, markdown, 'utf8');
+    index.refresh();
+    return { path: targetPath, slug: draft.slug };
+}

package/dist/ui/safe-path.d.ts

@@ -0,0 +1,6 @@
+export declare function isValidFsName(name: string): boolean;
+export declare function normalizeRelativePath(relative: string): string;
+export declare function resolveUnderKnowledgeRoot(knowledgeRoot: string, relative: string): string | null;
+export declare function resolveRelativeMdPath(knowledgeRoot: string, relative: string): string | null;
+export declare function parentRelativePath(relative: string): string;
+export declare function joinRelativePath(parent: string, name: string): string;

package/dist/ui/safe-path.js

@@ -0,0 +1,42 @@
+import path from 'node:path';
+const FS_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+export function isValidFsName(name) {
+    return FS_NAME_PATTERN.test(name) && name !== '.repo-mind' && name !== '.worktrees';
+}
+export function normalizeRelativePath(relative) {
+    return relative.replace(/\\/g, '/').replace(/^\/+/, '').replace(/\/+$/, '');
+}
+export function resolveUnderKnowledgeRoot(knowledgeRoot, relative) {
+    const normalized = normalizeRelativePath(relative);
+    const candidate = path.resolve(knowledgeRoot, normalized);
+    const rootWithSep = knowledgeRoot.endsWith(path.sep)
+        ? knowledgeRoot
+        : `${knowledgeRoot}${path.sep}`;
+    if (!candidate.startsWith(rootWithSep) && candidate !== knowledgeRoot) {
+        return null;
+    }
+    return candidate;
+}
+export function resolveRelativeMdPath(knowledgeRoot, relative) {
+    const normalized = normalizeRelativePath(relative);
+    if (!normalized || normalized.endsWith('.md')) {
+        const base = resolveUnderKnowledgeRoot(knowledgeRoot, normalized);
+        if (!base) {
+            return null;
+        }
+        return base.endsWith('.md') ? base : `${base}.md`;
+    }
+    return resolveUnderKnowledgeRoot(knowledgeRoot, `${normalized}.md`);
+}
+export function parentRelativePath(relative) {
+    const normalized = normalizeRelativePath(relative);
+    const idx = normalized.lastIndexOf('/');
+    if (idx === -1) {
+        return '';
+    }
+    return normalized.slice(0, idx);
+}
+export function joinRelativePath(parent, name) {
+    const base = normalizeRelativePath(parent);
+    return base ? `${base}/${name}` : name;
+}

package/dist/ui/serve-asset.d.ts

@@ -0,0 +1,4 @@
+import type { ServerResponse } from 'node:http';
+export declare function decodeAssetRelativePath(encodedPath: string): string;
+export declare function serveKnowledgeAsset(res: ServerResponse, knowledgeRoot: string, encodedRelative: string): void;
+export declare function assetExists(knowledgeRoot: string, relative: string): boolean;

package/dist/ui/serve-asset.js

@@ -0,0 +1,49 @@
+import fs from 'node:fs';
+import { isImageFileName, mimeTypeForImagePath } from '../index/asset-file.js';
+import { resolveUnderKnowledgeRoot } from './safe-path.js';
+function sendJson(res, status, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(status, {
+        'Content-Type': 'application/json; charset=utf-8',
+        'Content-Length': Buffer.byteLength(payload),
+    });
+    res.end(payload);
+}
+export function decodeAssetRelativePath(encodedPath) {
+    return encodedPath
+        .replace(/^\/+/, '')
+        .split('/')
+        .map((segment) => decodeURIComponent(segment))
+        .join('/');
+}
+export function serveKnowledgeAsset(res, knowledgeRoot, encodedRelative) {
+    const relative = decodeAssetRelativePath(encodedRelative);
+    if (!relative || !isImageFileName(relative)) {
+        sendJson(res, 400, { error: 'invalid asset path' });
+        return;
+    }
+    const absolute = resolveUnderKnowledgeRoot(knowledgeRoot, relative);
+    if (!absolute || !fs.existsSync(absolute) || !fs.statSync(absolute).isFile()) {
+        sendJson(res, 404, { error: 'asset not found' });
+        return;
+    }
+    const contentType = mimeTypeForImagePath(relative);
+    if (!contentType) {
+        sendJson(res, 403, { error: 'unsupported asset type' });
+        return;
+    }
+    const data = fs.readFileSync(absolute);
+    res.writeHead(200, {
+        'Content-Type': contentType,
+        'Content-Length': data.length,
+        'Cache-Control': 'no-cache',
+    });
+    res.end(data);
+}
+export function assetExists(knowledgeRoot, relative) {
+    if (!isImageFileName(relative)) {
+        return false;
+    }
+    const absolute = resolveUnderKnowledgeRoot(knowledgeRoot, relative);
+    return Boolean(absolute && fs.existsSync(absolute) && fs.statSync(absolute).isFile());
+}

package/dist/ui/server.d.ts

@@ -0,0 +1,17 @@
+import http from 'node:http';
+import type { DocIndex } from '../index/doc-index.js';
+import type { DocsWatcher } from './docs-watcher.js';
+import type { DraftsDb } from './db/drafts-db.js';
+export interface UiServerOptions {
+    host?: string;
+    port: number;
+    index: DocIndex;
+    staticDir: string;
+    draftsDb?: DraftsDb;
+    docsWatcher?: DocsWatcher;
+}
+export declare function createUiServer(options: UiServerOptions): http.Server;
+export declare function resolveUiStaticDir(): string;
+export declare function startUiServer(options: UiServerOptions): Promise<http.Server>;
+/** Destroys open HTTP connections (including SSE) so shutdown can complete. */
+export declare function destroyUiServerConnections(server: http.Server): void;

package/dist/ui/server.js

@@ -0,0 +1,237 @@
+import fs from 'node:fs';
+import http from 'node:http';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { routeApi, handleDocsEvents } from './api-handlers.js';
+import { handleDraftApi } from './draft-api.js';
+import { serveKnowledgeAsset } from './serve-asset.js';
+import { handleAssetUpload, MAX_ASSET_UPLOAD_BYTES } from './upload-asset.js';
+const MIME_TYPES = {
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.svg': 'image/svg+xml',
+    '.json': 'application/json; charset=utf-8',
+    '.ico': 'image/x-icon',
+    '.png': 'image/png',
+    '.woff2': 'font/woff2',
+};
+const MAX_BODY_BYTES = 2 * 1024 * 1024;
+function readBodyBuffer(req, maxBytes) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        req.on('data', (chunk) => {
+            size += chunk.length;
+            if (size > maxBytes) {
+                reject(new Error('request body too large'));
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on('end', () => resolve(Buffer.concat(chunks)));
+        req.on('error', reject);
+    });
+}
+function resolveStaticPath(staticDir, requestPath) {
+    const normalized = path.normalize(requestPath).replace(/^(\.\.(\/|\\|$))+/, '');
+    const filePath = path.join(staticDir, normalized);
+    const resolvedStatic = path.resolve(staticDir);
+    const resolvedFile = path.resolve(filePath);
+    if (!resolvedFile.startsWith(resolvedStatic)) {
+        return null;
+    }
+    return resolvedFile;
+}
+function sendJson(res, status, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(status, {
+        'Content-Type': 'application/json; charset=utf-8',
+        'Content-Length': Buffer.byteLength(payload),
+    });
+    res.end(payload);
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        req.on('data', (chunk) => {
+            size += chunk.length;
+            if (size > MAX_BODY_BYTES) {
+                reject(new Error('request body too large'));
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        req.on('error', reject);
+    });
+}
+function serveStatic(res, staticDir, requestPath) {
+    const relative = requestPath === '/' ? 'index.html' : requestPath.replace(/^\//, '');
+    let filePath = resolveStaticPath(staticDir, relative);
+    if (filePath && fs.existsSync(filePath) && fs.statSync(filePath).isDirectory()) {
+        filePath = path.join(filePath, 'index.html');
+    }
+    if (!filePath || !fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
+        const spaFallback = resolveStaticPath(staticDir, 'index.html');
+        if (!spaFallback || !fs.existsSync(spaFallback)) {
+            return false;
+        }
+        filePath = spaFallback;
+    }
+    const ext = path.extname(filePath);
+    const contentType = MIME_TYPES[ext] ?? 'application/octet-stream';
+    const data = fs.readFileSync(filePath);
+    res.writeHead(200, {
+        'Content-Type': contentType,
+        'Content-Length': data.length,
+    });
+    res.end(data);
+    return true;
+}
+export function createUiServer(options) {
+    const host = options.host ?? '127.0.0.1';
+    const { staticDir, index, draftsDb, docsWatcher } = options;
+    return http.createServer((req, res) => {
+        void (async () => {
+            const method = req.method ?? 'GET';
+            const urlPath = new URL(req.url ?? '/', `http://${host}`).pathname;
+            if (urlPath.startsWith('/api/')) {
+                if (urlPath === '/api/assets/upload' && method === 'POST') {
+                    const knowledgeRoot = index.getKnowledgeRoot();
+                    if (!knowledgeRoot) {
+                        sendJson(res, 404, { error: 'no docs/ directory found' });
+                        return;
+                    }
+                    const contentType = req.headers['content-type'] ?? '';
+                    if (!contentType.toLowerCase().includes('multipart/form-data')) {
+                        sendJson(res, 400, { error: 'multipart/form-data required' });
+                        return;
+                    }
+                    let bodyBuffer;
+                    try {
+                        bodyBuffer = await readBodyBuffer(req, MAX_ASSET_UPLOAD_BYTES);
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : 'bad request';
+                        sendJson(res, 400, { error: message });
+                        return;
+                    }
+                    const uploadResponse = handleAssetUpload(knowledgeRoot, bodyBuffer, contentType);
+                    sendJson(res, uploadResponse.status, uploadResponse.body);
+                    return;
+                }
+                if (urlPath.startsWith('/api/assets/') && method === 'GET') {
+                    const knowledgeRoot = index.getKnowledgeRoot();
+                    if (!knowledgeRoot) {
+                        sendJson(res, 404, { error: 'no docs/ directory found' });
+                        return;
+                    }
+                    serveKnowledgeAsset(res, knowledgeRoot, urlPath.slice('/api/assets/'.length));
+                    return;
+                }
+                if (urlPath === '/api/events' && method === 'GET') {
+                    handleDocsEvents(req, res, docsWatcher);
+                    return;
+                }
+                let bodyRaw = '';
+                if (method === 'POST' || method === 'PUT' || method === 'DELETE') {
+                    try {
+                        bodyRaw = await readBody(req);
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : 'bad request';
+                        sendJson(res, 400, { error: message });
+                        return;
+                    }
+                }
+                const draftResponse = handleDraftApi(index, draftsDb, method, urlPath, bodyRaw);
+                if (draftResponse) {
+                    sendJson(res, draftResponse.status, draftResponse.body);
+                    return;
+                }
+                if (urlPath.startsWith('/api/drafts')) {
+                    sendJson(res, 503, { error: 'drafts database unavailable' });
+                    return;
+                }
+                if (method !== 'GET' && method !== 'HEAD') {
+                    sendJson(res, 405, { error: 'method not allowed' });
+                    return;
+                }
+                const apiResponse = routeApi(index, req);
+                if (apiResponse) {
+                    if (method === 'HEAD') {
+                        res.writeHead(apiResponse.status);
+                        res.end();
+                        return;
+                    }
+                    sendJson(res, apiResponse.status, apiResponse.body);
+                    return;
+                }
+                sendJson(res, 404, { error: 'not found' });
+                return;
+            }
+            if (method !== 'GET' && method !== 'HEAD') {
+                sendJson(res, 405, { error: 'method not allowed' });
+                return;
+            }
+            if (method === 'HEAD') {
+                res.writeHead(200);
+                res.end();
+                return;
+            }
+            if (!serveStatic(res, staticDir, urlPath)) {
+                sendJson(res, 503, {
+                    error: 'UI assets not found — run `npm run build:ui` in the repo-mind package',
+                });
+            }
+        })().catch((error) => {
+            const message = error instanceof Error ? error.message : 'internal error';
+            sendJson(res, 500, { error: message });
+        });
+    });
+}
+export function resolveUiStaticDir() {
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    const packageRoot = path.join(moduleDir, '..', '..');
+    return path.join(packageRoot, 'ui', 'dist');
+}
+export function startUiServer(options) {
+    const host = options.host ?? '127.0.0.1';
+    const server = createUiServer(options);
+    attachActiveConnectionTracking(server);
+    return new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(options.port, host, () => {
+            server.removeListener('error', reject);
+            resolve(server);
+        });
+    });
+}
+const activeSockets = new WeakMap();
+function attachActiveConnectionTracking(server) {
+    const sockets = new Set();
+    activeSockets.set(server, sockets);
+    server.on('connection', (socket) => {
+        sockets.add(socket);
+        socket.on('close', () => {
+            sockets.delete(socket);
+        });
+    });
+}
+/** Destroys open HTTP connections (including SSE) so shutdown can complete. */
+export function destroyUiServerConnections(server) {
+    const sockets = activeSockets.get(server);
+    if (sockets) {
+        for (const socket of sockets) {
+            socket.destroy();
+        }
+        sockets.clear();
+    }
+    if (typeof server.closeAllConnections === 'function') {
+        server.closeAllConnections();
+    }
+}

package/dist/ui/stats.d.ts

@@ -0,0 +1,9 @@
+import type { DocIndex } from '../index/doc-index.js';
+import { type DocStatus, type DocType } from '../index/types.js';
+export interface KnowledgeStats {
+    byType: Record<DocType, number>;
+    byStatus: Record<DocStatus, number>;
+    brokenRelatedCount: number;
+    totalDocs: number;
+}
+export declare function computeKnowledgeStats(index: DocIndex): KnowledgeStats;

package/dist/ui/stats.js

@@ -0,0 +1,23 @@
+import { DOC_STATUSES, DOC_TYPES } from '../index/types.js';
+export function computeKnowledgeStats(index) {
+    const byType = Object.fromEntries(DOC_TYPES.map((t) => [t, 0]));
+    const byStatus = Object.fromEntries(DOC_STATUSES.map((s) => [s, 0]));
+    const docs = index.refresh();
+    const slugSet = new Set(docs.map((doc) => doc.slug));
+    let brokenRelatedCount = 0;
+    for (const doc of docs) {
+        byType[doc.type] += 1;
+        byStatus[doc.status] += 1;
+        for (const related of doc.related) {
+            if (!slugSet.has(related)) {
+                brokenRelatedCount += 1;
+            }
+        }
+    }
+    return {
+        byType,
+        byStatus,
+        brokenRelatedCount,
+        totalDocs: docs.length,
+    };
+}

package/dist/ui/templates.d.ts

@@ -0,0 +1,12 @@
+import type { DocType } from '../index/types.js';
+export interface TemplateInfo {
+    id: string;
+    label: string;
+    type: DocType;
+    filename: string;
+}
+export declare function listPageTemplates(): TemplateInfo[];
+export declare function readPageTemplate(templateId: string): {
+    body: string;
+    title?: string;
+};

package/dist/ui/templates.js

@@ -0,0 +1,39 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import matter from 'gray-matter';
+import { fileURLToPath } from 'node:url';
+const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const TEMPLATES_DIR = path.join(PACKAGE_ROOT, 'templates');
+const TEMPLATE_LABELS = {
+    'adr-example': { label: 'ADR', type: 'adr' },
+    'feature-spec-example': { label: 'Feature spec', type: 'feature-spec' },
+    'glossary-term-example': { label: 'Glossary term', type: 'glossary-term' },
+    'open-question-example': { label: 'Open question', type: 'open-question' },
+    'agent-instruction-example': { label: 'Agent instruction', type: 'agent-instruction' },
+    'combat-system-example': { label: 'Feature spec (example)', type: 'feature-spec' },
+};
+export function listPageTemplates() {
+    if (!fs.existsSync(TEMPLATES_DIR)) {
+        return [];
+    }
+    const templates = [];
+    for (const filename of fs.readdirSync(TEMPLATES_DIR)) {
+        if (!filename.endsWith('.md')) {
+            continue;
+        }
+        const id = filename.replace(/\.md$/, '');
+        const meta = TEMPLATE_LABELS[id] ?? { label: id, type: 'wiki-page' };
+        templates.push({ id, label: meta.label, type: meta.type, filename });
+    }
+    return templates.sort((a, b) => a.label.localeCompare(b.label));
+}
+export function readPageTemplate(templateId) {
+    const safeId = templateId.replace(/[^a-zA-Z0-9_-]/g, '');
+    const filePath = path.join(TEMPLATES_DIR, `${safeId}.md`);
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`unknown template: ${templateId}`);
+    }
+    const parsed = matter(fs.readFileSync(filePath, 'utf8'));
+    const title = typeof parsed.data.title === 'string' ? parsed.data.title : undefined;
+    return { body: parsed.content.trimStart(), title };
+}

package/dist/ui/upload-asset.d.ts

@@ -0,0 +1,11 @@
+export declare const MAX_ASSET_UPLOAD_BYTES: number;
+export interface AssetUploadResult {
+    relativePath: string;
+    url: string;
+}
+export declare function handleAssetUpload(knowledgeRoot: string, body: Buffer, contentType: string): {
+    status: number;
+    body: AssetUploadResult | {
+        error: string;
+    };
+};