@iprep/server 1.1.2

package/src/middleware/error-handler.js

@@ -0,0 +1,9 @@
+import { logger } from '../utils/logger.js';
+
+export function errorHandler(err, req, res, next) {
+  logger.error(`${req.method} ${req.path} →`, err.message);
+  const status = err.status || err.statusCode || 500;
+  res.status(status).json({
+    error: status >= 500 ? 'Internal server error' : err.message,
+  });
+}

package/src/middleware/logger.js

@@ -0,0 +1,9 @@
+import { logger } from '../utils/logger.js';
+
+export function requestLogger(req, res, next) {
+  const start = Date.now();
+  res.on('finish', () => {
+    logger.info(`${req.method} ${req.path} ${res.statusCode} (${Date.now() - start}ms)`);
+  });
+  next();
+}

package/src/middleware/validation.js

@@ -0,0 +1,16 @@
+import { isValidMessage, isValidTutorId, isValidUserId } from '@iprep/shared';
+
+export function validateChatRequest(req, res, next) {
+  const { userId, tutorId, message } = req.body;
+
+  if (!isValidUserId(userId)) {
+    return res.status(400).json({ error: 'Invalid or missing userId' });
+  }
+  if (!isValidTutorId(tutorId)) {
+    return res.status(400).json({ error: `Invalid tutorId. Must be one of the registered tutors.` });
+  }
+  if (!isValidMessage(message)) {
+    return res.status(400).json({ error: 'Invalid or missing message' });
+  }
+  next();
+}

package/src/routes/chat.js

@@ -0,0 +1,18 @@
+import { Router } from 'express';
+import { sendMessage } from '../services/chat-service.js';
+import { validateChatRequest } from '../middleware/validation.js';
+
+const router = Router();
+
+// POST /api/chat
+router.post('/', validateChatRequest, async (req, res, next) => {
+  try {
+    const { userId, tutorId, message, conversationId } = req.body;
+    const result = await sendMessage(userId, tutorId, message, conversationId || null);
+    res.json(result);
+  } catch (err) {
+    next(err);
+  }
+});
+
+export default router;

package/src/routes/conversations.js

@@ -0,0 +1,43 @@
+import { Router } from 'express';
+import { getConversationsByUser, getConversationById, getMessagesByConversation } from '@iprep/db';
+import { isValidTutorId, isValidUserId } from '@iprep/shared';
+
+const router = Router();
+
+// GET /api/conversations?userId=&tutorId=
+router.get('/', async (req, res, next) => {
+  try {
+    const { userId, tutorId } = req.query;
+    if (!isValidUserId(userId) || !isValidTutorId(tutorId)) {
+      return res.status(400).json({ error: 'userId and tutorId are required' });
+    }
+    const conversations = await getConversationsByUser(userId, tutorId);
+    res.json({ conversations });
+  } catch (err) {
+    next(err);
+  }
+});
+
+// GET /api/conversations/:id
+router.get('/:id', async (req, res, next) => {
+  try {
+    const conv = await getConversationById(Number(req.params.id));
+    if (!conv) return res.status(404).json({ error: 'Conversation not found' });
+    res.json({ conversation: conv });
+  } catch (err) {
+    next(err);
+  }
+});
+
+// GET /api/conversations/:id/messages
+router.get('/:id/messages', async (req, res, next) => {
+  try {
+    const convId = Number(req.params.id);
+    const messages = await getMessagesByConversation(convId);
+    res.json({ messages });
+  } catch (err) {
+    next(err);
+  }
+});
+
+export default router;

package/src/routes/documents.js

