commit 8a7efe9eb96c163f1baf7df9b146f9cf53e82867 · dunkirk.sh/thistle

.gitignore

···

       1
       1
        
       node_modules

     

       2
       2
        
       *.db

     

       3
       3
        
       uploads/

     

       4
       4
       +
       transcripts/

     

       4
       5
        
       .env

+92

CRUSH.md

···

       247
       247
        
       

     

       248
       248
        
       Use `bun test` to run tests.

     

       249
       249
        
       

     

       250
       250
       +
       ### Basic Test Structure

     

       251
       251
       +
       

     

       250
       252
        
       ```ts

     

       251
       253
        
       import { test, expect } from "bun:test";

     

       252
       254
        
       

     
···

       254
       256
        
         expect(1).toBe(1);

     

       255
       257
        
       });

     

       256
       258
        
       ```

     

       259
       259
       +
       

     

       260
       260
       +
       ### Test File Naming

     

       261
       261
       +
       

     

       262
       262
       +
       - Place tests next to the code they test: `foo.ts` → `foo.test.ts`

     

       263
       263
       +
       - This keeps tests close to implementation for easy maintenance

     

       264
       264
       +
       - Bun automatically discovers `*.test.ts` files

     

       265
       265
       +
       

     

       266
       266
       +
       ### Writing Good Tests

     

       267
       267
       +
       

     

       268
       268
       +
       **Test security-critical code:**

     

       269
       269
       +
       - File path operations (directory traversal, injection)

     

       270
       270
       +
       - User input validation

     

       271
       271
       +
       - Authentication/authorization

     

       272
       272
       +
       - API endpoint security

     

       273
       273
       +
       

     

       274
       274
       +
       **Test edge cases:**

     

       275
       275
       +
       - Empty strings, null, undefined

     

       276
       276
       +
       - Very large inputs (size limits)

     

       277
       277
       +
       - Invalid formats

     

       278
       278
       +
       - Boundary conditions

     

       279
       279
       +
       

     

       280
       280
       +
       **Test async operations:**

     

       281
       281
       +
       ```ts

     

       282
       282
       +
       test("async function", async () => {

     

       283
       283
       +
         const result = await someAsyncFunction();

     

       284
       284
       +
         expect(result).toBe("expected value");

     

       285
       285
       +
       });

     

       286
       286
       +
       ```

     

       287
       287
       +
       

     

       288
       288
       +
       **Test error conditions:**

     

       289
       289
       +
       ```ts

     

       290
       290
       +
       test("rejects invalid input", async () => {

     

       291
       291
       +
         await expect(dangerousFunction("../../../etc/passwd")).rejects.toThrow();

     

       292
       292
       +
         await expect(dangerousFunction("invalid")).rejects.toThrow("Invalid format");

     

       293
       293
       +
       });

     

       294
       294
       +
       ```

     

       295
       295
       +
       

     

       296
       296
       +
       **Example: Security-focused tests**

     

       297
       297
       +
       ```ts

     

       298
       298
       +
       test("prevents directory traversal", async () => {

     

       299
       299
       +
         const maliciousIds = [

     

       300
       300
       +
           "../../../etc/passwd",

     

       301
       301
       +
           "../../secret.txt",

     

       302
       302
       +
           "test/../../../config",

     

       303
       303
       +
         ];

     

       304
       304
       +
       

     

       305
       305
       +
         for (const id of maliciousIds) {

     

       306
       306
       +
           await expect(loadFile(id)).rejects.toThrow();

     

       307
       307
       +
         }

     

       308
       308
       +
       });

     

       309
       309
       +
       

     

       310
       310
       +
       test("validates input format", async () => {

     

       311
       311
       +
         const invalidInputs = [

     

       312
       312
       +
           "test; rm -rf /",

     

       313
       313
       +
           "test`whoami`",

     

       314
       314
       +
           "test\x00null",

     

       315
       315
       +
         ];

     

       316
       316
       +
       

     

       317
       317
       +
         for (const input of invalidInputs) {

     

       318
       318
       +
           await expect(processInput(input)).rejects.toThrow("Invalid format");

     

       319
       319
       +
         }

     

       320
       320
       +
       });

     

       321
       321
       +
       ```

     

       322
       322
       +
       

     

       323
       323
       +
       ### Running Tests

     

       324
       324
       +
       

     

       325
       325
       +
       ```bash

     

       326
       326
       +
       # Run all tests

     

       327
       327
       +
       bun test

     

       328
       328
       +
       

     

       329
       329
       +
       # Run specific test file

     

       330
       330
       +
       bun test src/lib/auth.test.ts

     

       331
       331
       +
       

     

       332
       332
       +
       # Watch mode (re-run on changes)

     

       333
       333
       +
       bun test --watch

     

       334
       334
       +
       ```

     

       335
       335
       +
       

     

       336
       336
       +
       ### What to Test

     

       337
       337
       +
       

     

       338
       338
       +
       **Always test:**

     

       339
       339
       +
       - Security-critical functions (file I/O, user input)

     

       340
       340
       +
       - Complex business logic

     

       341
       341
       +
       - Edge cases and error handling

     

       342
       342
       +
       - Public API functions

     

       343
       343
       +
       

     

       344
       344
       +
       **Don't need to test:**

     

       345
       345
       +
       - Simple getters/setters

     

       346
       346
       +
       - Framework/library code

     

       347
       347
       +
       - UI components (unless complex logic)

     

       348
       348
       +
       - One-line utility functions

     

       257
       349
        
       

     

       258
       350
        
       ## TypeScript Configuration

     

       259
       351

