@vue-skuilder/express 0.1.24 → 0.1.26

package/dist/peruser.js

@@ -0,0 +1,75 @@
+/**
+ * Per-user database provisioning daemon.
+ *
+ * Replaces CouchDB's built-in couch_peruser Erlang module, which has a
+ * process leak bug that causes unbounded memory growth:
+ * https://github.com/apache/couchdb/issues/5871
+ *
+ * Watches the _users database changes feed and ensures that every user
+ * has a corresponding userdb-{hex(username)} database with appropriate
+ * security settings. Replays from since=0 on every startup — this is
+ * cheap and removes the need to persist checkpoint state.
+ */
+import { getCouchDB } from './couchdb/index.js';
+import logger from './logger.js';
+function hexEncode(str) {
+    let returnStr = '';
+    for (let i = 0; i < str.length; i++) {
+        returnStr += ('000' + str.charCodeAt(i).toString(16)).slice(3);
+    }
+    return returnStr;
+}
+async function ensureUserDB(username) {
+    const dbName = `userdb-${hexEncode(username)}`;
+    const server = getCouchDB();
+    try {
+        await server.db.create(dbName);
+        logger.info(`peruser: created ${dbName}`);
+    }
+    catch (e) {
+        if (e &&
+            typeof e === 'object' &&
+            'statusCode' in e &&
+            e.statusCode === 412) {
+            // already exists — expected on replay
+        }
+        else {
+            logger.error(`peruser: error creating ${dbName}:`, e);
+            return;
+        }
+    }
+    const db = server.use(dbName);
+    try {
+        const security = {
+            admins: { names: [username], roles: [] },
+            members: { names: [username], roles: [] },
+        };
+        await db.insert(security, '_security');
+    }
+    catch (e) {
+        logger.error(`peruser: error setting security on ${dbName}:`, e);
+    }
+}
+export function startPerUserProvisioning() {
+    const usersDB = getCouchDB().use('_users');
+    usersDB.changesReader
+        .start({
+        includeDocs: false,
+        since: '0',
+    })
+        .on('change', (change) => {
+        if (!change.id.startsWith('org.couchdb.user:'))
+            return;
+        if (change.deleted)
+            return;
+        const username = change.id.replace('org.couchdb.user:', '');
+        ensureUserDB(username).catch((e) => {
+            logger.error(`peruser: unhandled error for ${username}:`, e);
+        });
+    })
+        .on('error', (err) => {
+        logger.error('peruser: _users changes feed error:', err);
+    });
+    logger.info('peruser: watching _users for new accounts');
+}
+//# sourceMappingURL=peruser.js.map

package/dist/peruser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"peruser.js","sourceRoot":"","sources":["../src/peruser.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.24",
+  "version": "0.1.26",
   "description": "an API",
   "main": "dist/index.js",
   "type": "module",
@@ -35,8 +35,8 @@
   "author": "Colin Kennedy",
   "license": "GPL-3.0-or-later",
   "dependencies": {
-    "@vue-skuilder/common": "^0.1.24",
-    "@vue-skuilder/db": "^0.1.24",
+    "@vue-skuilder/common": "^0.1.26",
+    "@vue-skuilder/db": "^0.1.26",
     "axios": "^1.12.0",
     "cookie-parser": "^1.4.7",
     "cors": "^2.8.5",
@@ -77,5 +77,5 @@
     "typescript-eslint": "^8.48.1",
     "vitest": "^4.0.15"
   },
-  "stableVersion": "0.1.24"
+  "stableVersion": "0.1.26"
 }

package/src/app-factory.ts

@@ -1,8 +1,8 @@
 import { initializeDataLayer } from '@vue-skuilder/db';
