···

       
4
       
 
       
interface TranscriptionJob {

     

       
5
       
 
       
	id: string;

     

       
6
       
 
       
	filename: string;

     

       
7
       
-
       
	status: "uploading" | "processing" | "completed" | "failed";

     

       
8
       
 
       
	progress: number;

     

       
9
       
 
       
	transcript?: string;

     

       
10
       
 
       
	created_at: number;

     
···

       
113
       
 
       
    }

     

       
114
       
 
       


     

       
115
       
 
       
    .status-processing {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
116
       
 
       
      background: color-mix(in srgb, var(--accent) 10%, transparent);

     

       
117
       
 
       
      color: var(--accent);

     

       
118
       
 
       
    }

     
···

       
133
       
 
       
      background: var(--secondary);

     

       
134
       
 
       
      border-radius: 2px;

     

       
135
       
 
       
      margin-bottom: 1rem;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
136
       
 
       
    }

     

       
137
       
 
       


     

       
138
       
 
       
    .progress-fill {

     
···

       
142
       
 
       
      transition: width 0.3s;

     

       
143
       
 
       
    }

     

       
144
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
145
       
 
       
    .job-transcript {

     

       
146
       
 
       
      background: color-mix(in srgb, var(--primary) 5%, transparent);

     

       
147
       
 
       
      border-radius: 6px;

     
···

       
164
       
 
       


     

       
165
       
 
       
	private eventSources: Map<string, EventSource> = new Map();

     

       
166
       
 
       
	private handleAuthChange = async () => {

     

       
0
       
 
       

     

       
167
       
 
       
		await this.loadJobs();

     

       
168
       
 
       
		this.connectToJobStreams();

     

       
169
       
 
       
	};

     

       
170
       
 
       


     

       
171
       
 
       
	override async connectedCallback() {

     

       
172
       
 
       
		super.connectedCallback();

     

       
0
       
 
       

     

       
173
       
 
       
		await this.loadJobs();

     

       
174
       
 
       
		this.connectToJobStreams();

     

       
175
       
 
       


     
···

       
190
       
 
       
	private connectToJobStreams() {

     

       
191
       
 
       
		// Connect to SSE streams for active jobs

     

       
192
       
 
       
		for (const job of this.jobs) {

     

       
193
       
-
       
			if (job.status === "processing" || job.status === "uploading") {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
194
       
 
       
				this.connectToJobStream(job.id);

     

       
195
       
 
       
			}

     

       
196
       
 
       
		}

     
···

       
203
       
 
       


     

       
204
       
 
       
		const eventSource = new EventSource(`/api/transcriptions/${jobId}/stream`);

     

       
205
       
 
       


     

       
206
       
-
       
		eventSource.onmessage = (event) => {

     

       
0
       
 
       

     

       
207
       
 
       
			const update = JSON.parse(event.data);

     

       
208
       
 
       


     

       
209
       
 
       
			// Update the job in our list efficiently (mutate in place for Lit)

     
···

       
223
       
 
       
					this.eventSources.delete(jobId);

     

       
224
       
 
       
				}

     

       
225
       
 
       
			}

     

       
226
       
-
       
		};

     

       
227
       
 
       


     

       
228
       
 
       
		eventSource.onerror = (error) => {

     

       
229
       
 
       
			console.warn(`SSE connection error for job ${jobId}:`, error);

     

       
230
       
 
       
			eventSource.close();

     

       
231
       
 
       
			this.eventSources.delete(jobId);

     

       
232
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
233
       
 
       
			// Retry connection up to 3 times with exponential backoff

     

       
234
       
 
       
			if (retryCount < 3) {

     

       
235
       
 
       
				const backoff = 2 ** retryCount * 1000; // 1s, 2s, 4s

     
···

       
247
       
 
       
		this.eventSources.set(jobId, eventSource);

     

       
248
       
 
       
	}

     

       
249
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
250
       
 
       
	async loadJobs() {

     

       
251
       
 
       
		try {

     

       
252
       
 
       
			const response = await fetch("/api/transcriptions");

     

       
253
       
 
       
			if (response.ok) {

     

       
254
       
 
       
				const data = await response.json();

     

       
255
       
 
       
				this.jobs = data.jobs;

     

       
256
       
-
       
				this.serviceAvailable = true;

     

       
257
       
 
       
			} else if (response.status === 404) {

     

       
258
       
 
       
				// Transcription service not available - show empty state

     

       
259
       
 
       
				this.jobs = [];

     

       
260
       
-
       
				this.serviceAvailable = false;

     

       
261
       
 
       
			} else {

     

       
262
       
 
       
				console.error("Failed to load jobs:", response.status);

     

       
263
       
-
       
				this.serviceAvailable = false;

     

       
264
       
 
       
			}

     

       
265
       
 
       
		} catch (error) {

     

       
266
       
 
       
			// Network error or service unavailable - don't break the page

     

       
267
       
 
       
			console.warn("Transcription service unavailable:", error);

     

       
268
       
 
       
			this.jobs = [];

     

       
269
       
-
       
			this.serviceAvailable = false;

     

       
270
       
 
       
		}

     

       
271
       
 
       
	}

     

       
272
       
 
       


     
···

       
324
       
 
       
			return;

     

       
325
       
 
       
		}

     

       
326
       
 
       


     

       
327
       
-
       
		if (file.size > 25 * 1024 * 1024) {

     

       
328
       
-
       
			// 25MB limit

     

       
329
       
-
       
			alert("File size must be less than 25MB");

     

       
330
       
 
       
			return;

     

       
331
       
 
       
		}

     

       
332
       
 
       


     
···

       
382
       
 
       
					}

     

       
383
       
 
       
        </div>

     

       
384
       
 
       
        <div class="upload-hint">

     

       
385
       
-
       
          ${this.serviceAvailable ? "Supports MP3, WAV, M4A, AAC, OGG, WebM, FLAC up to 25MB - Requires faster-whisper server" : "Transcription service unavailable"}

     

       
386
       
 
       
        </div>

     

       
387
       
 
       
        <input type="file" class="file-input" accept="audio/mpeg,audio/wav,audio/m4a,audio/mp4,audio/aac,audio/ogg,audio/webm,audio/flac,.m4a" @change=${this.handleFileSelect} ${!this.serviceAvailable ? "disabled" : ""} />

     

       
388
       
 
       
      </div>

     
···

       
398
       
 
       
            </div>

     

       
399
       
 
       


     

       
400
       
 
       
            ${

     

       
401
       
-
       
							job.status === "uploading" || job.status === "processing"

     

       
0
       
 
       

     

       
0
       
 
       

     

       
402
       
 
       
								? html`

     

       
403
       
 
       
              <div class="progress-bar">

     

       
404
       
-
       
                <div class="progress-fill" style="width: ${job.progress}%"></div>

     

       
405
       
 
       
              </div>

     

       
406
       
 
       
            `

     

       
407
       
 
       
								: ""

     

···

       
4
       
 
       
interface TranscriptionJob {

     

       
5
       
 
       
	id: string;

     

       
6
       
 
       
	filename: string;

     

       
7
       
+
       
	status: "uploading" | "processing" | "transcribing" | "completed" | "failed";

     

       
8
       
 
       
	progress: number;

     

       
9
       
 
       
	transcript?: string;

     

       
10
       
 
       
	created_at: number;

     
···

       
113
       
 
       
    }

     

       
114
       
 
       


     

       
115
       
 
       
    .status-processing {

     

       
116
       
+
       
      background: color-mix(in srgb, var(--primary) 10%, transparent);

     

       
117
       
+
       
      color: var(--primary);

     

       
118
       
+
       
    }

     

       
119
       
+
       


     

       
120
       
+
       
    .status-transcribing {

     

       
121
       
 
       
      background: color-mix(in srgb, var(--accent) 10%, transparent);

     

       
122
       
 
       
      color: var(--accent);

     

       
123
       
 
       
    }

     
···

       
138
       
 
       
      background: var(--secondary);

     

       
139
       
 
       
      border-radius: 2px;

     

       
140
       
 
       
      margin-bottom: 1rem;

     

       
141
       
+
       
      overflow: hidden;

     

       
142
       
+
       
      position: relative;

     

       
143
       
 
       
    }

     

       