@@ -0,0 +1,172 @@
+import { Router } from 'express';
+import fs from 'fs/promises';
+import path from 'path';
+import multer from 'multer';
+import { IprepPaths, isValidTutorId } from '@iprep/shared';
+import {
+  prisma,
+  createDocument,
+  getDocumentsByTutor,
+  deleteDocument as dbDeleteDocument,
+} from '@iprep/db';
+
+const router = Router();
+
+const ALLOWED_EXTS = new Set(['.md', '.txt']);
+const MAX_SIZE = 10 * 1024 * 1024; // 10 MB
+
+const upload = multer({
+  storage: multer.memoryStorage(),
+  limits: { fileSize: MAX_SIZE },
+  fileFilter: (_req, file, cb) => {
+    const ext = path.extname(file.originalname).toLowerCase();
+    if (ALLOWED_EXTS.has(ext)) cb(null, true);
+    else cb(new Error(`Unsupported file type: ${ext}`));
+  },
+});
+
+// File formats that don't need conversion — mark success immediately
+const NO_CONVERT_EXTS = new Set(['.md', '.txt']);
+
+function formatExt(filename) {
+  return path.extname(filename).replace('.', '').toUpperCase() || 'FILE';
+}
+
+function initialStatus(filename) {
+  const ext = path.extname(filename).toLowerCase();
+  return NO_CONVERT_EXTS.has(ext) ? 'success' : 'pending';
+}
+
+// Sync filesystem → DB:
+//  1. Create records for files on disk with no DB entry
+//  2. Fix stale 'pending' status on .md/.txt files that don't need conversion
+async function syncDiskToDB(tutorId) {
+  const dir = IprepPaths.documents(tutorId);
+
+  let entries;
+  try {
+    entries = await fs.readdir(dir);
+  } catch {
+    return; // directory doesn't exist yet — nothing to sync
+  }
+
+  const existing = await getDocumentsByTutor(tutorId);
+  const trackedByName = new Map(existing.map((d) => [d.originalName, d]));
+
+  for (const filename of entries) {
+    const ext = path.extname(filename).toLowerCase();
+    if (!ALLOWED_EXTS.has(ext)) continue;
+
+    const filePath = path.join(dir, filename);
+    let stat;
+    try { stat = await fs.stat(filePath); } catch { continue; }
+    if (!stat.isFile()) continue;
+
+    const correct = initialStatus(filename);
+    const record = trackedByName.get(filename);
+
+    if (!record) {
+      // File exists on disk but no DB record — auto-import it
+      await createDocument({
+        tutorId,
+        originalName: filename,
+        originalFormat: formatExt(filename),
+        fileSize: stat.size,
+        conversionStatus: correct,
+      });
+    } else if (record.conversionStatus === 'pending' && correct === 'success') {
+      // Existing record has wrong status — fix it
+      await prisma.document.update({
+        where: { id: record.id },
+        data: { conversionStatus: 'success' },
+      });
+    }
+  }
+}
+
+// GET /api/documents?tutorId=
+router.get('/', async (req, res, next) => {
+  try {
+    const { tutorId } = req.query;
+    if (!tutorId || !isValidTutorId(tutorId)) {
+      return res.status(400).json({ error: 'Valid tutorId is required' });
+    }
+    // Auto-import any files placed directly on disk without going through upload
+    await syncDiskToDB(tutorId);
+    const documents = await getDocumentsByTutor(tutorId);
+    res.json({ documents });
+  } catch (err) {
+    next(err);
+  }
+});
+
+// POST /api/documents  (multipart: tutorId + file)
+router.post('/', upload.single('file'), async (req, res, next) => {
+  try {
+    const { tutorId } = req.body;
+
+    if (!tutorId || !isValidTutorId(tutorId)) {
+      return res.status(400).json({ error: 'Valid tutorId is required' });
+    }
+    if (!req.file) {
+      return res.status(400).json({ error: 'No file uploaded' });
+    }
+
+    // Ensure the documents directory exists
+    const destDir = IprepPaths.documents(tutorId);
+    await fs.mkdir(destDir, { recursive: true });
+
+    // Write file to disk
+    const destPath = path.join(destDir, req.file.originalname);
+    await fs.writeFile(destPath, req.file.buffer);
+
+    // Create DB record (.md/.txt are already plain text — mark success immediately)
+    const document = await createDocument({
+      tutorId,
+      originalName: req.file.originalname,
+      originalFormat: formatExt(req.file.originalname),
+      fileSize: req.file.size,
+      conversionStatus: initialStatus(req.file.originalname),
+    });
+
+    res.status(201).json({ document, message: 'ok' });
+  } catch (err) {
+    next(err);
+  }
+});
+
+// DELETE /api/documents/:docId
+router.delete('/:docId', async (req, res, next) => {
+  try {
+    const { docId } = req.params;
+
+    // Fetch record first so we know tutorId + filename
+    const doc = await prisma.document.findUnique({ where: { id: docId } });
+
+    if (!doc) {
+      return res.status(404).json({ error: 'Document not found' });
+    }
+
+    // Delete file from disk (ignore if already gone)
+    const filePath = path.join(IprepPaths.documents(doc.tutorId), doc.originalName);
+    try {
+      await fs.unlink(filePath);
+    } catch { /* already removed */ }
+
+    await dbDeleteDocument(docId);
+
+    res.json({ success: true });
+  } catch (err) {
+    next(err);
+  }
+});
+
+// Multer error handler (file size / type rejections)
+router.use((err, _req, res, next) => {
+  if (err instanceof multer.MulterError || err.message?.startsWith('Unsupported')) {
+    return res.status(400).json({ error: err.message });
+  }
+  next(err);
+});
+
+export default router;