-import { 
-  ServerRequestType as RequestEnum, 
-  ServerRequest, 
-  prepareNote55, 
+import {
+  ServerRequestType as RequestEnum,
+  ServerRequest,
+  prepareNote55,
 } from '@vue-skuilder/common';
 import { CourseLookup } from '@vue-skuilder/db';
 import cookieParser from 'cookie-parser';
@@ -12,6 +12,7 @@ import express from 'express';
 import morgan from 'morgan';
 import Nano from 'nano';
 import PostProcess from './attachment-preprocessing/index.js';
+import { startPerUserProvisioning } from './peruser.js';
 import {
   ClassroomCreationQueue,
   ClassroomJoinQueue,
@@ -22,8 +23,16 @@ import {
   initCourseDBDesignDocInsert,
 } from './client-requests/course-requests.js';
 import { packCourse } from './client-requests/pack-requests.js';
-import { requestIsAuthenticated } from './couchdb/authentication.js';
-import { getCouchDB, initializeCouchDB, useOrCreateCourseDB, useOrCreateDB } from './couchdb/index.js';
+import {
+  getAuthenticatedUser,
+  requestIsAuthenticated,
+} from './couchdb/authentication.js';
+import {
+  getCouchDB,
+  initializeCouchDB,
+  useOrCreateCourseDB,
+  useOrCreateDB,
+} from './couchdb/index.js';
 import { classroomDbDesignDoc } from './design-docs.js';
 import logger from './logger.js';
 import logsRouter from './routes/logs.js';
@@ -45,7 +54,9 @@ export type AppConfig = ExpressServerConfig | EnvironmentConfig;
 /**
  * Type guard to determine if config is ExpressServerConfig (programmatic usage)
  */
-function isExpressServerConfig(config: AppConfig): config is ExpressServerConfig {
+function isExpressServerConfig(
+  config: AppConfig
+): config is ExpressServerConfig {
   return 'couchdb' in config && typeof config.couchdb === 'object';
 }
 
@@ -70,19 +81,20 @@ function convertToEnvConfig(config: ExpressServerConfig): EnvironmentConfig {
  */
 export function createExpressApp(config: AppConfig): express.Application {
   const app = express();
-  
+
   // Normalize config to environment format for internal usage
-  const envConfig = isExpressServerConfig(config) 
-    ? convertToEnvConfig(config) 
+  const envConfig = isExpressServerConfig(config)
+    ? convertToEnvConfig(config)
     : config;
 
   // Initialize CouchDB connection
   initializeCouchDB(envConfig);
 
   // Configure CORS - use config if available, otherwise defaults
-  const corsOptions = isExpressServerConfig(config) && config.cors 
-    ? config.cors 
-    : { credentials: true, origin: true };
+  const corsOptions =
+    isExpressServerConfig(config) && config.cors
+      ? config.cors
+      : { credentials: true, origin: true };
 
   // Middleware setup
   app.use(cookieParser());
@@ -130,7 +142,10 @@ export function createExpressApp(config: AppConfig): express.Application {
         logger.info(`Delete request made on course ${req.params.courseID}...`);
         const auth = await requestIsAuthenticated(req);
         if (auth) {
-          logger.info(`	Authenticated delete request made...`);          const dbResp = await getCouchDB().db.destroy(            `coursedb-${req.params.courseID}`          );
+          logger.info(`	Authenticated delete request made...`);
+          const dbResp = await getCouchDB().db.destroy(
+            `coursedb-${req.params.courseID}`
+          );
           if (!dbResp.ok) {
             res.json({ success: false, error: dbResp });
             return;
@@ -147,7 +162,9 @@ export function createExpressApp(config: AppConfig): express.Application {
         }
       } catch (error) {
         logger.error('Error deleting course:', error);
-        res.status(500).json({ success: false, error: 'Failed to delete course' });
+        res
+          .status(500)
+          .json({ success: false, error: 'Failed to delete course' });
       }
     })();
   });
@@ -156,13 +173,15 @@ export function createExpressApp(config: AppConfig): express.Application {
     req: VueClientRequest,
     res: express.Response
   ): Promise<void> {
-    const auth = await requestIsAuthenticated(req);
-    if (auth) {
+    // Use secure authentication that returns the actual session username
+    const authResult = await getAuthenticatedUser(req);
+    if (authResult.authenticated) {
+      const authenticatedUsername = authResult.username;
       const body = req.body;
       logger.info(
         `Authorized ${
           body.type ? body.type : '[unspecified request type]'
-        } request made...`
+        } request from ${authenticatedUsername}...`
       );
 
       if (body.type === RequestEnum.CREATE_CLASSROOM) {
@@ -176,8 +195,9 @@ export function createExpressApp(config: AppConfig): express.Application {
         body.response = await ClassroomJoinQueue.getResult(id);
         res.json(body.response);
       } else if (body.type === RequestEnum.LEAVE_CLASSROOM) {
+        // SECURITY FIX: Use authenticated username from session, not user-supplied req.body.user
         const id: number = ClassroomLeaveQueue.addRequest({
-          username: req.body.user,
+          username: authenticatedUsername,
           ...body.data,
         });
         body.response = await ClassroomLeaveQueue.getResult(id);
@@ -196,7 +216,8 @@ export function createExpressApp(config: AppConfig): express.Application {
           body.data.tags,
           body.data.uploads
         );
-        getCouchDB().use(`coursedb-${body.data.courseID}`)
+        getCouchDB()
+          .use(`coursedb-${body.data.courseID}`)
           .insert(payload as Nano.MaybeDocument)
           .then((r) => {
             logger.info(`\t\t\tCouchDB insert result: ${JSON.stringify(r)}`);
@@ -212,15 +233,16 @@ export function createExpressApp(config: AppConfig): express.Application {
             `\tPACK_COURSE request received in production mode, but this is not supported!`
           );
           res.status(400);
-          res.statusMessage = 'Packing courses is not supported in production mode.';
+          res.statusMessage =
+            'Packing courses is not supported in production mode.';
           res.send();
           return;
         }
-        
+
         body.response = await packCourse({
           courseId: body.courseId,
           outputPath: body.outputPath,
-          couchdbUrl: body.couchdbUrl
+          couchdbUrl: body.couchdbUrl,
         });
         res.json(body.response);
       }
@@ -243,7 +265,8 @@ export function createExpressApp(config: AppConfig): express.Application {
   app.get('/', (_req: Request, res: Response) => {
     let status = `Express service is running.\nVersion: ${envConfig.VERSION}\n`;
 
-    getCouchDB().session()
+    getCouchDB()
+      .session()
       .then((s) => {
         if (s.ok) {
           status += 'Couchdb is running.\n';
@@ -272,8 +295,6 @@ export async function initializeServices(config: AppConfig): Promise<void> {
     ? convertToEnvConfig(config)
     : config;
 
-
-
   await initializeDataLayer({
     type: 'couch',
     options: {
@@ -301,10 +322,21 @@ export async function initializeServices(config: AppConfig): Promise<void> {
     // media uploads
     void PostProcess();
 
+    // start the per-user database provisioning listener
+    // (replaces CouchDB's couch_peruser, which has a process leak)
+    // skip in studio mode — studio is a local single-user environment
+    if (envConfig.NODE_ENV !== 'studio') {
+      startPerUserProvisioning();
+    }
+
     initCourseDBDesignDocInsert().catch((error) => {
-      logger.error(`Error in initCourseDBDesignDocInsert background task: ${error}`);
+      logger.error(
+        `Error in initCourseDBDesignDocInsert background task: ${error}`
+      );
       if (error && typeof error === 'object') {
-        logger.error(`Full error details in initCourseDBDesignDocInsert: ${JSON.stringify(error)}`);
+        logger.error(
+          `Full error details in initCourseDBDesignDocInsert: ${JSON.stringify(error)}`
+        );
       }
     });
 
@@ -325,4 +357,4 @@ export async function initializeServices(config: AppConfig): Promise<void> {
   } catch (e) {
     logger.info(`Error: ${JSON.stringify(e)}`);
   }
-}
+}

package/src/attachment-preprocessing/normalize-local.ts

@@ -58,8 +58,28 @@ interface LoudnessData {
   target_offset: string;
 }
 
+// Fade durations in seconds — short enough to preserve consonant onsets,
+// long enough to smooth out the noise-floor cut-in/cut-out
+const FADE_IN_DURATION = 0.05; // 50ms
+const FADE_OUT_DURATION = 0.1; // 100ms
+
+function parseDuration(output: string): number {
+  const match = output.match(/Duration:\s*(\d+):(\d+):(\d+)\.(\d+)/);
+  if (!match) throw new Error('Could not parse duration from ffmpeg output');
+  const hours = parseInt(match[1]);
+  const minutes = parseInt(match[2]);
+  const seconds = parseInt(match[3]);
+  const frac = parseInt(match[4]) / Math.pow(10, match[4].length);
+  return hours * 3600 + minutes * 60 + seconds + frac;
+}
+
+async function getAudioDuration(filePath: string): Promise<number> {
+  const result = await exec(`"${FFMPEG}" -i "${filePath}" -f null -`);
+  return parseDuration(result.stderr);
+}
+
 /**
- * Normalizes a single wav file to mp3 with loudnorm
+ * Normalizes a single wav file to mp3 with loudnorm and fade in/out
  * Same spec as the attachment preprocessing: I=-16:TP=-1.5:LRA=11
  */
 async function normalizeFile(
@@ -73,6 +93,7 @@ async function normalizeFile(
 
   const PADDED = path.join(tmpDir, 'padded.wav');
   const PADDED_NORMALIZED = path.join(tmpDir, 'paddedNormalized.wav');
+  const TRIMMED = path.join(tmpDir, 'trimmed.wav');
   const NORMALIZED = path.join(tmpDir, 'normalized.mp3');
 
   try {
@@ -108,10 +129,23 @@ async function normalizeFile(
         `print_format=summary -ar 48k "${PADDED_NORMALIZED}"`
     );
 
-    // Cut off the padded part and convert to mp3
-    log(`[${baseName}] Cutting padding and encoding to mp3...`);
+    // Cut off the padded silence (keep as wav to avoid double lossy encoding)
+    log(`[${baseName}] Cutting padding...`);
+    await exec(
+      `"${FFMPEG}" -i "${PADDED_NORMALIZED}" -ss 00:00:10.000 "${TRIMMED}"`
+    );
+
+    // Apply fade in/out and encode to mp3
+    const duration = await getAudioDuration(TRIMMED);
+    const fadeOutStart = Math.max(0, duration - FADE_OUT_DURATION);
+    log(
+      `[${baseName}] Applying fades (in=${FADE_IN_DURATION}s, out=${FADE_OUT_DURATION}s @ ${fadeOutStart.toFixed(3)}s) and encoding to mp3...`
+    );
     await exec(
-      `"${FFMPEG}" -i "${PADDED_NORMALIZED}" -ss 00:00:10.000 -acodec libmp3lame -b:a 192k "${NORMALIZED}"`
+      `"${FFMPEG}" -i "${TRIMMED}" -af ` +
+        `"afade=t=in:st=0:d=${FADE_IN_DURATION}:curve=qsin,` +
+        `afade=t=out:st=${fadeOutStart}:d=${FADE_OUT_DURATION}:curve=qsin" ` +
+        `-acodec libmp3lame -b:a 192k "${NORMALIZED}"`
     );
 
     // Copy to output location

package/src/client-requests/pack-requests.ts

@@ -28,23 +28,25 @@ interface PackCourseResponse {
 function extractOriginalCourseId(decoratedId: string): string {
   // Remove unpacked_ prefix if present
   let courseId = decoratedId.replace(/^unpacked_/, '');
-  
+
   // Remove timestamp_random suffix pattern: _YYYYMMDD_abcdef
   courseId = courseId.replace(/_\d{8}_[a-z0-9]{6}$/, '');
-  
+
   // If no changes were made, return original (handles non-decorated IDs)
   return courseId === decoratedId ? decoratedId : courseId;
 }
 
-export async function packCourse(data: PackCourseData): Promise<PackCourseResponse> {
+export async function packCourse(
+  data: PackCourseData
+): Promise<PackCourseResponse> {
   logger.info(`Starting PACK_COURSE for ${data.courseId}...`);
-  
+
   try {
     const startTime = Date.now();
-    
+
     // Use CouchDBToStaticPacker directly from db package
     const { CouchDBToStaticPacker } = await import('@vue-skuilder/db');
-    
+
     // Create database connection URL - use provided couchdbUrl if available (studio mode)
     logger.info(`Pack request data: ${JSON.stringify(data, null, 2)}`);
     let courseDbUrl: string;
@@ -53,21 +55,23 @@ export async function packCourse(data: PackCourseData): Promise<PackCourseRespon
       logger.info(`Using provided CouchDB URL: "${courseDbUrl}"`);
     } else {
       // Fallback to ENV configuration for production mode
-      logger.info(`ENV values - Protocol: "${ENV.COUCHDB_PROTOCOL}", Admin: "${ENV.COUCHDB_ADMIN}", Password: "${ENV.COUCHDB_PASSWORD}", Server: "${ENV.COUCHDB_SERVER}"`);
+      logger.info(
+        `ENV values - Protocol: "${ENV.COUCHDB_PROTOCOL}", Admin: "${ENV.COUCHDB_ADMIN}", Password: PROBABLY_NOT_THE_PASSORD, Server: "${ENV.COUCHDB_SERVER}"`
+      );
       const dbUrl = `${ENV.COUCHDB_PROTOCOL}://${ENV.COUCHDB_ADMIN}:${ENV.COUCHDB_PASSWORD}@${ENV.COUCHDB_SERVER}`;
       const dbName = `coursedb-${data.courseId}`;
       courseDbUrl = `${dbUrl}/${dbName}`;
       logger.info(`Constructed dbUrl from ENV: "${courseDbUrl}"`);
     }
-    
+
     // Determine output path based on environment and provided path
     let outputPath: string;
-    
+
     if (data.outputPath) {
       // If output path is provided, check if it's absolute or relative
       const pathModule = await import('path');
       const path = pathModule.default || pathModule;
-      
+
       if (path.isAbsolute(data.outputPath)) {
         // Use absolute path as-is
         outputPath = data.outputPath;
@@ -78,39 +82,45 @@ export async function packCourse(data: PackCourseData): Promise<PackCourseRespon
       }
     } else {
       // No output path provided - use default
-      outputPath = ENV.NODE_ENV === 'studio' ?
-        '/tmp/skuilder-studio-output' :
-        process.cwd();
+      outputPath =
+        ENV.NODE_ENV === 'studio'
+          ? '/tmp/skuilder-studio-output'
+          : process.cwd();
     }
-    
-    logger.info(`Packing course ${data.courseId} from ${courseDbUrl} to ${outputPath}`);
-    
+
+    logger.info(
+      `Packing course ${data.courseId} from ${courseDbUrl} to ${outputPath}`
+    );
+
     // Clean up existing output directory for replace-in-place functionality
     const fsExtra = await import('fs-extra');
     const fs = fsExtra.default || fsExtra;
-    
+
     try {
       if (await fs.pathExists(outputPath)) {
         logger.info(`Removing existing directory: ${outputPath}`);
         await fs.remove(outputPath);
       }
     } catch (cleanupError) {
-      logger.warn(`Warning: Could not clean up existing directory ${outputPath}:`, cleanupError);
+      logger.warn(
+        `Warning: Could not clean up existing directory ${outputPath}:`,
+        cleanupError
+      );
       // Continue anyway - the write operation might still succeed
     }
-    
+
     // Initialize packer and perform pack operation with file writing
     const packer = new CouchDBToStaticPacker();
-    
+
     // For Express, we create a simple FileSystemAdapter using dynamic imports
     const createFsAdapter = async () => {
       const fsExtra = await import('fs-extra');
       const pathModule = await import('path');
-      
+
       // Access the default export for fs-extra
       const fs = fsExtra.default || fsExtra;
       const path = pathModule.default || pathModule;
-      
+
       return {
         async readFile(filePath: string): Promise<string> {
           return await fs.readFile(filePath, 'utf8');
@@ -131,13 +141,20 @@ export async function packCourse(data: PackCourseData): Promise<PackCourseRespon
           return {
             isDirectory: () => stats.isDirectory(),
             isFile: () => stats.isFile(),
-            size: stats.size
+            size: stats.size,
           };
         },
-        async writeFile(filePath: string, data: string | Buffer): Promise<void> {
+        async writeFile(
+          filePath: string,
+          data: string | Buffer
+        ): Promise<void> {
           await fs.writeFile(filePath, data as string | Uint8Array);
         },
-        async writeJson(filePath: string, data: unknown, options?: { spaces?: number }): Promise<void> {
+        async writeJson(
+          filePath: string,
+          data: unknown,
+          options?: { spaces?: number }
+        ): Promise<void> {
           await fs.writeJson(filePath, data, options);
         },
         async ensureDir(dirPath: string): Promise<void> {
@@ -151,25 +168,32 @@ export async function packCourse(data: PackCourseData): Promise<PackCourseRespon
         },
         isAbsolute(filePath: string): boolean {
           return path.isAbsolute(filePath);
-        }
+        },
       };
     };
-    
+
     const fsAdapter = await createFsAdapter();
-    
+
     // Use regular PouchDB for simple data reading
     logger.info(`Creating PouchDB instance with URL: ${courseDbUrl}`);
     // logger.info(`PouchDB constructor available: ${typeof PouchDB}`);
     // logger.info(`PouchDB adapters: ${JSON.stringify(Object.keys((PouchDB as any).adapters || {}))}`);
-    
+
     const courseDb = new PouchDB(courseDbUrl);
     // logger.info(`PouchDB instance created, adapter: ${(courseDb as any).adapter}`);
-    
+
     // Extract original courseId from decorated database name for manifest generation
     const originalCourseId = extractOriginalCourseId(data.courseId);
-    logger.info(`Using originalCourseId "${originalCourseId}" for manifest (extracted from "${data.courseId}")`);
-    
-    const packResult = await packer.packCourseToFiles(courseDb, originalCourseId, outputPath, fsAdapter);
+    logger.info(
+      `Using originalCourseId "${originalCourseId}" for manifest (extracted from "${data.courseId}")`
+    );
+
+    const packResult = await packer.packCourseToFiles(
+      courseDb,
+      originalCourseId,
+      outputPath,
+      fsAdapter
+    );
 
     // Create course-level skuilder.json for the packed course
     const pathModule = await import('path');
@@ -181,9 +205,12 @@ export async function packCourse(data: PackCourseData): Promise<PackCourseRespon
     try {
       const manifestContent = await fsAdapter.readFile(manifestPath);
       const manifest = JSON.parse(manifestContent);
-      courseTitle = manifest.courseName || manifest.courseConfig?.name || originalCourseId;
+      courseTitle =
+        manifest.courseName || manifest.courseConfig?.name || originalCourseId;
     } catch (error) {
-      logger.warn(`Could not read manifest for course title, using courseId: ${error}`);
+      logger.warn(
+        `Could not read manifest for course title, using courseId: ${error}`
+      );
     }
 
     // Create course-level skuilder.json
@@ -198,7 +225,9 @@ export async function packCourse(data: PackCourseData): Promise<PackCourseRespon
     };
 
     const skuilderJsonPath = path.join(outputPath, 'skuilder.json');
-    await fsAdapter.writeJson(skuilderJsonPath, courseSkuilderJson, { spaces: 2 });
+    await fsAdapter.writeJson(skuilderJsonPath, courseSkuilderJson, {
+      spaces: 2,
+    });
     logger.info(`Created skuilder.json for course: ${originalCourseId}`);
 
     const duration = Date.now() - startTime;
@@ -210,24 +239,27 @@ export async function packCourse(data: PackCourseData): Promise<PackCourseRespon
       attachmentsFound: packResult.attachmentsFound,
       filesWritten: packResult.filesWritten + 1, // +1 for skuilder.json
       totalFiles: packResult.filesWritten + 1, // Updated to reflect actual files written including skuilder.json
-      duration: duration
+      duration: duration,
     };
 
-    logger.info(`Pack completed in ${duration}ms. Attachments: ${response.attachmentsFound}, Files written: ${response.filesWritten}`);
+    logger.info(
+      `Pack completed in ${duration}ms. Attachments: ${response.attachmentsFound}, Files written: ${response.filesWritten}`
+    );
 
     return response;
   } catch (error) {
     logger.error('Pack operation failed:', error);
-    
+
     const response: PackCourseResponse = {
       status: Status.error,
       ok: false,
-      errorText: error instanceof Error ? error.message : 'Pack operation failed'
+      errorText:
+        error instanceof Error ? error.message : 'Pack operation failed',
     };
-    
+
     return response;
   }
 }
 
 // Export types for use in app.ts
-export type { PackCourseData, PackCourseResponse };
+export type { PackCourseData, PackCourseResponse };