144
       
 
       


     

       
145
       
 
       
    .progress-fill {

     
···

       
149
       
 
       
      transition: width 0.3s;

     

       
150
       
 
       
    }

     

       
151
       
 
       


     

       
152
       
+
       
    .progress-fill.indeterminate {

     

       
153
       
+
       
      width: 30%;

     

       
154
       
+
       
      background: var(--primary);

     

       
155
       
+
       
      animation: progress-slide 1.5s ease-in-out infinite;

     

       
156
       
+
       
    }

     

       
157
       
+
       


     

       
158
       
+
       
    @keyframes progress-slide {

     

       
159
       
+
       
      0% {

     

       
160
       
+
       
        transform: translateX(-100%);

     

       
161
       
+
       
      }

     

       
162
       
+
       
      100% {

     

       
163
       
+
       
        transform: translateX(333%);

     

       
164
       
+
       
      }

     

       
165
       
+
       
    }

     

       
166
       
+
       


     

       
167
       
 
       
    .job-transcript {

     

       
168
       
 
       
      background: color-mix(in srgb, var(--primary) 5%, transparent);

     

       
169
       
 
       
      border-radius: 6px;

     
···

       
186
       
 
       


     

       
187
       
 
       
	private eventSources: Map<string, EventSource> = new Map();

     

       
188
       
 
       
	private handleAuthChange = async () => {

     

       
189
       
+
       
		await this.checkHealth();

     

       
190
       
 
       
		await this.loadJobs();

     

       
191
       
 
       
		this.connectToJobStreams();

     

       
192
       
 
       
	};

     

       
193
       
 
       


     

       
194
       
 
       
	override async connectedCallback() {

     

       
195
       
 
       
		super.connectedCallback();

     

       
196
       
+
       
		await this.checkHealth();

     

       
197
       
 
       
		await this.loadJobs();

     

       
198
       
 
       
		this.connectToJobStreams();

     

       
199
       
 
       


     
···

       
214
       
 
       
	private connectToJobStreams() {

     

       
215
       
 
       
		// Connect to SSE streams for active jobs

     

       
216
       
 
       
		for (const job of this.jobs) {

     

       
217
       
+
       
			if (

     

       
218
       
+
       
				job.status === "processing" ||

     

       
219
       
+
       
				job.status === "transcribing" ||

     

       
220
       
+
       
				job.status === "uploading"

     

       
221
       
+
       
			) {

     

       
222
       
 
       
				this.connectToJobStream(job.id);

     

       
223
       
 
       
			}

     

       
224
       
 
       
		}

     
···

       
231
       
 
       


     

       
232
       
 
       
		const eventSource = new EventSource(`/api/transcriptions/${jobId}/stream`);

     

       
233
       
 
       


     

       
234
       
+
       
		// Handle named "update" events from SSE stream

     

       
235
       
+
       
		eventSource.addEventListener("update", (event) => {

     

       
236
       
 
       
			const update = JSON.parse(event.data);

     

       
237
       
 
       


     

       
238
       
 
       
			// Update the job in our list efficiently (mutate in place for Lit)

     
···

       
252
       
 
       
					this.eventSources.delete(jobId);

     

       
253
       
 
       
				}

     

       
254
       
 
       
			}

     

       
255
       
+
       
		});

     

       
256
       
 
       


     

       
257
       
 
       
		eventSource.onerror = (error) => {

     

       
258
       
 
       
			console.warn(`SSE connection error for job ${jobId}:`, error);

     

       
259
       
 
       
			eventSource.close();

     

       
260
       
 
       
			this.eventSources.delete(jobId);

     

       
261
       
 
       


     

       
262
       
+
       
			// Check if the job still exists before retrying

     

       
263
       
+
       
			const job = this.jobs.find((j) => j.id === jobId);

     

       
264
       
+
       
			if (!job) {

     

       
265
       
+
       
				console.log(`Job ${jobId} no longer exists, skipping retry`);

     

       
266
       
+
       
				return;

     

       
267
       
+
       
			}

     

       
268
       
+
       


     

       
269
       
+
       
			// Don't retry if job is already in a terminal state

     

       
270
       
+
       
			if (job.status === "completed" || job.status === "failed") {

     

       
271
       
+
       
				console.log(`Job ${jobId} is ${job.status}, skipping retry`);

     

       
272
       
+
       
				return;

     

       
273
       
+
       
			}

     

       
274
       
+
       


     

       
275
       
 
       
			// Retry connection up to 3 times with exponential backoff

     

       
276
       
 
       
			if (retryCount < 3) {

     

       
277
       
 
       
				const backoff = 2 ** retryCount * 1000; // 1s, 2s, 4s

     
···

       
289
       
 
       
		this.eventSources.set(jobId, eventSource);

     

       
290
       
 
       
	}

     

       
291
       
 
       


     

       
292
       
+
       
	async checkHealth() {

     

       
293
       
+
       
		try {

     

       
294
       
+
       
			const response = await fetch("/api/transcriptions/health");

     

       
295
       
+
       
			if (response.ok) {

     

       
296
       
+
       
				const data = await response.json();

     

       
297
       
+
       
				this.serviceAvailable = data.available;

     

       
298
       
+
       
			} else {

     

       
299
       
+
       
				this.serviceAvailable = false;

     

       
300
       
+
       
			}

     

       
301
       
+
       
		} catch {

     

       
302
       
+
       
			this.serviceAvailable = false;

     

       
303
       
+
       
		}

     

       
304
       
+
       
	}

     

       
305
       
+
       


     

       
306
       
 
       
	async loadJobs() {

     

       
307
       
 
       
		try {

     

       
308
       
 
       
			const response = await fetch("/api/transcriptions");

     

       
309
       
 
       
			if (response.ok) {

     

       
310
       
 
       
				const data = await response.json();

     

       
311
       
 
       
				this.jobs = data.jobs;

     

       
312
       
+
       
				// Don't override serviceAvailable - it's set by checkHealth()

     

       
313
       
 
       
			} else if (response.status === 404) {

     

       
314
       
 
       
				// Transcription service not available - show empty state

     

       
315
       
 
       
				this.jobs = [];

     

       
0
       
 
       

     

       
316
       
 
       
			} else {

     

       
317
       
 
       
				console.error("Failed to load jobs:", response.status);

     

       
0
       
 
       

     

       
318
       
 
       
			}

     

       
319
       
 
       
		} catch (error) {

     

       
320
       
 
       
			// Network error or service unavailable - don't break the page

     

       
321
       
 
       
			console.warn("Transcription service unavailable:", error);

     

       
322
       
 
       
			this.jobs = [];

     

       
0
       
 
       

     

       
323
       
 
       
		}

     

       
324
       
 
       
	}

     

       
325
       
 
       


     
···

       
377
       
 
       
			return;

     

       
378
       
 
       
		}

     

       
379
       
 
       


     

       
380
       
+
       
		if (file.size > 100 * 1024 * 1024) {

     

       
381
       
+
       
			// 100MB limit

     

       
382
       
+
       
			alert("File size must be less than 100MB");

     

       
383
       
 
       
			return;

     

       
384
       
 
       
		}

     

       
385
       
 
       


     
···

       
435
       
 
       
					}

     

       
436
       
 
       
        </div>

     

       
437
       
 
       
        <div class="upload-hint">

     

       
438
       
+
       
          ${this.serviceAvailable ? "Supports MP3, WAV, M4A, AAC, OGG, WebM, FLAC up to 100MB" : "Transcription is currently unavailable"}

     

       
439
       
 
       
        </div>

     

       
