@editframe/vite-plugin 0.18.22-beta.0 → 0.18.23-beta.0

package/dist/forbidRelativePaths.js

@@ -0,0 +1,4 @@
+const forbidRelativePaths = (req) => {
+	if (req.url?.includes("..")) throw new Error("Relative paths are forbidden");
+};
+export { forbidRelativePaths };

package/dist/index.js

@@ -0,0 +1,74 @@
+import { forbidRelativePaths } from "./forbidRelativePaths.js";
+import { sendTaskResult } from "./sendTaskResult.js";
+import { rm } from "node:fs/promises";
+import path, { join } from "node:path";
+import { cacheImage, findOrCreateCaptions, generateTrack, generateTrackFragmentIndex, md5FilePath } from "@editframe/assets";
+import debug from "debug";
+const vitePluginEditframe = (options) => {
+	return {
+		name: "vite-plugin-editframe",
+		configureServer(server) {
+			server.middlewares.use(async (req, res, next) => {
+				const log = debug("ef:vite-plugin");
+				if (req.url?.startsWith("/@ef")) forbidRelativePaths(req);
+				else return next();
+				log(`Handling ${req.url}`);
+				const requestPath = req.url.replace(/^\/@ef-[^/]+\//, "");
+				const assetPath = requestPath.replace(/\?.*$/, "");
+				const absolutePath = assetPath.startsWith("http") ? assetPath : path.join(options.root, assetPath).replace("dist/", "src/");
+				options.cacheRoot = options.cacheRoot.replace("dist/", "src/");
+				const efPrefix = req.url.split("/")[1];
+				switch (efPrefix) {
+					case "@ef-clear-cache": {
+						if (req.method !== "DELETE") {
+							res.writeHead(405, { Allow: "DELETE" });
+							res.end();
+							break;
+						}
+						log(`Clearing cache for ${options.cacheRoot}`);
+						await rm(join(options.cacheRoot, ".cache"), {
+							recursive: true,
+							force: true
+						});
+						res.writeHead(200, { "Content-Type": "text/plain" });
+						res.end("Cache cleared");
+						break;
+					}
+					case "@ef-asset": {
+						if (req.method !== "HEAD") {
+							res.writeHead(405, { Allow: "HEAD" });
+							res.end();
+						}
+						md5FilePath(absolutePath).then((md5) => {
+							res.writeHead(200, { etag: md5 });
+							res.end();
+						}).catch(next);
+						break;
+					}
+					case "@ef-track-fragment-index": {
+						log(`Serving track fragment index for ${absolutePath}`);
+						generateTrackFragmentIndex(options.cacheRoot, absolutePath).then((taskResult) => sendTaskResult(req, res, taskResult)).catch(next);
+						break;
+					}
+					case "@ef-track": {
+						log(`Serving track for ${absolutePath}`);
+						generateTrack(options.cacheRoot, absolutePath, req.url).then((taskResult) => sendTaskResult(req, res, taskResult)).catch(next);
+						break;
+					}
+					case "@ef-captions":
+						log(`Serving captions for ${absolutePath}`);
+						findOrCreateCaptions(options.cacheRoot, absolutePath).then((taskResult) => sendTaskResult(req, res, taskResult)).catch(next);
+						break;
+					case "@ef-image":
+						log(`Serving image file ${absolutePath}`);
+						cacheImage(options.cacheRoot, absolutePath).then((taskResult) => sendTaskResult(req, res, taskResult)).catch(next);
+						break;
+					default:
+						log(`Unknown asset type ${efPrefix}`);
+						break;
+				}
+			});
+		}
+	};
+};
+export { vitePluginEditframe };

package/dist/sendTaskResult.js

@@ -0,0 +1,53 @@
+import debug from "debug";
+import { createReadStream, statSync } from "node:fs";
+import mime from "mime";
+const sendTaskResult = (req, res, taskResult) => {
+	const { cachePath, md5Sum } = taskResult;
+	const filePath = cachePath;
+	const headers = { etag: md5Sum };
+	const log = debug("ef:sendfile");
+	try {
+		log(`Sending file ${filePath}`);
+		const stats = statSync(filePath);
+		if (req.headers.range) {
+			const [x, y] = req.headers.range.replace("bytes=", "").split("-");
+			let end = Number.parseInt(y ?? "0", 10) || stats.size - 1;
+			const start = Number.parseInt(x ?? "0", 10) || 0;
+			if (end >= stats.size) end = stats.size - 1;
+			if (start >= stats.size) {
+				log("Range start is greater than file size");
+				res.setHeader("Content-Range", `bytes */${stats.size}`);
+				res.statusCode = 416;
+				return res.end();
+			}
+			res.writeHead(206, {
+				...headers,
+				"Content-Type": mime.getType(filePath) || "text/plain",
+				"Cache-Control": "max-age=3600",
+				"Content-Range": `bytes ${start}-${end}/${stats.size}`,
+				"Content-Length": end - start + 1,
+				"Accept-Ranges": "bytes"
+			});
+			log(`Sending ${filePath} range ${start}-${end}/${stats.size}`);
+			const readStream = createReadStream(filePath, {
+				start,
+				end
+			});
+			readStream.pipe(res);
+		} else {
+			res.writeHead(200, {
+				...headers,
+				"Content-Type": mime.getType(filePath) || "text/plain",
+				"Cache-Control": "max-age=3600",
+				"Content-Length": stats.size
+			});
+			log(`Sending ${filePath}`);
+			const readStream = createReadStream(filePath);
+			readStream.pipe(res);
+		}
+	} catch (error) {
+		log("Error sending file", error);
+		console.error(error);
+	}
+};
+export { sendTaskResult };

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@editframe/vite-plugin",
-  "version": "0.18.22-beta.0",
+  "version": "0.18.23-beta.0",
   "description": "Editframe vite plugin",
   "exports": {
     ".": {
       "import": {
         "types": "./dist/index.d.ts",
-        "default": "./dist/vite-plugin/src/index.js"
+        "default": "./dist/index.js"
       }
     }
   },
@@ -19,7 +19,7 @@
   "author": "",
   "license": "UNLICENSED",
   "dependencies": {
-    "@editframe/assets": "0.18.22-beta.0",
+    "@editframe/assets": "0.18.23-beta.0",
     "connect": "^3.7.0",
     "debug": "^4.3.5",
     "mime": "^4.0.3",

package/dist/assets/src/tasks/cacheImage.js

@@ -1,20 +0,0 @@
-import { idempotentTask } from "../idempotentTask.js";
-import path from "node:path";
-import { createReadStream } from "node:fs";
-const cacheImageTask = idempotentTask({
-	label: "image",
-	filename: (absolutePath) => path.basename(absolutePath),
-	runner: async (absolutePath) => {
-		return createReadStream(absolutePath);
-	}
-});
-const cacheImage = async (cacheRoot, absolutePath) => {
-	try {
-		return await cacheImageTask(cacheRoot, absolutePath);
-	} catch (error) {
-		console.error(error);
-		console.trace("Error caching image", error);
-		throw error;
-	}
-};
-export { cacheImage };

package/dist/assets/src/tasks/findOrCreateCaptions.js

@@ -1,27 +0,0 @@
-import { idempotentTask } from "../idempotentTask.js";
-import { basename } from "node:path";
-import debug from "debug";
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-const execPromise = promisify(exec);
-const log = debug("ef:generateCaptions");
-const generateCaptionDataFromPath = async (absolutePath) => {
-	const command = `whisper_timestamped --language en --efficient --output_format vtt ${absolutePath}`;
-	log(`Running command: ${command}`);
-	const { stdout } = await execPromise(command);
-	return stdout;
-};
-const generateCaptionDataTask = idempotentTask({
-	label: "captions",
-	filename: (absolutePath) => `${basename(absolutePath)}.captions.json`,
-	runner: generateCaptionDataFromPath
-});
-const findOrCreateCaptions = async (cacheRoot, absolutePath) => {
-	try {
-		return await generateCaptionDataTask(cacheRoot, absolutePath);
-	} catch (error) {
-		console.trace("Error finding or creating captions", error);
-		throw error;
-	}
-};
-export { findOrCreateCaptions, generateCaptionDataFromPath };

package/dist/assets/src/tasks/generateTrack.js

@@ -1,27 +0,0 @@
-import { idempotentTask } from "../idempotentTask.js";
-import { generateSingleTrackFromPath } from "../generateSingleTrack.js";
-import { basename } from "node:path";
-import debug from "debug";
-const generateTrackFromPath = async (absolutePath, trackId) => {
-	const log = debug("ef:generateTrackFragment");
-	log(`Generating track ${trackId} for ${absolutePath}`);
-	const result = await generateSingleTrackFromPath(absolutePath, trackId);
-	return result.stream;
-};
-const generateTrackTask = idempotentTask({
-	label: "track",
-	filename: (absolutePath, trackId) => `${basename(absolutePath)}.track-${trackId}.mp4`,
-	runner: generateTrackFromPath
-});
-const generateTrack = async (cacheRoot, absolutePath, url) => {
-	try {
-		const trackId = new URL(`http://localhost${url}`).searchParams.get("trackId");
-		if (trackId === null) throw new Error("No trackId provided. It must be specified in the query string: ?trackId=1 (for video) or ?trackId=2 (for audio)");
-		return await generateTrackTask(cacheRoot, absolutePath, Number(trackId));
-	} catch (error) {
-		console.error(error);
-		console.trace("Error generating track", error);
-		throw error;
-	}
-};
-export { generateTrack, generateTrackFromPath };

package/dist/assets/src/tasks/generateTrackFragmentIndex.js

@@ -1,50 +0,0 @@
-import { Probe } from "../Probe.js";
-import { generateFragmentIndex } from "../generateFragmentIndex.js";
-import { idempotentTask } from "../idempotentTask.js";
-import { basename } from "node:path";
-import debug from "debug";
-const generateTrackFragmentIndexFromPath = async (absolutePath) => {
-	const log = debug("ef:generateTrackFragment");
-	const probe = await Probe.probePath(absolutePath);
-	let startTimeOffsetMs;
-	if (probe.format.start_time && Number(probe.format.start_time) !== 0) {
-		startTimeOffsetMs = Number(probe.format.start_time) * 1e3;
-		log(`Extracted format start_time offset: ${probe.format.start_time}s (${startTimeOffsetMs}ms)`);
-	} else {
-		const videoStream = probe.streams.find((stream) => stream.codec_type === "video");
-		if (videoStream && videoStream.start_time && Number(videoStream.start_time) !== 0) {
-			startTimeOffsetMs = Number(videoStream.start_time) * 1e3;
-			log(`Extracted video stream start_time offset: ${videoStream.start_time}s (${startTimeOffsetMs}ms)`);
-		} else log("No format/stream timing offset found - will detect from composition time");
-	}
-	log(`Generating track fragment index for ${absolutePath} using single-track approach`);
-	const trackFragmentIndexes = {};
-	for (let streamIndex = 0; streamIndex < probe.streams.length; streamIndex++) {
-		const stream = probe.streams[streamIndex];
-		if (stream.codec_type !== "audio" && stream.codec_type !== "video") continue;
-		const trackId = streamIndex + 1;
-		log(`Processing track ${trackId} (${stream.codec_type})`);
-		const trackStream = probe.createTrackReadstream(streamIndex);
-		const trackIdMapping = { 0: trackId };
-		const singleTrackIndexes = await generateFragmentIndex(trackStream, startTimeOffsetMs, trackIdMapping);
-		Object.assign(trackFragmentIndexes, singleTrackIndexes);
-	}
-	return trackFragmentIndexes;
-};
-const generateTrackFragmentIndexTask = idempotentTask({
-	label: "trackFragmentIndex",
-	filename: (absolutePath) => `${basename(absolutePath)}.tracks.json`,
-	runner: async (absolutePath) => {
-		const index = await generateTrackFragmentIndexFromPath(absolutePath);
-		return JSON.stringify(index, null, 2);
-	}
-});
-const generateTrackFragmentIndex = async (cacheRoot, absolutePath) => {
-	try {
-		return await generateTrackFragmentIndexTask(cacheRoot, absolutePath);
-	} catch (error) {
-		console.trace("Error generating track fragment index", error);
-		throw error;
-	}
-};
-export { generateTrackFragmentIndex, generateTrackFragmentIndexFromPath };