package/src/routes/health.js

@@ -0,0 +1,9 @@
+import { Router } from 'express';
+
+const router = Router();
+
+router.get('/', (req, res) => {
+  res.json({ status: 'ok', timestamp: new Date().toISOString() });
+});
+
+export default router;

package/src/routes/tutors.js

@@ -0,0 +1,107 @@
+import { Router } from 'express';
+import fs from 'fs/promises';
+import path from 'path';
+import { listTutors, loadTutorConfig } from '../services/tutor-service.js';
+import { isValidTutorId, IprepPaths } from '@iprep/shared';
+
+const TUTORS_DIR = IprepPaths.aitutors;
+
+const router = Router();
+
+// GET /api/tutors
+router.get('/', async (req, res, next) => {
+  try {
+    const tutors = await listTutors();
+    res.json({ tutors });
+  } catch (err) {
+    next(err);
+  }
+});
+
+// GET /api/tutors/:tutorId
+router.get('/:tutorId', async (req, res, next) => {
+  try {
+    const { tutorId } = req.params;
+    if (!isValidTutorId(tutorId)) {
+      return res.status(404).json({ error: 'Tutor not found' });
+    }
+    const config = await loadTutorConfig(tutorId);
+    res.json({ tutor: config });
+  } catch (err) {
+    next(err);
+  }
+});
+
+// GET /api/tutors/:tutorId/files — list .md config files for a tutor
+router.get('/:tutorId/files', async (req, res, next) => {
+  try {
+    const { tutorId } = req.params;
+    if (!isValidTutorId(tutorId)) {
+      return res.status(404).json({ error: 'Tutor not found' });
+    }
+
+    const tutorDir = path.join(TUTORS_DIR, tutorId);
+
+    let entries;
+    try {
+      entries = await fs.readdir(tutorDir);
+    } catch {
+      return res.json({ files: [] });
+    }
+
+    const mdFiles = entries.filter(f => f.endsWith('.md'));
+
+    const files = await Promise.all(
+      mdFiles.map(async (filename) => {
+        const filePath = path.join(tutorDir, filename);
+        const stat = await fs.stat(filePath);
+        return {
+          filename,
+          lastModified: stat.mtime.toISOString(),
+          size: stat.size,
+        };
+      })
+    );
+
+    res.json({ files });
+  } catch (err) {
+    next(err);
+  }
+});
+
+// GET /api/tutors/:tutorId/files/:filename — return raw markdown content
+router.get('/:tutorId/files/:filename', async (req, res, next) => {
+  try {
+    const { tutorId, filename } = req.params;
+
+    if (!isValidTutorId(tutorId)) {
+      return res.status(404).json({ error: 'Tutor not found' });
+    }
+
+    // Security: only allow .md files, block path traversal
+    if (!filename.endsWith('.md') || filename.includes('..') || filename.includes('/') || filename.includes('\\')) {
+      return res.status(400).json({ error: 'Invalid filename' });
+    }
+
+    const filePath = path.join(TUTORS_DIR, tutorId, filename);
+
+    // Verify the resolved path is still inside tutorDir (extra safety)
+    const tutorDir = path.join(TUTORS_DIR, tutorId);
+    if (!filePath.startsWith(tutorDir + path.sep) && filePath !== tutorDir) {
+      return res.status(400).json({ error: 'Invalid filename' });
+    }
+
+    let content;
+    try {
+      content = await fs.readFile(filePath, 'utf-8');
+    } catch {
+      return res.status(404).json({ error: 'File not found' });
+    }
+
+    res.json({ filename, content });
+  } catch (err) {
+    next(err);
+  }
+});
+
+export default router;

package/src/services/chat-service.js