440
       
 
       
        <input type="file" class="file-input" accept="audio/mpeg,audio/wav,audio/m4a,audio/mp4,audio/aac,audio/ogg,audio/webm,audio/flac,.m4a" @change=${this.handleFileSelect} ${!this.serviceAvailable ? "disabled" : ""} />

     

       
441
       
 
       
      </div>

     
···

       
451
       
 
       
            </div>

     

       
452
       
 
       


     

       
453
       
 
       
            ${

     

       
454
       
+
       
							job.status === "uploading" ||

     

       
455
       
+
       
							job.status === "processing" ||

     

       
456
       
+
       
							job.status === "transcribing"

     

       
457
       
 
       
								? html`

     

       
458
       
 
       
              <div class="progress-bar">

     

       
459
       
+
       
                <div class="progress-fill ${job.status === "processing" ? "indeterminate" : ""}" style="${job.status === "processing" ? "" : `width: ${job.progress}%`}"></div>

     

       
460
       
 
       
              </div>

     

       
461
       
 
       
            `

     

       
462
       
 
       
								: ""

     

···

       
60
       
 
       
      CREATE INDEX IF NOT EXISTS idx_transcriptions_status ON transcriptions(status);

     

       
61
       
 
       
    `,

     

       
62
       
 
       
	},

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
63
       
 
       
];

     

       
64
       
 
       


     

       
65
       
 
       
function getCurrentVersion(): number {

     

···

       
60
       
 
       
      CREATE INDEX IF NOT EXISTS idx_transcriptions_status ON transcriptions(status);

     

       
61
       
 
       
    `,

     

       
62
       
 
       
	},

     

       
63
       
+
       
	{

     

       
64
       
+
       
		version: 3,

     

       
65
       
+
       
		name: "Add whisper_job_id to transcriptions",

     

       
66
       
+
       
		sql: `

     

       
67
       
+
       
      ALTER TABLE transcriptions ADD COLUMN whisper_job_id TEXT;

     

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

     

       
69
       
+
       
    `,

     

       
70
       
+
       
	},

     

       
71
       
 
       
];

     

       
72
       
 
       


     

       
73
       
 
       
function getCurrentVersion(): number {

     

···

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

     

       
36
       
 
       


     

       
37
       
 
       
// Initialize transcription system

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
38
       
 
       
const transcriptionEvents = new TranscriptionEventEmitter();

     

       
39
       
 
       
const whisperService = new WhisperServiceManager(

     

       
40
       
 
       
	WHISPER_SERVICE_URL,

     
···

       
46
       
 
       
setInterval(cleanupExpiredSessions, 60 * 60 * 1000);

     

       
47
       
 
       


     

       
48
       
 
       
// Sync with Whisper DB on startup

     

       
49
       
-
       
await whisperService.syncWithWhisper();

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
50
       
 
       


     

       
51
       
 
       
// Periodic sync every 5 minutes as backup (SSE handles real-time updates)

     

       
52
       
 
       
setInterval(() => whisperService.syncWithWhisper(), 5 * 60 * 1000);

     
···

       
389
       
 
       
						{ status: 404 },

     

       
390
       
 
       
					);

     

       
391
       
 
       
				}

     

       
392
       
-
       
				// Event-driven SSE stream (NO POLLING!)

     

       
393
       
 
       
				const stream = new ReadableStream({

     

       
394
       
 
       
					start(controller) {

     

       
395
       
 
       
						const encoder = new TextEncoder();

     

       
0
       
 
       

     

       
0
       
 
       

     

       
396
       
 
       


     

       
397
       
 
       
						const sendEvent = (data: Partial<TranscriptionUpdate>) => {

     

       
398
       
-
       
							controller.enqueue(

     

       
399
       
-
       
								encoder.encode(`data: ${JSON.stringify(data)}\n\n`),

     

       
400
       
-
       
							);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
401
       
 
       
						};

     

       
402
       
 
       
						// Send initial state from DB

     

       
403
       
 
       
						const current = db

     
···

       
424
       
 
       
							current?.status === "completed" ||

     

       
425
       
 
       
							current?.status === "failed"

     

       
426
       
 
       
						) {

     

       
0
       
 
       

     

       
427
       
 
       
							controller.close();

     

       
428
       
 
       
							return;

     

       
429
       
 
       
						}

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
430
       
 
       
						// Subscribe to EventEmitter for live updates

     

       
431
       
 
       
						const updateHandler = (data: TranscriptionUpdate) => {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
432
       
 
       
							// Only send changed fields to save bandwidth

     

       
433
       
 
       
							const payload: Partial<TranscriptionUpdate> = {

     

       
434
       
 
       
								status: data.status,

     
···

       
446
       
 
       


     

       
447
       
 
       
							// Close stream when done

     

       
448
       
 
       
							if (data.status === "completed" || data.status === "failed") {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
449
       
 
       
								transcriptionEvents.off(transcriptionId, updateHandler);

     

       
450
       
 
       
								controller.close();

     

       
451
       
 
       
							}

     
···

       
453
       
 
       
						transcriptionEvents.on(transcriptionId, updateHandler);

     

       
454
       
 
       
						// Cleanup on client disconnect

     

       
455
       
 
       
						return () => {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
456
       
 
       
							transcriptionEvents.off(transcriptionId, updateHandler);

     

       
457
       
 
       
						};

     

       
458
       
 
       
					},

     
···

       
466
       
 
       
				});

     

       
467
       
 
       
			},

     

       
