great progress

Author: kentcdodds

exercises/01.advanced-tools/01.problem.annotations/src/resources.ts

@@ -1,6 +1,7 @@
 import { invariant } from '@epic-web/invariant'
 import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js'
 import { type EpicMeMCP } from './index.ts'
+import { getVideoBase64, listVideos } from './video.ts'
 
 export async function initializeResources(agent: EpicMeMCP) {
 	agent.server.registerResource(
@@ -105,4 +106,45 @@ export async function initializeResources(agent: EpicMeMCP) {
 			}
 		},
 	)
+
+	agent.server.registerResource(
+		'video',
+		new ResourceTemplate('epicme://videos/{videoId}', {
+			complete: {
+				async videoId(value) {
+					const videos = await listVideos()
+					return videos.filter((video) => video.includes(value))
+				},
+			},
+			list: async () => {
+				const videos = await listVideos()
+				return {
+					resources: videos.map((video) => ({
+						name: video,
+						uri: `epicme://videos/${video}`,
+						mimeType: 'application/json',
+					})),
+				}
+			},
+		}),
+		{
+			title: 'EpicMe Videos',
+			description: 'A single video with the given ID',
+		},
+		async (uri, { videoId }) => {
+			invariant(typeof videoId === 'string', 'Video ID is required')
+
+			const videoBase64 = await getVideoBase64(videoId)
+			invariant(videoBase64, `Video with ID "${videoId}" not found`)
+			return {
+				contents: [
+					{
+						mimeType: 'video/mp4',
+						text: videoBase64,
+						uri: uri.toString(),
+					},
+				],
+			}
+		},
+	)
 }

exercises/01.advanced-tools/01.problem.annotations/src/sampling.ts

@@ -1,6 +1,3 @@
-import { spawn } from 'node:child_process'
-import * as fs from 'node:fs/promises'
-import { userInfo } from 'node:os'
 import { invariant } from '@epic-web/invariant'
 import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js'
 import { z } from 'zod'
@@ -14,6 +11,7 @@ import {
 	updateTagInputSchema,
 } from './db/schema.ts'
 import { type EpicMeMCP } from './index.ts'
+import { createWrappedVideo } from './video.ts'
 
 export async function initializeTools(agent: EpicMeMCP) {
 	agent.server.registerTool(
@@ -285,15 +283,13 @@ export async function initializeTools(agent: EpicMeMCP) {
 					),
 				mockTime: z
 					.number()
+					.optional()
 					.describe(
 						'If set to > 0, use mock mode and this is the mock wait time in milliseconds',
 					),
 			},
 		},
