commit 5d3390bbe9b8e8775c1cef6d6582931c322f94b8 · dunkirk.sh/thistle

+78 -1

src/index.ts

···

       23
       23
        
       	type TranscriptionUpdate,

     

       24
       24
        
       	WhisperServiceManager,

     

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

     

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

     

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

     

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

     

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

     

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

     
···

       518
       518
        
       			GET: async () => {

     

       519
       519
        
       				const isHealthy = await whisperService.checkHealth();

     

       520
       520
        
       				return Response.json({ available: isHealthy });

     

       521
       521
       +
       			},

     

       522
       522
       +
       		},

     

       523
       523
       +
       		"/api/transcriptions/:id": {

     

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

     

       525
       525
       +
       				try {

     

       526
       526
       +
       					const user = requireAuth(req);

     

       527
       527
       +
       					const transcriptionId = req.params.id;

     

       528
       528
       +
       

     

       529
       529
       +
       					// Verify ownership

     

       530
       530
       +
       					const transcription = db

     

       531
       531
       +
       						.query<

     

       532
       532
       +
       							{

     

       533
       533
       +
       								id: string;

     

       534
       534
       +
       								user_id: number;

     

       535
       535
       +
       								status: string;

     

       536
       536
       +
       								original_filename: string;

     

       537
       537
       +
       							},

     

       538
       538
       +
       							[string]

     

       539
       539
       +
       						>(

     

       540
       540
       +
       							"SELECT id, user_id, status, original_filename FROM transcriptions WHERE id = ?",

     

       541
       541
       +
       						)

     

       542
       542
       +
       						.get(transcriptionId);

     

       543
       543
       +
       

     

       544
       544
       +
       					if (!transcription || transcription.user_id !== user.id) {

     

       545
       545
       +
       						return Response.json(

     

       546
       546
       +
       							{ error: "Transcription not found" },

     

       547
       547
       +
       							{ status: 404 },

     

       548
       548
       +
       						);

     

       549
       549
       +
       					}

     

       550
       550
       +
       

     

       551
       551
       +
       					if (transcription.status !== "completed") {

     

       552
       552
       +
       						return Response.json(

     

       553
       553
       +
       							{ error: "Transcription not completed yet" },

     

       554
       554
       +
       							{ status: 400 },

     

       555
       555
       +
       						);

     

       556
       556
       +
       					}

     

       557
       557
       +
       

     

       558
       558
       +
       					// Get format from query parameter

     

       559
       559
       +
       					const url = new URL(req.url);

     

       560
       560
       +
       					const format = url.searchParams.get("format");

     

       561
       561
       +
       

     

       562
       562
       +
       					// Return WebVTT format if requested

     

       563
       563
       +
       					if (format === "vtt") {

     

       564
       564
       +
       						const vttContent = await getTranscriptVTT(transcriptionId);

     

       565
       565
       +
       

     

       566
       566
       +
       						if (!vttContent) {

     

       567
       567
       +
       							return Response.json(

     

       568
       568
       +
       								{ error: "VTT transcript not available" },

     

       569
       569
       +
       								{ status: 404 },

     

       570
       570
       +
       							);

     

       571
       571
       +
       						}

     

       572
       572
       +
       

     

       573
       573
       +
       						return new Response(vttContent, {

     

       574
       574
       +
       							headers: {

     

       575
       575
       +
       								"Content-Type": "text/vtt",

     

       576
       576
       +
       								"Content-Disposition": `attachment; filename="${transcription.original_filename}.vtt"`,

     

       577
       577
       +
       							},

     

       578
       578
       +
       						});

     

       579
       579
       +
       					}

     

       580
       580
       +
       

     

       581
       581
       +
       					// Default: return plain text transcript from file

     

       582
       582
       +
       					const transcript = await getTranscript(transcriptionId);

     

       583
       583
       +
       					if (!transcript) {

     

       584
       584
       +
       						return Response.json(

     

       585
       585
       +
       							{ error: "Transcript not available" },

     

       586
       586
       +
       							{ status: 404 },

     

       587
       587
       +
       						);

     

       588
       588
       +
       					}

     

       589
       589
       +
       

     

       590
       590
       +
       					return new Response(transcript, {

     

       591
       591
       +
       						headers: {

     

       592
       592
       +
       							"Content-Type": "text/plain",

     

       593
       593
       +
       						},

     

       594
       594
       +
       					});

     

       595
       595
       +
       				} catch (error) {

     

       596
       596
       +
       					return handleError(error);

     

       597
       597
       +
       				}

     

       521
       598
        
       			},

     

       522
       599
        
       		},

     

       523
       600
        
       		"/api/transcriptions": {

+17

src/lib/transcript-storage.test.ts

···

       2
       2
        
       import {

     

       3
       3
        
       	deleteTranscript,

     

       4
       4
        
       	getTranscript,

     

       5
       5
       +
       	getTranscriptVTT,

     

       5
       6
        
       	hasTranscript,

     

       6
       7
        
       	saveTranscript,

     

       8
       8
       +
       	saveTranscriptVTT,

     

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

     

       8
       10
        
       

     

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

     
···

       91
       93
        
       	}

     

       92
       94
        
       });

     

       93
       95
        
       

     

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

     

       97
       97
       +
       	const testId = "test-vtt-123";

     

       98
       98
       +
       	const vttContent = "WEBVTT\n\n00:00:00.000 --> 00:00:02.500\nHello world\n\n";

     

       99
       99
       +
       

     

       100
       100
       +
       	// Save VTT

     

       101
       101
       +
       	await saveTranscriptVTT(testId, vttContent);

     

       102
       102
       +
       

     

       103
       103
       +
       	// Read VTT

     

       104
       104
       +
       	const retrieved = await getTranscriptVTT(testId);

     

       105
       105
       +
       	expect(retrieved).toBe(vttContent);

     

       106
       106
       +
       

     

       107
       107
       +
       	// Clean up

     

       108
       108
       +
       	await deleteTranscript(testId);

     

       109
       109
       +
       });

     

       110
       110
       +