468
       
 
       
		},

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
469
       
 
       
		"/api/transcriptions": {

     

       
470
       
 
       
			GET: (req) => {

     

       
471
       
 
       
				try {

     
···

       
511
       
 
       


     

       
512
       
 
       
					if (!file) throw ValidationErrors.missingField("audio");

     

       
513
       
 
       


     

       
514
       
-
       
					if (!file.type.startsWith("audio/")) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
515
       
 
       
						throw ValidationErrors.unsupportedFileType(

     

       
516
       
 
       
							"MP3, WAV, M4A, AAC, OGG, WebM, FLAC",

     

       
517
       
 
       
						);

     
···

       
523
       
 
       


     

       
524
       
 
       
					// Generate unique filename

     

       
525
       
 
       
					const transcriptionId = crypto.randomUUID();

     

       
526
       
-
       
					const fileExtension = file.name.split(".").pop();

     

       
527
       
 
       
					const filename = `${transcriptionId}.${fileExtension}`;

     

       
528
       
 
       


     

       
529
       
 
       
					// Save file to disk

     

···

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

     

       
36
       
 
       


     

       
37
       
 
       
// Initialize transcription system

     

       
38
       
+
       
console.log(

     

       
39
       
+
       
	`[Transcription] Connecting to Murmur at ${WHISPER_SERVICE_URL}...`,

     

       
40
       
+
       
);

     

       
41
       
 
       
const transcriptionEvents = new TranscriptionEventEmitter();

     

       
42
       
 
       
const whisperService = new WhisperServiceManager(

     

       
43
       
 
       
	WHISPER_SERVICE_URL,

     
···

       
49
       
 
       
setInterval(cleanupExpiredSessions, 60 * 60 * 1000);

     

       
50
       
 
       


     

       
51
       
 
       
// Sync with Whisper DB on startup

     

       
52
       
+
       
try {

     

       
53
       
+
       
	await whisperService.syncWithWhisper();

     

       
54
       
+
       
	console.log("[Transcription] Successfully connected to Murmur");

     

       
55
       
+
       
} catch (error) {

     

       
56
       
+
       
	console.warn(

     

       
57
       
+
       
		"[Transcription] Murmur unavailable at startup:",

     

       
58
       
+
       
		error instanceof Error ? error.message : "Unknown error",

     

       
59
       
+
       
	);

     

       
60
       
+
       
}

     

       
61
       
 
       


     

       
62
       
 
       
// Periodic sync every 5 minutes as backup (SSE handles real-time updates)

     

       
63
       
 
       
setInterval(() => whisperService.syncWithWhisper(), 5 * 60 * 1000);

     
···

       
400
       
 
       
						{ status: 404 },

     

       
401
       
 
       
					);

     

       
402
       
 
       
				}

     

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

     

       
404
       
 
       
				const stream = new ReadableStream({

     

       
405
       
 
       
					start(controller) {

     

       
406
       
 
       
						const encoder = new TextEncoder();

     

       
407
       
+
       
						let isClosed = false;

     

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

     

       
409
       
 
       


     

       
410
       
 
       
						const sendEvent = (data: Partial<TranscriptionUpdate>) => {

     

       
411
       
+
       
							if (isClosed) return;

     

       
412
       
+
       
							try {

     

       
413
       
+
       
								// Send event ID for reconnection support

     

       
414
       
+
       
								lastEventId = Math.floor(Date.now() / 1000);

     

       
415
       
+
       
								controller.enqueue(

     

       
416
       
+
       
									encoder.encode(

     

       
417
       
+
       
										`id: ${lastEventId}\nevent: update\ndata: ${JSON.stringify(data)}\n\n`,

     

       
418
       
+
       
									),

     

       
419
       
+
       
								);

     

       
420
       
+
       
							} catch {

     

       
421
       
+
       
								// Controller already closed (client disconnected)

     

       
422
       
+
       
								isClosed = true;

     

       
423
       
+
       
							}

     

       
424
       
+
       
						};

     

       
425
       
+
       


     

       
426
       
+
       
						const sendHeartbeat = () => {

     

       
427
       
+
       
							if (isClosed) return;

     

       
428
       
+
       
							try {

     

       
429
       
+
       
								controller.enqueue(encoder.encode(": heartbeat\n\n"));

     

       
430
       
+
       
							} catch {

     

       
431
       
+
       
								isClosed = true;

     

       
432
       
+
       
							}

     

       
433
       
 
       
						};

     

       
434
       
 
       
						// Send initial state from DB

     

       
435
       
 
       
						const current = db

     
···

       
456
       
 
       
							current?.status === "completed" ||

     

       
457
       
 
       
							current?.status === "failed"

     

       
458
       
 
       
						) {

     

       
459
       
+
       
							isClosed = true;

     

       
460
       
 
       
							controller.close();

     

       
461
       
 
       
							return;

     

       
462
       
 
       
						}

     

       
463
       
+
       
						// Send heartbeats every 2.5 seconds to keep connection alive

     

       
464
       
+
       
						const heartbeatInterval = setInterval(sendHeartbeat, 2500);

     

       
465
       
+
       


     

       
466
       
 
       
						// Subscribe to EventEmitter for live updates

     

       
467
       
 
       
						const updateHandler = (data: TranscriptionUpdate) => {

     

       
468
       
+
       
							if (isClosed) return;

     

       
469
       
+
       


     

       
470
       
 
       
							// Only send changed fields to save bandwidth

     

       
471
       
 
       
							const payload: Partial<TranscriptionUpdate> = {

     

       
472
       
 
       
								status: data.status,

     
···

       
484
       
 
       


     

       
485
       
 
       
							// Close stream when done

     

       
486
       
 
       
							if (data.status === "completed" || data.status === "failed") {

     

       
487
       
+
       
								isClosed = true;

     

       
488
       
+
       
								clearInterval(heartbeatInterval);

     

       
489
       
 
       
								transcriptionEvents.off(transcriptionId, updateHandler);

     

       
490
       
 
       
								controller.close();

     

       
491
       
 
       
							}

     
···

       
493
       
 
       
						transcriptionEvents.on(transcriptionId, updateHandler);

     

       
494
       
 
       
						// Cleanup on client disconnect

     

       
495
       
 
       
						return () => {

     

       
496
       
+
       
							isClosed = true;

     

       
497
       
+
       
							clearInterval(heartbeatInterval);

     

       
498
       
 
       
							transcriptionEvents.off(transcriptionId, updateHandler);

     

       
499
       
 
       
						};

     

       
500
       
 
       
					},

     
···

       
508
       
 
       
				});

     

       
509
       
 
       
			},

     

       
510
       
 
       
		},

     

       
511
       
+
       
		"/api/transcriptions/health": {

     

       
512
       
+
       
			GET: async () => {

     

       
513
       
+
       
				const isHealthy = await whisperService.checkHealth();

     

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

     

       
515
       
+
       
			},

     

       
516
       
+
       
		},

     

       
517
       
 
       
		"/api/transcriptions": {

     

       
518
       
 
       
			GET: (req) => {

     

       
519
       
 
       
				try {

     
···

       
559
       
 
       


     

       
560
       
 
       
					if (!file) throw ValidationErrors.missingField("audio");

     

       
561
       
 
       


     

       
562
       
+
       
					// Validate file type

     

       
563
       
+
       
					const fileExtension = file.name.split(".").pop()?.toLowerCase();

     

       
564
       
+
       
					const allowedExtensions = [

     

       
565
       
+
       
						"mp3",

     

       
566
       
+
       
						"wav",

     

       
567
       
+
       
						"m4a",

     

       
568
       
+
       
						"aac",

     

       
569
       
+
       
						"ogg",

     

       
570
       
+
       
						"webm",

     

       
571
       
+
       
						"flac",

     

       
572
       
+
       
						"mp4",

     

       
573
       
+
       
					];

     

       
574
       
+
       
					const isAudioType =

     

       
575
       
+
       
						file.type.startsWith("audio/") || file.type === "video/mp4";

     

       
576
       
+
       
					const isAudioExtension =

     

       
577
       
+
       
						fileExtension && allowedExtensions.includes(fileExtension);

     

       
578
       
+
       


     

       
579
       
+
       
					if (!isAudioType && !isAudioExtension) {

     

       
580
       
 
       
						throw ValidationErrors.unsupportedFileType(

     

       
581
       
 
       
							"MP3, WAV, M4A, AAC, OGG, WebM, FLAC",

     

       
582
       
 
       
						);

     
···

       
588
       
 
       


     

       
589
       
 
       
					// Generate unique filename

     

       
590
       
 
       
					const transcriptionId = crypto.randomUUID();

     

       
0
       
 
       

     

       
591
       
 
       
					const filename = `${transcriptionId}.${fileExtension}`;

     

       
592
       
 
       


     

       
593
       
 
       
					// Save file to disk

     

···

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

     

       
4
       
 
       


     

       
5
       
 
       
// Constants

     

       
6
       
-
       
export const MAX_FILE_SIZE = 25 * 1024 * 1024; // 25MB

     

       
7
       
 
       
export const MAX_TRANSCRIPT_LENGTH = 50000;

     

       
8
       
 
       
export const MAX_ERROR_LENGTH = 255;

     

       
9
       
 
       


     
···

       
11
       
 
       
export type TranscriptionStatus =

     

       
12
       
 
       
	| "uploading"

     

       
13
       
 
       
	| "processing"

     

       
0
       
 
       

     

       
14
       
 
       
	| "completed"

     

       
15
       
 
       
	| "failed";

     

       
16
       
 
       


     
···

       
107
       
 
       
		private events: TranscriptionEventEmitter,

     

       
108
       
 
       
	) {}

     

       
109
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
110
       
 
       
	async startTranscription(

     

       
111
       
 
       
		transcriptionId: string,

     

       
112
       
 
       
		filename: string,

     
···

       
122
       
 
       
			const filePath = `./uploads/${filename}`;

     

       
123
       
 
       
			const fileBuffer = await Bun.file(filePath).arrayBuffer();

     

       
124
       
 
       


     

       
125
       
-
       
			// Create form data for the faster-whisper server

     

       
126
       
 
       
			const formData = new FormData();

     

       
127
       
 
       
			const file = new File([fileBuffer], filename, { type: "audio/mpeg" });

     

       
128
       
 
       
			formData.append("file", file);

     

       
129
       
 
       


     

       
130
       
-
       
			// Call the faster-whisper server to start transcription

     

       
131
       
 
       
			const response = await fetch(`${this.serviceUrl}/transcribe`, {

     

       
132
       
 
       
				method: "POST",

     

       
133
       
 
       
				body: formData,

     
···

       
142
       
 
       


     

       
143
       
 
       
			const { job_id } = await response.json();

     

       
144
       
 
       


     

       
145
       
-
       
			// Connect to SSE stream from Whisper

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
146
       
 
       
			this.streamWhisperJob(transcriptionId, job_id, filePath);

     

       
147
       
 
       
		} catch (error) {

     

       
148
       
 
       
			console.error(

     
···

       
184
       
 
       


     

       
185
       
 
       
		const es = createEventSource({

     

       
186
       
 
       
			url: `${this.serviceUrl}/transcribe/${jobId}/stream`,

     

       
187
       
-
       
			onMessage: ({ data }) => {

     

       
188
       
 
       
				try {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
189
       
 
       
					const update = JSON.parse(data) as WhisperJob;

     

       
190
       
-
       
					this.handleWhisperUpdate(transcriptionId, jobId, filePath, update);

     

       
191
       
 
       
				} catch (err) {

     

       
192
       
 
       
					console.error(

     

       
193
       
 
       
						`[Stream] Error processing update for ${transcriptionId}:`,

     
···

       
202
       
 
       


     

       
203
       
 
       
	private handleWhisperUpdate(

     

       
204
       
 
       
		transcriptionId: string,

     

       
205
       
-
       
		jobId: string,

     

       
206
       
 
       
		filePath: string,

     

       
207
       
 
       
		update: WhisperJob,

     

       
208
       
 
       
	) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
209
       
 
       
		if (update.status === "processing") {

     

       
210
       
-
       
			const progress = Math.max(10, Math.min(95, update.progress ?? 0));

     

       
211
       
-
       
			this.updateTranscription(transcriptionId, { progress });

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
212
       
 
       


     

       
213
       
 
       
			this.events.emit(transcriptionId, {

     

       
214
       
 
       
				status: "processing",

     

       
215
       
 
       
				progress,

     

       
216
       
 
       
			});

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
0
       
 
       

     

       
218
       
 
       
			const transcript = (update.transcript ?? "").substring(

     

       
219
       
 
       
				0,

     

       
220
       
 
       
				MAX_TRANSCRIPT_LENGTH,

     
···

       
232
       
 
       
				transcript,

     

       
233
       
 
       
			});

     

       
234
       
 
       


     

       
235
       
-
       
			// Clean up

     

       
236
       
-
       
			this.cleanupJob(transcriptionId, jobId, filePath);

     

       
0
       
 
       

     

       
237
       
 
       
		} else if (update.status === "failed") {

     

       
238
       
 
       
			const errorMessage = (

     

       
239
       
 
       
				update.error_message ?? "Transcription failed"

     
···

       
251
       
 
       
				error_code: ErrorCode.TRANSCRIPTION_FAILED,

     

       
252
       
 
       
			});

     

       
253
       
 
       


     

       
0
       
 
       

     

       
254
       
 
       
			this.closeStream(transcriptionId);

     

       
255
       
-
       
			this.deleteWhisperJob(jobId);

     

       
256
       
 
       
		}

     

       
257
       
 
       
	}

     

       
258
       
 
       


     

       
259
       
-
       
	private cleanupJob(transcriptionId: string, jobId: string, filePath: string) {

     

       
260
       
-
       
		// Delete uploaded file

     

       
261
       
-
       
		Bun.file(filePath)

     

       
262
       
-
       
			.text()

     

       
263
       
-
       
			.then(() => Bun.write(filePath, ""))

     

       
264
       
-
       
			.catch(() => {});

     

       
265
       
-
       


     

       
266
       
-
       
		this.closeStream(transcriptionId);

     

       
267
       
-
       
		this.deleteWhisperJob(jobId);

     

       
268
       
-
       
	}

     

       
269
       
-
       


     

       
270
       
 
       
	private closeStream(transcriptionId: string) {

     

       
271
       
 
       
		const es = this.activeStreams.get(transcriptionId);

     

       
272
       
 
       
		if (es) {

     
···

       
276
       
 
       
		this.streamLocks.delete(transcriptionId);

     

       
277
       
 
       
	}

     

       
278
       
 
       


     

       
279
       
-
       
	private async deleteWhisperJob(jobId: string) {

     

       
280
       
-
       
		try {

     

       
281
       
-
       
			await fetch(`${this.serviceUrl}/transcribe/${jobId}`, {

     

       
282
       
-
       
				method: "DELETE",

     

       
283
       
-
       
			});

     

       
284
       
-
       
		} catch {

     

       
285
       
-
       
			// Silent fail - job may already be deleted

     

       
286
       
-
       
		}

     

       
287
       
 
       
	}

     

       
288
       
 
       


     

       
289
       
 
       
	private updateTranscription(

     
···

       
327
       
 
       
	}

     

       
328
       
 
       


     

       
329
       
 
       
	async syncWithWhisper(): Promise<void> {

     

       
330
       
-
       
		try {

     

       
331
       
-
       
			const whisperJobs = await this.fetchWhisperJobs();

     

       
332
       
-
       
			if (!whisperJobs) return;

     

       
0
       
 
       

     

       
333
       
 
       


     

       
334
       
-
       
			const activeDbJobs = this.getActiveDbJobs();

     

       
335
       
-
       
			const activeJobsMap = new Map(activeDbJobs.map((j) => [j.id, j]));

     

       
336
       
 
       


     

       
337
       
-
       
			await this.syncWhisperJobsToDb(whisperJobs, activeJobsMap);

     

       
338
       
-
       
			await this.syncDbJobsToWhisper(activeDbJobs, whisperJobs);

     

       
339
       
-
       
		} catch (error) {

     

       
340
       
-
       
			console.warn(

     

       
341
       
-
       
				"[Sync] Failed:",

     

       
342
       
-
       
				error instanceof Error ? error.message : "Unknown error",

     

       
343
       
-
       
			);

     

       
344
       
-
       
		}

     

       
345
       
 
       
	}

     

       
346
       
 
       


     

       
347
       
 
       
	private async fetchWhisperJobs(): Promise<WhisperJob[] | null> {

     
···

       
360
       
 
       


     

       
361
       
 
       
	private getActiveDbJobs(): Array<{

     

       
362
       
 
       
		id: string;

     

       
0
       
 
       

     

       
363
       
 
       
		filename: string;

     

       
364
       
 
       
		status: string;

     

       
365
       
 
       
	}> {

     

       
366
       
 
       
		return this.db

     

       
367
       
-
       
			.query<{ id: string; filename: string; status: string }, []>(

     

       
368
       
-
       
				"SELECT id, filename, status FROM transcriptions WHERE status IN ('uploading', 'processing')",

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
369
       
 
       
			)

     

       
370
       
 
       
			.all();

     

       
371
       
 
       
	}

     
···

       
374
       
 
       
		whisperJobs: WhisperJob[],

     

       
375
       
 
       
		activeJobsMap: Map<

     

       
376
       
 
       
			string,

     

       
377
       
-
       
			{ id: string; filename: string; status: string }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
378
       
 
       
		>,

     

       
379
       
 
       
	) {

     

       
380
       
 
       
		for (const whisperJob of whisperJobs) {

     

       
381
       
-
       
			const localJob = activeJobsMap.get(whisperJob.id);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
382
       
 
       


     

       
383
       
 
       
			if (!localJob) {

     

       
384
       
 
       
				await this.handleOrphanedWhisperJob(whisperJob.id);

     

       
385
       
 
       
				continue;

     

       
386
       
 
       
			}

     

       
387
       
 
       


     

       
388
       
-
       
			if (whisperJob.status === "completed" || whisperJob.status === "failed") {

     

       
389
       
-
       
				await this.syncCompletedJob(whisperJob);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
390
       
 
       
			}

     

       
391
       
 
       
		}

     

       
392
       
 
       
	}

     

       
393
       
 
       


     

       
394
       
 
       
	private async handleOrphanedWhisperJob(jobId: string) {

     

       
0
       
 
       

     

       
395
       
 
       
		const jobExists = this.db

     

       
396
       
-
       
			.query<{ id: string }, [string]>(

     

       
397
       
-
       
				"SELECT id FROM transcriptions WHERE id = ?",

     

       
398
       
 
       
			)

     

       
399
       
-
       
			.get(jobId);

     

       
400
       
 
       


     

       
401
       
 
       
		if (!jobExists) {

     

       
402
       
-
       
			// Not our job, delete it from Whisper

     

       
403
       
-
       
			await this.deleteWhisperJob(jobId);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
404
       
 
       
		}

     

       
405
       
 
       
	}

     

       
406
       
 
       


     

       
407
       
-
       
	private async syncCompletedJob(whisperJob: WhisperJob) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
408
       
 
       
		try {

     

       
409
       
 
       
			const details = await this.fetchJobDetails(whisperJob.id);

     

       
410
       
 
       
			if (!details) return;

     
···

       
413
       
 
       
				const transcript =

     

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

     

       
415
       
 
       


     

       
416
       
-
       
				this.updateTranscription(whisperJob.id, {

     

       
417
       
 
       
					status: "completed",

     

       
418
       
 
       
					progress: 100,

     

       
419
       
 
       
					transcript,

     

       
420
       
 
       
				});

     

       
421
       
 
       


     

       
422
       
-
       
				this.events.emit(whisperJob.id, {

     

       
423
       
 
       
					status: "completed",

     

       
424
       
 
       
					progress: 100,

     

       
425
       
 
       
					transcript,

     
···

       
429
       
 
       
					details.error_message ?? "Transcription failed"

     

       
430
       
 
       
				).substring(0, MAX_ERROR_LENGTH);

     

       
431
       
 
       


     

       
432
       
-
       
				this.updateTranscription(whisperJob.id, {

     

       
433
       
 
       
					status: "failed",

     

       
434
       
 
       
					error_message: errorMessage,

     

       
435
       
 
       
				});

     

       
436
       
 
       


     

       
437
       
-
       
				this.events.emit(whisperJob.id, {

     

       
438
       
 
       
					status: "failed",

     

       
439
       
 
       
					progress: 0,

     

       
440
       
 
       
					error_message: errorMessage,

     

       
441
       
 
       
				});

     

       
442
       
 
       
			}

     

       
443
       
 
       


     

       
444
       
-
       
			await this.deleteWhisperJob(whisperJob.id);

     

       
445
       
 
       
		} catch {

     

       
446
       
 
       
			console.warn(

     

       
447
       
 
       
				`[Sync] Failed to retrieve details for job ${whisperJob.id}`,

     
···

       
456
       
 
       
	}

     

       
457
       
 
       


     

       
458
       
 
       
	private async syncDbJobsToWhisper(

     

       
459
       
-
       
		activeDbJobs: Array<{ id: string; filename: string; status: string }>,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
460
       
 
       
		whisperJobs: WhisperJob[],

     

       
461
       
 
       
	) {

     

       
462
       
 
       
		for (const localJob of activeDbJobs) {

     

       
463
       
-
       
			const whisperHasJob = whisperJobs.some((wj) => wj.id === localJob.id);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
464
       
 
       


     

       
465
       
-
       
			if (!whisperHasJob) {

     

       
466
       
-
       
				// Job was lost, mark as failed

     

       
467
       
 
       
				const errorMessage = "Job lost - whisper service may have restarted";

     

       
468
       
 
       


     

       
469
       
 
       
				this.updateTranscription(localJob.id, {

     

···

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

     

       
4
       
 
       


     

       
5
       
 
       
// Constants

     

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

     

       
7
       
 
       
export const MAX_TRANSCRIPT_LENGTH = 50000;

     

       
8
       
 
       
export const MAX_ERROR_LENGTH = 255;

     

       
9
       
 
       


     
···

       
11
       
 
       
export type TranscriptionStatus =

     

       
12
       
 
       
	| "uploading"

     

       
13
       
 
       
	| "processing"

     

       
14
       
+
       
	| "transcribing"

     

       
15
       
 
       
	| "completed"

     

       
16
       
 
       
	| "failed";

     

       
17
       
 
       


     
···

       
108
       
 
       
		private events: TranscriptionEventEmitter,

     

       
109
       
 
       
	) {}

     

       
110
       
 
       


     

       
111
       
+
       
	async checkHealth(): Promise<boolean> {

     

       
112
       
+
       
		try {

     

       
113
       
+
       
			const response = await fetch(`${this.serviceUrl}/jobs`, {

     

       
114
       
+
       
				method: "GET",

     

       
115
       
+
       
			});

     

       
116
       
+
       
			return response.ok;

     

       
117
       
+
       
		} catch {

     

       
118
       
+
       
			return false;

     

       
119
       
+
       
		}

     

       
120
       
+
       
	}

     

       
121
       
+
       


     

       
122
       
 
       
	async startTranscription(

     

       
123
       
 
       
		transcriptionId: string,

     

       
124
       
 
       
		filename: string,

     
···

       
134
       
 
       
			const filePath = `./uploads/${filename}`;

     

       
135
       
 
       
			const fileBuffer = await Bun.file(filePath).arrayBuffer();

     

       
136
       
 
       


     

       
137
       
+
       
			// Create form data for the Murmur server

     

       
138
       
 
       
			const formData = new FormData();

     

       
139
       
 
       
			const file = new File([fileBuffer], filename, { type: "audio/mpeg" });

     

       
140
       
 
       
			formData.append("file", file);

     

       
141
       
 
       


     

       
142
       
+
       
			// Call the Murmur server to start transcription

     

       
143
       
 
       
			const response = await fetch(`${this.serviceUrl}/transcribe`, {

     

       
144
       
 
       
				method: "POST",

     

       
145
       
 
       
				body: formData,

     
···

       
154
       
 
       


     

       
155
       
 
       
			const { job_id } = await response.json();

     

       
156
       
 
       


     

       
157
       
+
       
			// Store Murmur's job_id in our database for tracking

     

       
158
       
+
       
			this.db.run("UPDATE transcriptions SET whisper_job_id = ? WHERE id = ?", [

     

       
159
       
+
       
				job_id,

     

       
160
       
+
       
				transcriptionId,

     

       
161
       
+
       
			]);

     

       
162
       
+
       


     

       
163
       
+
       
			// Connect to SSE stream from Murmur (use the job_id returned by Murmur)

     

       
164
       
 
       
			this.streamWhisperJob(transcriptionId, job_id, filePath);

     

       
165
       
 
       
		} catch (error) {

     

       
166
       
 
       
			console.error(

     
···

       
202
       
 
       


     

       
203
       
 
       
		const es = createEventSource({

     

       
204
       
 
       
			url: `${this.serviceUrl}/transcribe/${jobId}/stream`,

     

       
205
       
+
       
			onMessage: ({ event, data }) => {

     

       
206
       
 
       
				try {

     

       
207
       
+
       
					// Handle "error" events from SSE (e.g., "Job not found")

     

       
208
       
+
       
					if (event === "error") {

     

       
209
       
+
       
						const errorData = JSON.parse(data) as { error: string };

     

       
210
       
+
       
						console.error(

     

       
211
       
+
       
							`[Stream] Whisper service error for ${transcriptionId}:`,

     

       
212
       
+
       
							errorData.error,

     

       
213
       
+
       
						);

     

       
214
       
+
       


     

       
215
       
+
       
						// Mark the job as failed in our database

     

       
216
       
+
       
						this.updateTranscription(transcriptionId, {

     

       
217
       
+
       
							status: "failed",

     

       
218
       
+
       
							error_message: errorData.error,

     

       
219
       
+
       
						});

     

       
220
       
+
       


     

       
221
       
+
       
						this.events.emit(transcriptionId, {

     

       
222
       
+
       
							status: "failed",

     

       
223
       
+
       
							progress: 0,

     

       
224
       
+
       
							error_message: errorData.error,

     

       
225
       
+
       
							error_code: ErrorCode.TRANSCRIPTION_FAILED,

     

       
226
       
+
       
						});

     

       
227
       
+
       


     

       
228
       
+
       
						this.closeStream(transcriptionId);

     

       
229
       
+
       
						return;

     

       
230
       
+
       
					}

     

       
231
       
+
       


     

       
232
       
 
       
					const update = JSON.parse(data) as WhisperJob;

     

       
233
       
+
       
					this.handleWhisperUpdate(transcriptionId, filePath, update);

     

       
234
       
 
       
				} catch (err) {

     

       
235
       
 
       
					console.error(

     

       
236
       
 
       
						`[Stream] Error processing update for ${transcriptionId}:`,

     
···

       
245
       
 
       


     

       
246
       
 
       
	private handleWhisperUpdate(

     

       
247
       
 
       
		transcriptionId: string,

     

       
0
       
 
       

     

       
248
       
 
       
		filePath: string,

     

       
249
       
 
       
		update: WhisperJob,

     

       
250
       
 
       
	) {

     

       
251
       
+
       
		if (update.status === "pending") {

     

       
252
       
+
       
			// Initial status, no action needed

     

       
253
       
+
       
			return;

     

       
254
       
+
       
		}

     

       
255
       
+
       


     

       
256
       
 
       
		if (update.status === "processing") {

     

       
257
       
+
       
			// Murmur is initializing (file I/O, WhisperKit setup) - no transcript yet

     

       
258
       
+
       
			const progress = Math.min(100, update.progress ?? 0);

     

       
259
       
+
       


     

       
260
       
+
       
			this.updateTranscription(transcriptionId, {

     

       
261
       
+
       
				status: "processing",

     

       
262
       
+
       
				progress,

     

       
263
       
+
       
			});

     

       
264
       
 
       


     

       
265
       
 
       
			this.events.emit(transcriptionId, {

     

       
266
       
 
       
				status: "processing",

     

       
267
       
 
       
				progress,

     

       
268
       
 
       
			});

     

       
269
       
+
       
		} else if (update.status === "transcribing") {

     

       
270
       
+
       
			// Active transcription with progress callbacks

     

       
271
       
+
       
			const progress = Math.min(100, update.progress ?? 0);

     

       
272
       
+
       


     

       
273
       
+
       
			// If progress is still 0, keep status as "processing" until real progress starts

     

       
274
       
+
       
			const status = progress === 0 ? "processing" : "transcribing";

     

       
275
       
+
       


     

       
276
       
+
       
			// Strip WhisperKit special tokens from intermediate transcript

     

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

     

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

     

       
279
       
+
       


     

       
280
       
+
       
			this.updateTranscription(transcriptionId, {

     

       
281
       
+
       
				status,

     

       
282
       
+
       
				progress,

     

       
283
       
+
       
				transcript,

     

       
284
       
+
       
			});

     

       
285
       
+
       


     

       
286
       
+
       
			this.events.emit(transcriptionId, {

     

       
287
       
+
       
				status,

     

       
288
       
+
       
				progress,

     

       
289
       
+
       
				transcript: transcript || undefined,

     

       
290
       
+
       
			});

     

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

     

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

     

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

     

       
294
       
 
       
				0,

     

       
295
       
 
       
				MAX_TRANSCRIPT_LENGTH,

     
···

       
307
       
 
       
				transcript,

     

       
308
       
 
       
			});

     

       
309
       
 
       


     

       
310
       
+
       
			// Only close stream and delete local file - keep Whisper job for potential replay/debugging

     

       
311
       
+
       
			this.closeStream(transcriptionId);

     

       
312
       
+
       
			this.deleteLocalFile(filePath);

     

       
313
       
 
       
		} else if (update.status === "failed") {

     

       
314
       
 
       
			const errorMessage = (

     

       
315
       
 
       
				update.error_message ?? "Transcription failed"

     
···

       
327
       
 
       
				error_code: ErrorCode.TRANSCRIPTION_FAILED,

     

       
328
       
 
       
			});

     

       
329
       
 
       


     

       
330
       
+
       
			// Only close stream - keep failed jobs in Whisper for debugging

     

       
331
       
 
       
			this.closeStream(transcriptionId);

     

       
0
       
 
       

     

       
332
       
 
       
		}

     

       
333
       
 
       
	}

     

       
334
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
335
       
 
       
	private closeStream(transcriptionId: string) {

     

       
336
       
 
       
		const es = this.activeStreams.get(transcriptionId);

     

       
337
       
 
       
		if (es) {

     
···

       
341
       
 
       
		this.streamLocks.delete(transcriptionId);

     

       
342
       
 
       
	}

     

       
343
       
 
       


     

       
344
       
+
       
	private deleteLocalFile(filePath: string) {

     

       
345
       
+
       
		// Delete uploaded file from disk

     

       
346
       
+
       
		Bun.file(filePath)

     

       
347
       
+
       
			.text()

     

       
348
       
+
       
			.then(() => Bun.write(filePath, ""))

     

       
349
       
+
       
			.catch(() => {});

     

       
0
       
 
       

     

       
0
       
 
       

     

       
350
       
 
       
	}

     

       
351
       
 
       


     

       
352
       
 
       
	private updateTranscription(

     
···

       
390
       
 
       
	}

     

       
391
       
 
       


     

       
392
       
 
       
	async syncWithWhisper(): Promise<void> {

     

       
393
       
+
       
		const whisperJobs = await this.fetchWhisperJobs();

     

       
394
       
+
       
		if (!whisperJobs) {

     

       
395
       
+
       
			throw new Error("Murmur service unavailable");

     

       
396
       
+
       
		}

     

       
397
       
 
       


     

       
398
       
+
       
		const activeDbJobs = this.getActiveDbJobs();

     

       
399
       
+
       
		const activeJobsMap = new Map(activeDbJobs.map((j) => [j.id, j]));

     

       
400
       
 
       


     

       
401
       
+
       
		await this.syncWhisperJobsToDb(whisperJobs, activeJobsMap);

     

       
402
       
+
       
		await this.syncDbJobsToWhisper(activeDbJobs, whisperJobs);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
403
       
 
       
	}

     

       
404
       
 
       


     

       
405
       
 
       
	private async fetchWhisperJobs(): Promise<WhisperJob[] | null> {

     
···

       
418
       
 
       


     

       
419
       
 
       
	private getActiveDbJobs(): Array<{

     

       
420
       
 
       
		id: string;

     

       
421
       
+
       
		whisper_job_id: string | null;

     

       
422
       
 
       
		filename: string;

     

       
423
       
 
       
		status: string;

     

       
424
       
 
       
	}> {

     

       
425
       
 
       
		return this.db

     

       
426
       
+
       
			.query<

     

       
427
       
+
       
				{

     

       
428
       
+
       
					id: string;

     

       
429
       
+
       
					whisper_job_id: string | null;

     

       
430
       
+
       
					filename: string;

     

       
431
       
+
       
					status: string;

     

       
432
       
+
       
				},

     

       
433
       
+
       
				[]

     

       
434
       
+
       
			>(

     

       
435
       
+
       
				"SELECT id, whisper_job_id, filename, status FROM transcriptions WHERE status IN ('uploading', 'processing', 'transcribing')",

     

       
436
       
 
       
			)

     

       
437
       
 
       
			.all();

     

       
438
       
 
       
	}

     
···

       
441
       
 
       
		whisperJobs: WhisperJob[],

     

       
442
       
 
       
		activeJobsMap: Map<

     

       
443
       
 
       
			string,

     

       
444
       
+
       
			{

     

       
445
       
+
       
				id: string;

     

       
446
       
+
       
				whisper_job_id: string | null;

     

       
447
       
+
       
				filename: string;

     

       
448
       
+
       
				status: string;

     

       
449
       
+
       
			}

     

       
450
       
 
       
		>,

     

       
451
       
 
       
	) {

     

       
452
       
 
       
		for (const whisperJob of whisperJobs) {

     

       
453
       
+
       
			// Try to find by whisper_job_id first, then fall back to id

     

       
454
       
+
       
			let localJob = Array.from(activeJobsMap.values()).find(

     

       
455
       
+
       
				(j) => j.whisper_job_id === whisperJob.id,

     

       
456
       
+
       
			);

     

       
457
       
+
       


     

       
458
       
+
       
			if (!localJob) {

     

       
459
       
+
       
				// Legacy: try matching by our transcriptionId === whisperJob.id

     

       
460
       
+
       
				localJob = activeJobsMap.get(whisperJob.id);

     

       
461
       
+
       
			}

     

       
462
       
 
       


     

       
463
       
 
       
			if (!localJob) {

     

       
464
       
 
       
				await this.handleOrphanedWhisperJob(whisperJob.id);

     

       
465
       
 
       
				continue;

     

       
466
       
 
       
			}

     

       
467
       
 
       


     

       
468
       
+
       
			// Reconnect to active jobs on startup

     

       
469
       
+
       
			if (

     

       
470
       
+
       
				whisperJob.status === "processing" ||

     

       
471
       
+
       
				whisperJob.status === "transcribing"

     

       
472
       
+
       
			) {

     

       
473
       
+
       
				// Check if we're already streaming this job

     

       
474
       
+
       
				if (!this.activeStreams.has(localJob.id)) {

     

       
475
       
+
       
					console.log(

     

       
476
       
+
       
						`[Sync] Reconnecting to active job ${localJob.id} (Murmur job ${whisperJob.id})`,

     

       
477
       
+
       
					);

     

       
478
       
+
       
					const filePath = `./uploads/${localJob.filename}`;

     

       
479
       
+
       
					this.streamWhisperJob(localJob.id, whisperJob.id, filePath);

     

       
480
       
+
       
				}

     

       
481
       
+
       
			} else if (

     

       
482
       
+
       
				whisperJob.status === "completed" ||

     

       
483
       
+
       
				whisperJob.status === "failed"

     

       
484
       
+
       
			) {

     

       
485
       
+
       
				// Use our transcription ID, not Murmur's job ID

     

       
486
       
+
       
				await this.syncCompletedJob(whisperJob, localJob.id);

     

       
487
       
 
       
			}

     

       
488
       
 
       
		}

     

       
489
       
 
       
	}

     

       
490
       
 
       


     

       
491
       
 
       
	private async handleOrphanedWhisperJob(jobId: string) {

     

       
492
       
+
       
		// Check if this Murmur job_id exists in our DB (either as id or whisper_job_id)

     

       
493
       
 
       
		const jobExists = this.db

     

       
494
       
+
       
			.query<{ id: string }, [string, string]>(

     

       
495
       
+
       
				"SELECT id FROM transcriptions WHERE id = ? OR whisper_job_id = ?",

     

       
496
       
 
       
			)

     

       
497
       
+
       
			.get(jobId, jobId);

     

       
498
       
 
       


     

       
499
       
 
       
		if (!jobExists) {

     

       
500
       
+
       
			// Not our job - Murmur will keep it until explicitly deleted

     

       
501
       
+
       
			console.warn(

     

       
502
       
+
       
				`[Sync] Found orphaned job ${jobId} in Murmur (not in our DB)`,

     

       
503
       
+
       
			);

     

       
504
       
 
       
		}

     

       
505
       
 
       
	}

     

       
506
       
 
       


     

       
507
       
+
       
	private async syncCompletedJob(

     

       
508
       
+
       
		whisperJob: WhisperJob,

     

       
509
       
+
       
		transcriptionId: string,

     

       
510
       
+
       
	) {

     

       
511
       
 
       
		try {

     

       
512
       
 
       
			const details = await this.fetchJobDetails(whisperJob.id);

     

       
513
       
 
       
			if (!details) return;

     
···

       
516
       
 
       
				const transcript =

     

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

     

       
518
       
 
       


     

       
519
       
+
       
				this.updateTranscription(transcriptionId, {

     

       
520
       
 
       
					status: "completed",

     

       
521
       
 
       
					progress: 100,

     

       
522
       
 
       
					transcript,

     

       
523
       
 
       
				});

     

       
524
       
 
       


     

       
525
       
+
       
				this.events.emit(transcriptionId, {

     

       
526
       
 
       
					status: "completed",

     

       
527
       
 
       
					progress: 100,

     

       
528
       
 
       
					transcript,

     
···

       
532
       
 
       
					details.error_message ?? "Transcription failed"

     

       
533
       
 
       
				).substring(0, MAX_ERROR_LENGTH);

     

       
534
       
 
       


     

       
535
       
+
       
				this.updateTranscription(transcriptionId, {

     

       
536
       
 
       
					status: "failed",

     

       
537
       
 
       
					error_message: errorMessage,

     

       
538
       
 
       
				});

     

       
539
       
 
       


     

       
540
       
+
       
				this.events.emit(transcriptionId, {

     

       
541
       
 
       
					status: "failed",

     

       
542
       
 
       
					progress: 0,

     

       
543
       
 
       
					error_message: errorMessage,

     

       
544
       
 
       
				});

     

       
545
       
 
       
			}

     

       
546
       
 
       


     

       
547
       
+
       
			// Job persists in Murmur until explicitly deleted - we just sync state

     

       
548
       
 
       
		} catch {

     

       
549
       
 
       
			console.warn(

     

       
550
       
 
       
				`[Sync] Failed to retrieve details for job ${whisperJob.id}`,

     
···

       
559
       
 
       
	}

     

       
560
       
 
       


     

       
561
       
 
       
	private async syncDbJobsToWhisper(

     

       
562
       
+
       
		activeDbJobs: Array<{

     

       
563
       
+
       
			id: string;

     

       
564
       
+
       
			whisper_job_id: string | null;

     

       
565
       
+
       
			filename: string;

     

       
566
       
+
       
			status: string;

     

       
567
       
+
       
		}>,

     

       
568
       
 
       
		whisperJobs: WhisperJob[],

     

       
569
       
 
       
	) {

     

       
570
       
 
       
		for (const localJob of activeDbJobs) {

     

       
571
       
+
       
			// Check if Murmur has this job (by whisper_job_id or legacy id match)

     

       
572
       
+
       
			const whisperHasJob = whisperJobs.some(

     

       
573
       
+
       
				(wj) => wj.id === localJob.whisper_job_id || wj.id === localJob.id,

     

       
574
       
+
       
			);

     

       
575
       
 
       


     

       
576
       
+
       
			if (!whisperHasJob && localJob.whisper_job_id) {

     

       
577
       
+
       
				// Job was lost from Murmur, mark as failed

     

       
578
       
 
       
				const errorMessage = "Job lost - whisper service may have restarted";

     

       
579
       
 
       


     

       
580
       
 
       
				this.updateTranscription(localJob.id, {

     

···

       
13
       
 
       
# --- 1. Load Model on Startup ---

     

       
14
       
 
       
# This loads the model only once, not on every request

     

       
15
       
 
       
print("--- Loading faster-whisper model... ---")

     

       
16
       
-
       
model_size = "small"

     

       
17
       
 
       
# You can change this to "cuda" and "float16" if you have a GPU

     

       
18
       
 
       
model = WhisperModel(model_size, device="cpu", compute_type="int8")

     

       
19
       
 
       
print(f"--- Model '{model_size}' loaded. Server is ready. ---")

     

···

       
13
       
 
       
# --- 1. Load Model on Startup ---

     

       
14
       
 
       
# This loads the model only once, not on every request

     

       
15
       
 
       
print("--- Loading faster-whisper model... ---")

     

       
16
       
+
       
model_size = "medium.en"

     

       
17
       
 
       
# You can change this to "cuda" and "float16" if you have a GPU

     

       
18
       
 
       
model = WhisperModel(model_size, device="cpu", compute_type="int8")

     

       
19
       
 
       
print(f"--- Model '{model_size}' loaded. Server is ready. ---")