Study/server/app.ts
Elijah c595e0ff2c
All checks were successful
Verify and publish V2 container / build-and-push (push) Successful in 1m0s
Third revision: web search, MCP sign-in, exams, intelligent UI, clarifying questions
- Built-in Parallel web search (keyless; optional sign-in for higher limits and research)
  with its own settings page; OAuth sign-in (RFC 9728/8414/7591, PKCE, RFC 8707) for any
  MCP server, with token refresh and pre-registered client support
- Friendly tool steps (icon, name, status; details on click) and ids stripped from results;
  per-chat tool switches; taller thinking box
- Exams within classes: exam tabs, scoped lists, uploads, imports and Generate; exam-only
  material for generation; class setting for what the groups are called
- Assistant can ask clarifying questions in an inline form before generating
- OpenUI blocks (charts, questions, flashcards, inputs) in assistant, Explain and share chats
- Explain beside the quiz on wide screens, grounded in the cited source pages
- Quiz results: percentage ring coloured by score band, rainbow at 100
- Share links: assistant button like the owner's, hidden during quizzes; documents readable
  in the browser
- Live draft and library updates over server-sent events

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 20:30:00 -07:00

189 lines
7.7 KiB
TypeScript

import fs from 'node:fs';
import { setLocalEmbeddingDefault } from './services/semantic.ts';
import path from 'node:path';
import { Hono } from 'hono';
import { compress } from 'hono/compress';
import { z } from 'zod';
import { AIError } from './ai/types.ts';
import { authRoutes, csrfGuard, requireAuth } from './auth.ts';
import { HttpError, zodIssues, type AppContext } from './http.ts';
import { aiRoutes } from './routes/ai.ts';
import { APP_VERSION, dataRoutes } from './routes/data.ts';
import { documentRoutes, mediaRoute } from './routes/documents.ts';
import { libraryRoutes } from './routes/library.ts';
import { publicRoutes, shareRoutes } from './routes/shares.ts';
import { studyRoutes } from './routes/study.ts';
import { liveChanges } from './routes/events.ts';
import { notifyChange, topicOfWrite } from './services/events.ts';
import { expireOverdueAttempts } from './services/attempts.ts';
const MIME: Record<string, string> = {
'.html': 'text/html; charset=utf-8',
'.js': 'text/javascript; charset=utf-8',
'.mjs': 'text/javascript; charset=utf-8',
'.css': 'text/css; charset=utf-8',
'.json': 'application/json; charset=utf-8',
'.webmanifest': 'application/manifest+json; charset=utf-8',
'.svg': 'image/svg+xml',
'.png': 'image/png',
'.jpg': 'image/jpeg',
'.ico': 'image/x-icon',
'.woff2': 'font/woff2',
'.woff': 'font/woff',
'.txt': 'text/plain; charset=utf-8',
'.map': 'application/json; charset=utf-8',
};
const CSP = [
"default-src 'self'",
"script-src 'self'",
"style-src 'self' 'unsafe-inline'",
"img-src 'self' data: blob:",
"font-src 'self' data:",
"connect-src 'self'",
"frame-src 'self' blob:",
"worker-src 'self' blob:",
"object-src 'none'",
"base-uri 'self'",
"form-action 'self'",
"frame-ancestors 'self'",
].join('; ');
const AI_STATUS: Partial<Record<AIError['code'], number>> = { not_configured: 409, bad_request: 400, unsupported: 400, context_length: 413, rate_limit: 429, quota: 402, aborted: 499 };
export function createApp(app: AppContext): Hono {
const hono = new Hono();
setLocalEmbeddingDefault(app.config.localEmbeddings);
hono.onError((err, c) => {
if (err instanceof HttpError) {
if (err.status === 429 && typeof (err.details as { retryAfter?: number } | undefined)?.retryAfter === 'number') {
c.header('Retry-After', String((err.details as { retryAfter: number }).retryAfter));
}
return c.json({ error: { code: err.code, message: err.message, details: err.details } }, err.status as never);
}
if (err instanceof z.ZodError) {
const issues = zodIssues(err);
const first = issues[0];
return c.json({ error: { code: 'validation', message: first ? `${first.path ? `${first.path}: ` : ''}${first.message}` : 'Invalid input', details: issues } }, 422);
}
if (err instanceof AIError) {
return c.json({ error: { code: `ai_${err.code}`, message: err.message, details: err.providerMessage } }, (AI_STATUS[err.code] ?? 502) as never);
}
// Hono's own HTTP exceptions (body limit etc.)
const maybe = err as { status?: number; message?: string; getResponse?: () => Response };
if (typeof maybe.status === 'number' && maybe.status >= 400 && maybe.status < 500) {
return c.json({ error: { code: 'bad_request', message: maybe.message || 'Bad request' } }, maybe.status as never);
}
app.log('error', `Unhandled error on ${c.req.method} ${new URL(c.req.url).pathname}`, err);
return c.json({ error: { code: 'internal', message: 'Something went wrong on the server.' } }, 500);
});
// Security headers on everything.
hono.use('*', async (c, next) => {
await next();
const h = c.res.headers;
if (!h.has('X-Content-Type-Options')) h.set('X-Content-Type-Options', 'nosniff');
if (!h.has('Referrer-Policy')) h.set('Referrer-Policy', 'same-origin');
h.set('X-Frame-Options', 'SAMEORIGIN');
h.set('Permissions-Policy', 'camera=(), microphone=(), geolocation=(), payment=()');
if ((h.get('Content-Type') ?? '').startsWith('text/html') && !h.has('Content-Security-Policy')) h.set('Content-Security-Policy', CSP);
});
// gzip for API JSON and static text; event streams must not be buffered.
const gzip = compress();
hono.use('*', async (c, next) => {
const p = c.req.path;
if (p === '/api/ai/chat' || p === '/api/ai/explain' || p === '/api/events' || p.endsWith('/stream') || /^\/api\/public\/[^/]+\/(chat|explain)$/.test(p) || p.startsWith('/api/backup') || p.endsWith('/file') || p.startsWith('/media/')) return next();
return gzip(c, next);
});
hono.get('/api/health', (c) => {
try {
app.db.get('SELECT 1 AS ok');
return c.json({ ok: true, version: APP_VERSION });
} catch {
return c.json({ ok: false }, 503);
}
});
// Tell open tabs when drafts, documents or the library change (see /api/events).
app.db.onWrite = (sql) => {
const topic = topicOfWrite(sql);
if (topic) notifyChange(topic);
};
const api = new Hono();
api.use('*', async (c, next) => {
c.header('Cache-Control', 'no-store');
await next();
});
api.use('*', csrfGuard());
api.route('/auth', authRoutes(app));
api.route('/public', publicRoutes(app));
const secured = new Hono();
secured.use('*', requireAuth(app));
// Timed exams end on the wall clock even if nobody has the session open: submit any that are
// overdue before reading data, so lists never offer to resume an expired exam.
secured.use('*', async (c, next) => {
if (c.req.method === 'GET') {
try {
expireOverdueAttempts(app.db);
} catch (err) {
app.log('warn', 'Could not submit overdue timed sessions', err);
}
}
await next();
});
secured.route('/', libraryRoutes(app));
secured.route('/', studyRoutes(app));
secured.route('/', shareRoutes(app));
secured.route('/', documentRoutes(app));
secured.route('/', aiRoutes(app));
secured.route('/', dataRoutes(app));
secured.get('/events', (c) => liveChanges(c));
api.route('/', secured);
api.all('*', (c) => c.json({ error: { code: 'not_found', message: 'Unknown API route' } }, 404));
hono.route('/api', api);
hono.route('/media', mediaRoute(app));
/* ------------------------------ web app ------------------------------ */
const webDir = app.config.webDir;
const sendFile = (file: string, cache: string): Response => {
const ext = path.extname(file).toLowerCase();
return new Response(fs.readFileSync(file), { headers: { 'Content-Type': MIME[ext] ?? 'application/octet-stream', 'Cache-Control': cache } });
};
hono.get('*', (c) => {
if (!webDir) {
return c.text('The web app has not been built. Run "npm run build", or use "npm run dev" and open the Vite dev server.', 404);
}
let urlPath: string;
try {
urlPath = decodeURIComponent(new URL(c.req.url).pathname);
} catch {
return c.text('Invalid URL', 400);
}
const candidate = path.normalize(path.join(webDir, urlPath));
const relative = path.relative(webDir, candidate);
const inside = relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
if (!inside) return c.text('Not found', 404);
if (urlPath !== '/' && fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
// Hashed build assets never change; everything else is revalidated.
const immutable = urlPath.startsWith('/assets/');
return sendFile(candidate, immutable ? 'public, max-age=31536000, immutable' : 'no-cache');
}
if (path.extname(urlPath) && !urlPath.startsWith('/s/')) return c.text('Not found', 404);
const res = sendFile(path.join(webDir, 'index.html'), 'no-cache');
if (urlPath.startsWith('/s/')) {
res.headers.set('X-Robots-Tag', 'noindex, nofollow');
res.headers.set('Referrer-Policy', 'no-referrer');
}
return res;
});
return hono;
}