+27

src/lib/transcript-storage.ts

···

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

     

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

     

       75
       75
        
       }

     

       76
       76
       +
       

     

       77
       77
       +
       /**

     

       78
       78
       +
        * Write WebVTT transcript to file system

     

       79
       79
       +
        */

     

       80
       80
       +
       export async function saveTranscriptVTT(

     

       81
       81
       +
       	transcriptionId: string,

     

       82
       82
       +
       	vttContent: string,

     

       83
       83
       +
       ): Promise<void> {

     

       84
       84
       +
       	const safeId = validateTranscriptionId(transcriptionId);

     

       85
       85
       +
       	const filePath = `${TRANSCRIPTS_DIR}/${safeId}.vtt`;

     

       86
       86
       +
       	await Bun.write(filePath, vttContent);

     

       87
       87
       +
       }

     

       88
       88
       +
       

     

       89
       89
       +
       /**

     

       90
       90
       +
        * Read WebVTT transcript from file system

     

       91
       91
       +
        */

     

       92
       92
       +
       export async function getTranscriptVTT(

     

       93
       93
       +
       	transcriptionId: string,

     

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

     

       95
       95
       +
       	const safeId = validateTranscriptionId(transcriptionId);

     

       96
       96
       +
       	const filePath = `${TRANSCRIPTS_DIR}/${safeId}.vtt`;

     

       97
       97
       +
       	try {

     

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

     

       99
       99
       +
       	} catch {

     

       100
       100
       +
       		return null;

     

       101
       101
       +
       	}

     

       102
       102
       +
       }

+41 -1

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
       4
       +
       import { saveTranscript, saveTranscriptVTT } from "./transcript-storage";

     

       5
       5
        
       

     

       6
       6
        
       // Constants

     

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

     
···

       301
       301
        
       				await saveTranscript(transcriptionId, transcript);

     

       302
       302
        
       			}

     

       303
       303
        
       

     

       304
       304
       +
       			// Fetch and save VTT file from Murmur

     

       305
       305
       +
       			const whisperJobId = this.db

     

       306
       306
       +
       				.query<{ whisper_job_id: string }, [string]>(

     

       307
       307
       +
       					"SELECT whisper_job_id FROM transcriptions WHERE id = ?",

     

       308
       308
       +
       				)

     

       309
       309
       +
       				.get(transcriptionId)?.whisper_job_id;

     

       310
       310
       +
       

     

       311
       311
       +
       			if (whisperJobId) {

     

       312
       312
       +
       				try {

     

       313
       313
       +
       					const vttResponse = await fetch(

     

       314
       314
       +
       						`${this.serviceUrl}/transcribe/${whisperJobId}?format=vtt`,

     

       315
       315
       +
       					);

     

       316
       316
       +
       					if (vttResponse.ok) {

     

       317
       317
       +
       						const vttContent = await vttResponse.text();

     

       318
       318
       +
       						await saveTranscriptVTT(transcriptionId, vttContent);

     

       319
       319
       +
       					}

     

       320
       320
       +
       				} catch (error) {

     

       321
       321
       +
       					console.warn(

     

       322
       322
       +
       						`[Transcription] Failed to fetch VTT for ${transcriptionId}:`,

     

       323
       323
       +
       						error,

     

       324
       324
       +
       					);

     

       325
       325
       +
       				}

     

       326
       326
       +
       			}

     

       327
       327
       +
       

     

       304
       328
        
       			this.updateTranscription(transcriptionId, {

     

       305
       329
        
       				status: "completed",

     

       306
       330
        
       				progress: 100,

     
···

       518
       542
        
       				// Save transcript to file

     

       519
       543
        
       				if (transcript) {

     

       520
       544
        
       					await saveTranscript(transcriptionId, transcript);

     

       545
       545
       +
       				}

     

       546
       546
       +
       

     

       547
       547
       +
       				// Fetch and save VTT file

     

       548
       548
       +
       				try {

     

       549
       549
       +
       					const vttResponse = await fetch(

     

       550
       550
       +
       						`${this.serviceUrl}/transcribe/${whisperJob.id}?format=vtt`,

     

       551
       551
       +
       					);

     

       552
       552
       +
       					if (vttResponse.ok) {

     

       553
       553
       +
       						const vttContent = await vttResponse.text();

     

       554
       554
       +
       						await saveTranscriptVTT(transcriptionId, vttContent);

     

       555
       555
       +
       					}

     

       556
       556
       +
       				} catch (error) {

     

       557
       557
       +
       					console.warn(

     

       558
       558
       +
       						`[Sync] Failed to fetch VTT for ${transcriptionId}:`,

     

       559
       559
       +
       						error,

     

       560
       560
       +
       					);

     

       521
       561
        
       				}

     

       522
       562
        
       

     

       523
       563
        
       				this.updateTranscription(transcriptionId, {