src/db/schema.ts

···

       68
       68
        
             CREATE INDEX IF NOT EXISTS idx_transcriptions_whisper_job_id ON transcriptions(whisper_job_id);

     

       69
       69
        
           `,

     

       70
       70
        
       	},

     

       71
       71
       +
       	{

     

       72
       72
       +
       		version: 4,

     

       73
       73
       +
       		name: "Remove transcript column from transcriptions",

     

       74
       74
       +
       		sql: `

     

       75
       75
       +
             -- SQLite 3.35.0+ supports DROP COLUMN

     

       76
       76
       +
             ALTER TABLE transcriptions DROP COLUMN transcript;

     

       77
       77
       +
           `,

     

       78
       78
       +
       	},

     

       71
       79
        
       ];

     

       72
       80
        
       

     

       73
       81
        
       function getCurrentVersion(): number {

+34 -20

src/index.ts

···

       23
       23
        
       	type TranscriptionUpdate,

     

       24
       24
        
       	WhisperServiceManager,

     

       25
       25
        
       } from "./lib/transcription";

     

       26
       26
       +
       import { getTranscript } from "./lib/transcript-storage";

     

       26
       27
        
       import indexHTML from "./pages/index.html";

     

       27
       28
        
       import settingsHTML from "./pages/settings.html";

     

       28
       29
        
       import transcribeHTML from "./pages/transcribe.html";

     
···

       31
       32
        
       const WHISPER_SERVICE_URL =

     

       32
       33
        
       	process.env.WHISPER_SERVICE_URL || "http://localhost:8000";

     

       33
       34
        
       

     

       34
       34
       -
       // Create uploads directory if it doesn't exist

     

       35
       35
       +
       // Create uploads and transcripts directories if they don't exist

     

       35
       36
        
       await Bun.write("./uploads/.gitkeep", "");

     

       37
       37
       +
       await Bun.write("./transcripts/.gitkeep", "");

     

       36
       38
        
       

     

       37
       39
        
       // Initialize transcription system

     

       38
       40
        
       console.log(

     
···

       378
       380
        
       			},

     

       379
       381
        
       		},

     

       380
       382
        
       		"/api/transcriptions/:id/stream": {

     

       381
       381
       -
       			GET: (req) => {

     

       383
       383
       +
       			GET: async (req) => {

     

       382
       384
        
       				const sessionId = getSessionFromRequest(req);

     

       383
       385
        
       				if (!sessionId) {

     

       384
       386
        
       					return Response.json({ error: "Not authenticated" }, { status: 401 });

     
···

       402
       404
        
       				}

     

       403
       405
        
       				// Event-driven SSE stream with reconnection support

     

       404
       406
        
       				const stream = new ReadableStream({

     

       405
       405
       -
       					start(controller) {

     

       407
       407
       +
       					async start(controller) {

     

       406
       408
        
       						const encoder = new TextEncoder();

     

       407
       409
        
       						let isClosed = false;

     

       408
       410
        
       						let lastEventId = Math.floor(Date.now() / 1000);

     
···

       431
       433
        
       								isClosed = true;

     

       432
       434
        
       							}

     

       433
       435
        
       						};

     

       434
       434
       -
       						// Send initial state from DB

     

       436
       436
       +
       						// Send initial state from DB and file

     

       435
       437
        
       						const current = db

     

       436
       438
        
       							.query<

     

       437
       439
        
       								{

     

       438
       440
        
       									status: string;

     

       439
       441
        
       									progress: number;

     

       440
       440
       -
       									transcript: string | null;

     

       441
       442
        
       								},

     

       442
       443
        
       								[string]

     

       443
       444
        
       							>(

     

       444
       444
       -
       								"SELECT status, progress, transcript FROM transcriptions WHERE id = ?",

     

       445
       445
       +
       								"SELECT status, progress FROM transcriptions WHERE id = ?",

     

       445
       446
        
       							)

     

       446
       447
        
       							.get(transcriptionId);

     

       447
       448
        
       						if (current) {

     

       449
       449
       +
       							// Load transcript from file if completed

     

       450
       450
       +
       							let transcript: string | undefined;

     

       451
       451
       +
       							if (current.status === "completed") {

     

       452
       452
       +
       								transcript = (await getTranscript(transcriptionId)) || undefined;

     

       453
       453
       +
       							}

     

       448
       454
        
       							sendEvent({

     

       449
       455
        
       								status: current.status as TranscriptionUpdate["status"],

     

       450
       456
        
       								progress: current.progress,

     

       451
       451
       -
       								transcript: current.transcript || undefined,

     

       457
       457
       +
       								transcript,

     

       452
       458
        
       							});

     

       453
       459
        
       						}

     

       454
       460
        
       						// If already complete, close immediately

     
···

       515
       521
        
       			},

     

       516
       522
        
       		},

     

       517
       523
        
       		"/api/transcriptions": {

     

       518
       518
       -
       			GET: (req) => {

     

       524
       524
       +
       			GET: async (req) => {

     

       519
       525
        
       				try {

     

       520
       526
        
       					const user = requireAuth(req);

     

       521
       527
        
       

     
···

       527
       533
        
       								original_filename: string;

     

       528
       534
        
       								status: string;

     

       529
       535
        
       								progress: number;

     

       530
       530
       -
       								transcript: string | null;

     

       531
       536
        
       								created_at: number;

     

       532
       537
        
       							},

     

       533
       538
        
       							[number]

     

       534
       539
        
       						>(

     

       535
       535
       -
       							"SELECT id, filename, original_filename, status, progress, transcript, created_at FROM transcriptions WHERE user_id = ? ORDER BY created_at DESC",

     

       540
       540
       +
       							"SELECT id, filename, original_filename, status, progress, created_at FROM transcriptions WHERE user_id = ? ORDER BY created_at DESC",

     

       536
       541
        
       						)

     

       537
       542
        
       						.all(user.id);

     

       538
       543
        
       

     

       539
       539
       -
       					return Response.json({

     

       540
       540
       -
       						jobs: transcriptions.map((t) => ({

     

       541
       541
       -
       							id: t.id,

     

       542
       542
       -
       							filename: t.original_filename,

     

       543
       543
       -
       							status: t.status,

     

       544
       544
       -
       							progress: t.progress,

     

       545
       545
       -
       							transcript: t.transcript,

     

       546
       546
       -
       							created_at: t.created_at,

     

       547
       547
       -
       						})),

     

       548
       548
       -
       					});

     

       544
       544
       +
       					// Load transcripts from files for completed jobs

     

       545
       545
       +
       					const jobs = await Promise.all(

     

       546
       546
       +
       						transcriptions.map(async (t) => {

     

       547
       547
       +
       							let transcript: string | null = null;

     

       548
       548
       +
       							if (t.status === "completed") {

     

       549
       549
       +
       								transcript = await getTranscript(t.id);

     

       550
       550
       +
       							}

     

       551
       551
       +
       							return {

     

       552
       552
       +
       								id: t.id,

     

       553
       553
       +
       								filename: t.original_filename,

     

       554
       554
       +
       								status: t.status,

     

       555
       555
       +
       								progress: t.progress,

     

       556
       556
       +
       								transcript,

     

       557
       557
       +
       								created_at: t.created_at,

     

       558
       558
       +
       							};

     

       559
       559
       +
       						}),

     

       560
       560
       +
       					);

     

       561
       561
       +
       

     

       562
       562
       +
       					return Response.json({ jobs });

     

       549
       563
        
       				} catch (error) {

     

       550
       564
        
       					return handleError(error);

     

       551
       565
        
       				}

+1 -1

src/lib/auth.ts

···

       112
       112
        
       	password: string,

     

       113
       113
        
       ): Promise<User | null> {

     

       114
       114
        
       	const result = db

     

       115
       115
       -
       		.query<{ id: number; email: string; name: string | null; password_hash: string; created_at: number }, [string]>(

     

       115
       115
       +
       		.query<{ id: number; email: string; name: string | null; avatar: string; password_hash: string; created_at: number }, [string]>(

     

       116
       116
        
       			"SELECT id, email, name, avatar, password_hash, created_at FROM users WHERE email = ?",

     

       117
       117
        
       		)

     

       118
       118
        
       		.get(email);

+93

src/lib/transcript-storage.test.ts

···

       1
       1
       +
       import { expect, test } from "bun:test";

     

       2
       2
       +
       import {

     

       3
       3
       +
       	deleteTranscript,

     

       4
       4
       +
       	getTranscript,

     

       5
       5
       +
       	hasTranscript,

     

       6
       6
       +
       	saveTranscript,

     

       7
       7
       +
       } from "./transcript-storage";

     

       8
       8
       +
       

     

       9
       9
       +
       test("transcript storage", async () => {

     

       10
       10
       +
       	const testId = "test-transcript-123";

     

       11
       11
       +
       	const testContent = "This is a test transcript with some content.";

     

       12
       12
       +
       

     

       13
       13
       +
       	// Should not exist initially

     

       14
       14
       +
       	expect(await hasTranscript(testId)).toBe(false);

     

       15
       15
       +
       	expect(await getTranscript(testId)).toBe(null);

     

       16
       16
       +
       

     

       17
       17
       +
       	// Save transcript

     

       18
       18
       +
       	await saveTranscript(testId, testContent);

     

       19
       19
       +
       

     

       20
       20
       +
       	// Should exist now

     

       21
       21
       +
       	expect(await hasTranscript(testId)).toBe(true);

     

       22
       22
       +
       	expect(await getTranscript(testId)).toBe(testContent);

     

       23
       23
       +
       

     

       24
       24
       +
       	// Delete transcript

     

       25
       25
       +
       	await deleteTranscript(testId);

     

       26
       26
       +
       

     

       27
       27
       +
       	// Should not exist anymore

     

       28
       28
       +
       	expect(await hasTranscript(testId)).toBe(false);

     

       29
       29
       +
       	expect(await getTranscript(testId)).toBe(null);

     

       30
       30
       +
       });

     

       31
       31
       +
       

     

       32
       32
       +
       test("transcript storage handles large content", async () => {

     

       33
       33
       +
       	const testId = "test-large-transcript";

     

       34
       34
       +
       	// Create a 1MB transcript

     

       35
       35
       +
       	const largeContent = "A".repeat(1024 * 1024);

     

       36
       36
       +
       

     

       37
       37
       +
       	await saveTranscript(testId, largeContent);

     

       38
       38
       +
       	const retrieved = await getTranscript(testId);

     

       39
       39
       +
       

     

       40
       40
       +
       	expect(retrieved).toBe(largeContent);

     

       41
       41
       +
       	expect(retrieved?.length).toBe(1024 * 1024);

     

       42
       42
       +
       

     

       43
       43
       +
       	await deleteTranscript(testId);

     

       44
       44
       +
       });

     

       45
       45
       +
       

     

       46
       46
       +
       test("transcript storage prevents directory traversal", async () => {

     

       47
       47
       +
       	const maliciousIds = [

     

       48
       48
       +
       		"../../../etc/passwd",

     

       49
       49
       +
       		"../../secret.txt",

     

       50
       50
       +
       		"../config",

     

       51
       51
       +
       		"test/../../../etc/passwd",

     

       52
       52
       +
       		"test/../../passwd",

     

       53
       53
       +
       	];

     

       54
       54
       +
       

     

       55
       55
       +
       	for (const id of maliciousIds) {

     

       56
       56
       +
       		await expect(saveTranscript(id, "malicious")).rejects.toThrow();

     

       57
       57
       +
       		await expect(getTranscript(id)).rejects.toThrow();

     

       58
       58
       +
       		await expect(deleteTranscript(id)).rejects.toThrow();

     

       59
       59
       +
       		await expect(hasTranscript(id)).rejects.toThrow();

     

       60
       60
       +
       	}

     

       61
       61
       +
       });

     

       62
       62
       +
       

     

       63
       63
       +
       test("transcript storage validates ID format", async () => {

     

       64
       64
       +
       	const invalidIds = [

     

       65
       65
       +
       		"test; rm -rf /",

     

       66
       66
       +
       		"test`whoami`",

     

       67
       67
       +
       		"test\x00null",

     

       68
       68
       +
       		"test\nls",

     

       69
       69
       +
       		"test&&ls",

     

       70
       70
       +
       	];

     

       71
       71
       +
       

     

       72
       72
       +
       	for (const id of invalidIds) {

     

       73
       73
       +
       		await expect(saveTranscript(id, "test")).rejects.toThrow(

     

       74
       74
       +
       			"Invalid transcription ID",

     

       75
       75
       +
       		);

     

       76
       76
       +
       	}

     

       77
       77
       +
       });

     

       78
       78
       +
       

     

       79
       79
       +
       test("transcript storage accepts valid UUIDs", async () => {

     

       80
       80
       +
       	const validIds = [

     

       81
       81
       +
       		"550e8400-e29b-41d4-a716-446655440000",

     

       82
       82
       +
       		"6ba7b810-9dad-11d1-80b4-00c04fd430c8",

     

       83
       83
       +
       		"test-abc-123",

     

       84
       84
       +
       		"abc123",

     

       85
       85
       +
       	];

     

       86
       86
       +
       

     

       87
       87
       +
       	for (const id of validIds) {

     

       88
       88
       +
       		await saveTranscript(id, "test");

     

       89
       89
       +
       		expect(await getTranscript(id)).toBe("test");

     

       90
       90
       +
       		await deleteTranscript(id);

     

       91
       91
       +
       	}

     

       92
       92
       +
       });

     

       93
       93
       +

+75

src/lib/transcript-storage.ts

···

       1
       1
       +
       // File-based transcript storage to avoid SQLite size limits

     

       2
       2
       +
       

     

       3
       3
       +
       import { unlinkSync } from "node:fs";

     

       4
       4
       +
       import { basename } from "node:path";

     

       5
       5
       +
       

     

       6
       6
       +
       const TRANSCRIPTS_DIR = "./transcripts";

     

       7
       7
       +
       

     

       8
       8
       +
       /**

     

       9
       9
       +
        * Validate and sanitize transcription ID to prevent directory traversal

     

       10
       10
       +
        */

     

       11
       11
       +
       function validateTranscriptionId(id: string): string {

     

       12
       12
       +
       	// Reject empty strings

     

       13
       13
       +
       	if (!id || id.length === 0) {

     

       14
       14
       +
       		throw new Error("Invalid transcription ID: empty");

     

       15
       15
       +
       	}

     

       16
       16
       +
       	// Only allow safe characters (alphanumeric, hyphens, underscores)

     

       17
       17
       +
       	if (!/^[a-zA-Z0-9_-]+$/.test(id)) {

     

       18
       18
       +
       		throw new Error("Invalid transcription ID format");

     

       19
       19
       +
       	}

     

       20
       20
       +
       	// Ensure no path traversal by using only the basename

     

       21
       21
       +
       	const safeName = basename(id);

     

       22
       22
       +
       	if (safeName !== id) {

     

       23
       23
       +
       		throw new Error("Invalid transcription ID: path traversal detected");

     

       24
       24
       +
       	}

     

       25
       25
       +
       	return safeName;

     

       26
       26
       +
       }

     

       27
       27
       +
       

     

       28
       28
       +
       /**

     

       29
       29
       +
        * Write transcript to file system

     

       30
       30
       +
        */

     

       31
       31
       +
       export async function saveTranscript(

     

       32
       32
       +
       	transcriptionId: string,

     

       33
       33
       +
       	transcript: string,

     

       34
       34
       +
       ): Promise<void> {

     

       35
       35
       +
       	const safeId = validateTranscriptionId(transcriptionId);

     

       36
       36
       +
       	const filePath = `${TRANSCRIPTS_DIR}/${safeId}.txt`;

     

       37
       37
       +
       	await Bun.write(filePath, transcript);

     

       38
       38
       +
       }

     

       39
       39
       +
       

     

       40
       40
       +
       /**

     

       41
       41
       +
        * Read transcript from file system

     

       42
       42
       +
        */

     

       43
       43
       +
       export async function getTranscript(

     

       44
       44
       +
       	transcriptionId: string,

     

       45
       45
       +
       ): Promise<string | null> {

     

       46
       46
       +
       	const safeId = validateTranscriptionId(transcriptionId);

     

       47
       47
       +
       	const filePath = `${TRANSCRIPTS_DIR}/${safeId}.txt`;

     

       48
       48
       +
       	try {

     

       49
       49
       +
       		return await Bun.file(filePath).text();

     

       50
       50
       +
       	} catch {

     

       51
       51
       +
       		return null;

     

       52
       52
       +
       	}

     

       53
       53
       +
       }

     

       54
       54
       +
       

     

       55
       55
       +
       /**

     

       56
       56
       +
        * Delete transcript file

     

       57
       57
       +
        */

     

       58
       58
       +
       export async function deleteTranscript(transcriptionId: string): Promise<void> {

     

       59
       59
       +
       	const safeId = validateTranscriptionId(transcriptionId);

     

       60
       60
       +
       	const filePath = `${TRANSCRIPTS_DIR}/${safeId}.txt`;

     

       61
       61
       +
       	try {

     

       62
       62
       +
       		unlinkSync(filePath);

     

       63
       63
       +
       	} catch {

     

       64
       64
       +
       		// File doesn't exist or already deleted

     

       65
       65
       +
       	}

     

       66
       66
       +
       }

     

       67
       67
       +
       

     

       68
       68
       +
       /**

     

       69
       69
       +
        * Check if transcript exists

     

       70
       70
       +
        */

     

       71
       71
       +
       export async function hasTranscript(transcriptionId: string): Promise<boolean> {

     

       72
       72
       +
       	const safeId = validateTranscriptionId(transcriptionId);

     

       73
       73
       +
       	const filePath = `${TRANSCRIPTS_DIR}/${safeId}.txt`;

     

       74
       74
       +
       	return await Bun.file(filePath).exists();

     

       75
       75
       +
       }

+19 -16

src/lib/transcription.ts

···

       1
       1
        
       import type { Database } from "bun:sqlite";

     

       2
       2
        
       import { createEventSource } from "eventsource-client";

     

       3
       3
        
       import { ErrorCode } from "./errors";

     

       4
       4
       +
       import { saveTranscript } from "./transcript-storage";

     

       4
       5
        
       

     

       5
       6
        
       // Constants

     

       6
       7
        
       export const MAX_FILE_SIZE = 100 * 1024 * 1024; // 100MB

     

       7
       7
       -
       export const MAX_TRANSCRIPT_LENGTH = 50000;

     

       8
       8
        
       export const MAX_ERROR_LENGTH = 255;

     

       9
       9
        
       

     

       10
       10
        
       // Types

     
···

       243
       243
        
       		this.activeStreams.set(transcriptionId, es);

     

       244
       244
        
       	}

     

       245
       245
        
       

     

       246
       246
       -
       	private handleWhisperUpdate(

     

       246
       246
       +
       	private async handleWhisperUpdate(

     

       247
       247
        
       		transcriptionId: string,

     

       248
       248
        
       		filePath: string,

     

       249
       249
        
       		update: WhisperJob,

     
···

       277
       277
        
       			let transcript = update.transcript ?? "";

     

       278
       278
        
       			transcript = transcript.replace(/<\|[^|]+\|>/g, "").trim();

     

       279
       279
        
       

     

       280
       280
       +
       			// Save transcript to file (overwrites on each update)

     

       281
       281
       +
       			if (transcript) {

     

       282
       282
       +
       				await saveTranscript(transcriptionId, transcript);

     

       283
       283
       +
       			}

     

       284
       284
       +
       

     

       280
       285
        
       			this.updateTranscription(transcriptionId, {

     

       281
       286
        
       				status,

     

       282
       287
        
       				progress,

     

       283
       283
       -
       				transcript,

     

       284
       288
        
       			});

     

       285
       289
        
       

     

       286
       290
        
       			this.events.emit(transcriptionId, {

     
···

       290
       294
        
       			});

     

       291
       295
        
       		} else if (update.status === "completed") {

     

       292
       296
        
       			// Final transcript should already have tokens stripped by Murmur

     

       293
       293
       -
       			const transcript = (update.transcript ?? "").substring(

     

       294
       294
       -
       				0,

     

       295
       295
       -
       				MAX_TRANSCRIPT_LENGTH,

     

       296
       296
       -
       			);

     

       297
       297
       +
       			const transcript = update.transcript ?? "";

     

       298
       298
       +
       

     

       299
       299
       +
       			// Save final transcript to file

     

       300
       300
       +
       			if (transcript) {

     

       301
       301
       +
       				await saveTranscript(transcriptionId, transcript);

     

       302
       302
       +
       			}

     

       297
       303
        
       

     

       298
       304
        
       			this.updateTranscription(transcriptionId, {

     

       299
       305
        
       				status: "completed",

     

       300
       306
        
       				progress: 100,

     

       301
       301
       -
       				transcript,

     

       302
       307
        
       			});

     

       303
       308
        
       

     

       304
       309
        
       			this.events.emit(transcriptionId, {

     
···

       354
       359
        
       		data: {

     

       355
       360
        
       			status?: TranscriptionStatus;

     

       356
       361
        
       			progress?: number;

     

       357
       357
       -
       			transcript?: string;

     

       358
       362
        
       			error_message?: string;

     

       359
       363
        
       		},

     

       360
       364
        
       	) {

     
···

       368
       372
        
       		if (data.progress !== undefined) {

     

       369
       373
        
       			updates.push("progress = ?");

     

       370
       374
        
       			values.push(data.progress);

     

       371
       371
       -
       		}

     

       372
       372
       -
       		if (data.transcript !== undefined) {

     

       373
       373
       -
       			updates.push("transcript = ?");

     

       374
       374
       -
       			values.push(data.transcript);

     

       375
       375
        
       		}

     

       376
       376
        
       		if (data.error_message !== undefined) {

     

       377
       377
        
       			updates.push("error_message = ?");

     
···

       513
       513
        
       			if (!details) return;

     

       514
       514
        
       

     

       515
       515
        
       			if (details.status === "completed") {

     

       516
       516
       -
       				const transcript =

     

       517
       517
       -
       					details.transcript?.substring(0, MAX_TRANSCRIPT_LENGTH) ?? "";

     

       516
       516
       +
       				const transcript = details.transcript ?? "";

     

       517
       517
       +
       

     

       518
       518
       +
       				// Save transcript to file

     

       519
       519
       +
       				if (transcript) {

     

       520
       520
       +
       					await saveTranscript(transcriptionId, transcript);

     

       521
       521
       +
       				}

     

       518
       522
        
       

     

       519
       523
        
       				this.updateTranscription(transcriptionId, {

     

       520
       524
        
       					status: "completed",

     

       521
       525
        
       					progress: 100,

     

       522
       522
       -
       					transcript,

     

       523
       526
        
       				});

     

       524
       527
        
       

     

       525
       528
        
       				this.events.emit(transcriptionId, {