@@ -0,0 +1,69 @@
+import {
+  getOrCreateSession,
+  updateSessionClaudeId,
+  createConversation,
+  getRecentMessages,
+  saveMessage,
+} from '@iprep/db';
+import { sessionManager, buildSystemPrompt, buildChatPrompt } from '@iprep/adapter-utils';
+import { sanitizeMessage } from '@iprep/shared';
+import { loadTutorConfig } from './tutor-service.js';
+import { logger } from '../utils/logger.js';
+
+/**
+ * Orchestrates sending a message: loads tutor config, spawns/reuses Claude,
+ * saves messages to DB, returns the response.
+ */
+export async function sendMessage(userId, tutorId, userMessage, conversationId = null) {
+  const message = sanitizeMessage(userMessage);
+
+  // 1. Load tutor personality from filesystem
+  const tutorConfig = await loadTutorConfig(tutorId);
+
+  // 2. Get or create DB session
+  const session = await getOrCreateSession(userId, tutorId);
+
+  // 3. Get or create conversation
+  let convId = conversationId;
+  if (!convId) {
+    const conv = await createConversation(
+      userId,
+      session.id,
+      tutorId,
+      message.slice(0, 60)  // Use first 60 chars as title
+    );
+    convId = conv.id;
+  }
+
+  // 4. Load recent history for context
+  const history = await getRecentMessages(convId, 10);
+
+  // 5. Build prompts
+  const systemPrompt = buildSystemPrompt(tutorConfig);
+  const fullPrompt = buildChatPrompt(systemPrompt, history, message);
+
+  // 6. Get or spawn Claude process
+  const spawner = await sessionManager.getOrCreate(userId, tutorId, session.claudeSessionId);
+
+  // 7. Save user message first
+  await saveMessage(convId, 'user', message);
+
+  // 8. Send to Claude and get response
+  logger.info(`Sending message to Claude for user=${userId} tutor=${tutorId}`);
+  const response = await spawner.sendPrompt(fullPrompt);
+
+  // 9. Save the assistant response
+  await saveMessage(convId, 'assistant', response);
+
+  // 10. Update session with Claude's session ID for continuity
+  if (spawner.sessionId && spawner.sessionId !== session.claudeSessionId) {
+    await updateSessionClaudeId(session.id, spawner.sessionId);
+  }
+
+  return {
+    response,
+    tutorId,
+    conversationId: convId,
+    sessionId: session.id,
+  };
+}

package/src/services/tutor-service.js

@@ -0,0 +1,53 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { DEFAULT_TUTORS, IprepPaths } from '@iprep/shared';
+import { upsertTutor, getAllTutors } from '@iprep/db';
+import { logger } from '../utils/logger.js';
+
+const TUTORS_DIR = IprepPaths.aitutors;
+
+async function readFile(filePath) {
+  try {
+    return await fs.readFile(filePath, 'utf-8');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Load a tutor's config from the filesystem (markdown files).
+ */
+export async function loadTutorConfig(tutorId) {
+  const dir = path.join(TUTORS_DIR, tutorId);
+  const [systemPrompt, skills, settingsRaw] = await Promise.all([
+    readFile(path.join(dir, 'system-prompt.md')),
+    readFile(path.join(dir, 'skills.md')),
+    readFile(path.join(dir, 'settings.md')),
+  ]);
+
+  const meta = DEFAULT_TUTORS.find((t) => t.id === tutorId) || { id: tutorId, name: tutorId };
+
+  return {
+    ...meta,
+    systemPrompt: systemPrompt || `You are ${meta.name}, a helpful AI tutor.`,
+    skills: skills || '',
+    settings: settingsRaw || '',
+  };
+}
+
+/**
+ * Seed the database with the default tutors if they don't exist yet.
+ */
+export async function seedTutors() {
+  for (const tutor of DEFAULT_TUTORS) {
+    await upsertTutor(tutor);
+    logger.info(`Tutor seeded: ${tutor.name}`);
+  }
+}
+
+/**
+ * List all tutors from the DB, enriched with filesystem config.
+ */
+export async function listTutors() {
+  return getAllTutors();
+}

package/src/utils/env.js

@@ -0,0 +1,10 @@
+import dotenv from 'dotenv';
+import os from 'os';
+import path from 'path';
+
+// Load .env from ~/.iprep/.env (user's home directory)
+dotenv.config({ path: path.join(os.homedir(), '.iprep', '.env') });
+
+export const PORT = parseInt(process.env.PORT || '3000', 10);
+export const NODE_ENV = process.env.NODE_ENV || 'development';
+export const LOG_LEVEL = process.env.LOG_LEVEL || 'info';

package/src/utils/logger.js

@@ -0,0 +1,3 @@
+import { logger as baseLogger } from '@iprep/shared';
+export const logger = baseLogger;
+export default logger;