-		async (
-			{ year = new Date().getFullYear(), mockTime },
-			{ sendNotification, _meta, signal },
-		) => {
+		async ({ year = new Date().getFullYear(), mockTime }) => {
 			const entries = await agent.db.getEntries()
 			const filteredEntries = entries.filter(
 				(entry) => new Date(entry.createdAt * 1000).getFullYear() === year,
@@ -307,20 +303,6 @@ export async function initializeTools(agent: EpicMeMCP) {
 				tags: filteredTags,
 				year,
 				mockTime,
-				onProgress: (progress) => {
-					const { progressToken } = _meta ?? {}
-					if (!progressToken) return
-					void sendNotification({
-						method: 'notifications/progress',
-						params: {
-							progressToken,
-							progress,
-							total: 1,
-							message: 'Creating video...',
-						},
-					})
-				},
-				signal,
 			})
 			return {
 				content: [
@@ -395,159 +377,3 @@ function createTagResourceContent(tag: { id: number }): ResourceContent {
 		},
 	}
 }
-
-async function createWrappedVideo({
-	entries,
-	tags,
-	year,
-	mockTime,
-	onProgress,
-	signal,
-}: {
-	entries: Array<{ id: number; content: string }>
-	tags: Array<{ id: number; name: string }>
-	year: number
-	mockTime: number
-	onProgress: (progress: number) => void
-	signal: AbortSignal
-}) {
-	if (signal.aborted) {
-		throw new Error('Cancelled')
-	}
-	signal.addEventListener('abort', onAbort)
-	let ffmpeg: ReturnType<typeof spawn> | undefined
-	function onAbort() {
-		if (ffmpeg && !ffmpeg.killed) {
-			ffmpeg.kill('SIGKILL')
-		}
-	}
-	try {
-		if (mockTime > 0) {
-			const step = mockTime / 10
-			for (let i = 0; i < mockTime; i += step) {
-				if (signal.aborted) throw new Error('Cancelled')
-				const progress = i / mockTime
-				if (progress >= 1) break
-				onProgress(progress)
-				await new Promise((resolve) => setTimeout(resolve, step))
-			}
-			onProgress(1)
-			return 'epicme://videos/wrapped-2025'
-		}
-
-		const totalDurationSeconds = 60 * 2
-		const texts = [
-			{
-				text: `Hello ${userInfo().username}!`,
-				color: 'white',
-				fontsize: 72,
-			},
-			{
-				text: `It's ${new Date().toLocaleDateString('en-US', {
-					month: 'long',
-					day: 'numeric',
-					year: 'numeric',
-				})}`,
-				color: 'green',
-				fontsize: 72,
-			},
-			{
-				text: `Here's your EpicMe wrapped video for ${year}`,
-				color: 'yellow',
-				fontsize: 72,
-			},
-			{
-				text: `You wrote ${entries.length} entries in ${year}`,
-				color: '#ff69b4',
-				fontsize: 72,
-			},
-			{
-				text: `And you created ${tags.length} tags in ${year}`,
-				color: 'yellow',
-				fontsize: 72,
-			},
-			{ text: `Good job!`, color: 'red', fontsize: 72 },
-			{
-				text: `Keep Journaling in ${year + 1}!`,
-				color: '#ffa500',
-				fontsize: 72,
-			},
-		]
-		const numTexts = texts.length
-		const perTextDuration = totalDurationSeconds / numTexts
-		const outputFile = `./videos/wrapped-${year}.mp4`
-		await fs.mkdir('./videos', { recursive: true })
-		const fontPath = './other/caveat-variable-font.ttf'
-		const timings = texts.map((_, i) => {
-			const start = perTextDuration * i
-			const end = perTextDuration * (i + 1)
-			return { start, end }
-		})
-		const drawtexts = texts.map((t, i) => {
-			const { start, end } = timings[i]!
-			const fadeInEnd = start + perTextDuration / 3
-			const fadeOutStart = end - perTextDuration / 3
-			const scrollExpr = `h-((t-${start})*(h+text_h)/${perTextDuration})`
-			const fontcolor = t.color.startsWith('#')
-				? t.color.replace('#', '0x')
-				: t.color
-			const safeText = t.text
-				.replace(/\\/g, '\\\\')
-				.replace(/'/g, "'\\''")
-				.replace(/\n/g, '\\n')
-			return `drawtext=fontfile=${fontPath}:text='${safeText}':fontcolor=${fontcolor}:fontsize=${t.fontsize}:x=(w-text_w)/2:y=${scrollExpr}:alpha='if(lt(t,${start}),0,if(lt(t,${fadeInEnd}),1,if(lt(t,${fadeOutStart}),1,if(lt(t,${end}),((${end}-t)/${perTextDuration / 3}),0))))':shadowcolor=black:shadowx=4:shadowy=4`
-		})
-
-		const ffmpegPromise = new Promise((resolve, reject) => {
-			ffmpeg = spawn('ffmpeg', [
-				'-f',
-				'lavfi',
-				'-i',
-				`color=c=black:s=1280x720:d=${totalDurationSeconds}`,
-				'-vf',
-				drawtexts.join(','),
-				'-c:v',
-				'libx264',
-				'-preset',
-				'ultrafast',
-				'-crf',
-				'18',
-				'-pix_fmt',
-				'yuv420p',
-				'-y',
-				outputFile,
-			])
-
-			if (ffmpeg.stderr) {
-				ffmpeg.stderr.on('data', (data) => {
-					const str = data.toString()
-					const timeMatch = str.match(/time=(\d{2}):(\d{2}):(\d{2})\.(\d{2})/)
-					if (timeMatch) {
-						const hours = Number(timeMatch[1])
-						const minutes = Number(timeMatch[2])
-						const seconds = Number(timeMatch[3])
-						const fraction = Number(timeMatch[4])
-						const currentSeconds =
-							hours * 3600 + minutes * 60 + seconds + fraction / 100
-						const progress = Math.min(currentSeconds / totalDurationSeconds, 1)
-						onProgress(progress)
-					}
-				})
-			}
-
-			ffmpeg.on('close', (code) => {
-				if (signal.aborted) {
-					reject(new Error('Cancelled'))
-				} else if (code === 0) resolve(undefined)
-				else reject(new Error(`ffmpeg exited with code ${code}`))
-			})
-		})
-
-		await ffmpegPromise
-
-		const videoUri = `epicme://videos/wrapped-${year}`
-		return videoUri
-	} finally {
-		signal.removeEventListener('abort', onAbort)
-	}
-}