@editframe/vite-plugin 0.5.0-beta.2

package/dist/assets/Probe.mjs

@@ -0,0 +1,176 @@
+import { spawn } from "child_process";
+import { execPromise } from "../util/execPromise.mjs";
+import * as z from "zod";
+import { createReadStream } from "fs";
+const AudioStreamSchema = z.object({
+  index: z.number(),
+  codec_name: z.string(),
+  codec_long_name: z.string(),
+  codec_type: z.literal("audio"),
+  codec_tag_string: z.string(),
+  codec_tag: z.string(),
+  sample_fmt: z.string(),
+  sample_rate: z.string(),
+  channels: z.number(),
+  channel_layout: z.string(),
+  bits_per_sample: z.number(),
+  initial_padding: z.number().optional(),
+  r_frame_rate: z.string(),
+  avg_frame_rate: z.string(),
+  time_base: z.string(),
+  start_pts: z.number(),
+  start_time: z.coerce.number(),
+  duration_ts: z.number(),
+  duration: z.coerce.number(),
+  bit_rate: z.string(),
+  disposition: z.record(z.unknown())
+});
+const VideoStreamSchema = z.object({
+  index: z.number(),
+  codec_name: z.string(),
+  codec_long_name: z.string(),
+  codec_type: z.literal("video"),
+  codec_tag_string: z.string(),
+  codec_tag: z.string(),
+  width: z.number(),
+  height: z.number(),
+  coded_width: z.number(),
+  coded_height: z.number(),
+  r_frame_rate: z.string(),
+  avg_frame_rate: z.string(),
+  time_base: z.string(),
+  start_pts: z.number().optional(),
+  start_time: z.coerce.number().optional(),
+  duration_ts: z.number().optional(),
+  duration: z.coerce.number().optional(),
+  bit_rate: z.string().optional(),
+  disposition: z.record(z.unknown())
+});
+const ProbeFormatSchema = z.object({
+  filename: z.string(),
+  nb_streams: z.number(),
+  nb_programs: z.number(),
+  format_name: z.string(),
+  format_long_name: z.string(),
+  start_time: z.string().optional(),
+  duration: z.string().optional(),
+  size: z.string(),
+  bit_rate: z.string().optional(),
+  probe_score: z.number()
+});
+const StreamSchema = z.discriminatedUnion("codec_type", [
+  AudioStreamSchema,
+  VideoStreamSchema
+]);
+const ProbeSchema = z.object({
+  streams: z.array(StreamSchema),
+  format: ProbeFormatSchema
+});
+class Probe {
+  constructor(absolutePath, rawData) {
+    this.absolutePath = absolutePath;
+    this.data = ProbeSchema.parse(rawData);
+  }
+  static async probePath(absolutePath) {
+    const probeResult = await execPromise(
+      `ffprobe -v error -show_format -show_streams -of json ${absolutePath}`
+    );
+    const json = JSON.parse(probeResult.stdout);
+    return new Probe(absolutePath, json);
+  }
+  get audioStreams() {
+    return this.data.streams.filter(
+      (stream) => stream.codec_type === "audio"
+    );
+  }
+  get videoStreams() {
+    return this.data.streams.filter(
+      (stream) => stream.codec_type === "video"
+    );
+  }
+  get streams() {
+    return this.data.streams;
+  }
+  get format() {
+    return this.data.format;
+  }
+  get mustReencodeAudio() {
+    return this.audioStreams.some((stream) => stream.codec_name !== "aac");
+  }
+  get mustReencodeVideo() {
+    return false;
+  }
+  get mustRemux() {
+    return this.format.format_name !== "mp4";
+  }
+  get hasAudio() {
+    return this.audioStreams.length > 0;
+  }
+  get hasVideo() {
+    return this.videoStreams.length > 0;
+  }
+  get isAudioOnly() {
+    return this.audioStreams.length > 0 && this.videoStreams.length === 0;
+  }
+  get isVideoOnly() {
+    return this.audioStreams.length === 0 && this.videoStreams.length > 0;
+  }
+  get mustProcess() {
+    return this.mustReencodeAudio || this.mustReencodeVideo || this.mustRemux;
+  }
+  get ffmpegAudioOptions() {
+    if (!this.hasAudio) {
+      return [];
+    }
+    if (this.mustReencodeAudio) {
+      return [
+        "-c:a",
+        "aac",
+        "-b:a",
+        "192k",
+        "-ar",
+        "48000"
+      ];
+    }
+    return ["-c:a", "copy"];
+  }
+  get ffmpegVideoOptions() {
+    if (!this.hasVideo) {
+      return [];
+    }
+    if (this.mustReencodeVideo) {
+      return [
+        "-c:v",
+        "h264",
+        "-pix_fmt",
+        "yuv420p"
+      ];
+    }
+    return ["-c:v", "copy"];
+  }
+  createConformingReadstream() {
+    if (!this.mustProcess) {
+      return createReadStream(this.absolutePath);
+    }
+    return spawn("ffmpeg", [
+      "-i",
+      this.absolutePath,
+      ...this.ffmpegAudioOptions,
+      ...this.ffmpegVideoOptions,
+      "-f",
+      "mp4",
+      "-frag_duration",
+      "8000000",
+      "-movflags",
+      "frag_keyframe+empty_moov",
+      "pipe:1"
+    ], {
+      stdio: ["ignore", "pipe", "inherit"]
+    }).stdout;
+  }
+}
+export {
+  AudioStreamSchema,
+  Probe,
+  VideoStreamSchema
+};

package/dist/assets/idempotentTask.mjs

@@ -0,0 +1,57 @@
+import { existsSync, createWriteStream } from "fs";
+import path from "path";
+import { md5FilePath } from "./md5.mjs";
+import debug from "debug";
+import { mkdir, writeFile } from "fs/promises";
+import { Readable } from "stream";
+const idempotentTask = ({
+  label,
+  filename,
+  runner
+}) => {
+  const tasks = {};
+  return async (rootDir, absolutePath, ...args) => {
+    const log = debug(`@ef:${label}`);
+    const md5 = await md5FilePath(absolutePath);
+    const cacheDir = path.join(rootDir, ".cache", md5);
+    log(`Cache dir: ${cacheDir}`);
+    await mkdir(cacheDir, { recursive: true });
+    const cachePath = path.join(cacheDir, filename(absolutePath, ...args));
+    const key = cachePath;
+    if (existsSync(cachePath)) {
+      log(`Returning cached @ef:${label} task for ${key}`);
+      return { cachePath, md5Sum: md5 };
+    }
+    const maybeTask = tasks[key];
+    if (maybeTask) {
+      log(`Returning existing @ef:${label} task for ${key}`);
+      await maybeTask;
+      return { cachePath, md5Sum: md5 };
+    }
+    log(`Creating new @ef:${label} task for ${key}`);
+    const task = runner(absolutePath, ...args);
+    tasks[key] = task;
+    log(`Awaiting task for ${key}`);
+    const result = await task;
+    if (result instanceof Readable) {
+      log(`Piping task for ${key} to cache`);
+      const writeStream = createWriteStream(cachePath);
+      result.pipe(writeStream);
+      await new Promise((resolve, reject) => {
+        result.on("error", reject);
+        writeStream.on("error", reject);
+        writeStream.on("finish", resolve);
+      });
+      return { cachePath, md5Sum: md5 };
+    }
+    log(`Writing to ${cachePath}`);
+    await writeFile(cachePath, result);
+    return {
+      md5Sum: md5,
+      cachePath
+    };
+  };
+};
+export {
+  idempotentTask
+};

package/dist/assets/md5.mjs

@@ -0,0 +1,28 @@
+import { createReadStream } from "fs";
+import crypto from "crypto";
+async function md5FilePath(filePath) {
+  const readStream = createReadStream(filePath);
+  return md5ReadStream(readStream);
+}
+function md5ReadStream(readStream) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash("md5");
+    readStream.on("data", (data) => {
+      hash.update(data);
+    });
+    readStream.on("error", reject);
+    readStream.on("end", () => {
+      resolve(addDashesToUUID(hash.digest("hex")));
+    });
+  });
+}
+function addDashesToUUID(uuidWithoutDashes) {
+  if (uuidWithoutDashes.length !== 32) {
+    throw new Error("Invalid UUID without dashes. Expected 32 characters.");
+  }
+  return uuidWithoutDashes.slice(0, 8) + "-" + uuidWithoutDashes.slice(8, 12) + "-" + uuidWithoutDashes.slice(12, 16) + "-" + uuidWithoutDashes.slice(16, 20) + "-" + uuidWithoutDashes.slice(20, 32);
+}
+export {
+  md5FilePath,
+  md5ReadStream
+};

package/dist/assets/mp4FileWritable.mjs

@@ -0,0 +1,21 @@
+import { Writable } from "stream";
+const mp4FileWritable = (mp4File) => {
+  let arrayBufferStart = 0;
+  return new Writable({
+    write: (chunk, _encoding, callback) => {
+      const mp4BoxBuffer = chunk.buffer;
+      mp4BoxBuffer.fileStart = arrayBufferStart;
+      arrayBufferStart += chunk.length;
+      mp4File.appendBuffer(mp4BoxBuffer, false);
+      callback();
+    },
+    final: (callback) => {
+      mp4File.flush();
+      mp4File.processSamples(true);
+      callback();
+    }
+  });
+};
+export {
+  mp4FileWritable
+};

package/dist/assets/tasks/cacheImage.mjs

@@ -0,0 +1,22 @@
+import { idempotentTask } from "../idempotentTask.mjs";
+import { createReadStream } from "fs";
+import path from "path";
+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 generating track fragment index", error);
+    throw error;
+  }
+};
+export {
+  cacheImage
+};

package/dist/assets/tasks/findOrCreateCaptions.mjs

@@ -0,0 +1,26 @@
+import { execPromise } from "../../util/execPromise.mjs";
+import { idempotentTask } from "../idempotentTask.mjs";
+import debug from "debug";
+import { basename } from "path";
+const log = debug("@ef:generateCaptions");
+const generateCaptionData = idempotentTask({
+  label: "captions",
+  filename: (absolutePath) => `${basename(absolutePath)}.captions.json`,
+  runner: 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 findOrCreateCaptions = async (cacheRoot, absolutePath) => {
+  try {
+    return await generateCaptionData(cacheRoot, absolutePath);
+  } catch (error) {
+    console.trace("Error finding or creating captions", error);
+    throw error;
+  }
+};
+export {
+  findOrCreateCaptions
+};

package/dist/assets/tasks/generateTrack.mjs

@@ -0,0 +1,52 @@
+import { idempotentTask } from "../idempotentTask.mjs";
+import { MP4File } from "../../editor/util/MP4File.mjs";
+import debug from "debug";
+import { mp4FileWritable } from "../mp4FileWritable.mjs";
+import { PassThrough } from "stream";
+import { basename } from "path";
+import { Probe } from "../Probe.mjs";
+const generateTrackTask = idempotentTask({
+  label: "track",
+  filename: (absolutePath, trackId) => `${basename(absolutePath)}.track-${trackId}.mp4`,
+  runner: async (absolutePath, trackId) => {
+    const log = debug("@ef:generateTrackFragment");
+    const probe = await Probe.probePath(absolutePath);
+    const readStream = probe.createConformingReadstream();
+    const mp4File = new MP4File();
+    log(`Generating track fragment index for ${absolutePath}`);
+    readStream.pipe(mp4FileWritable(mp4File));
+    await new Promise((resolve, reject) => {
+      readStream.on("end", resolve);
+      readStream.on("error", reject);
+    });
+    const trackStream = new PassThrough();
+    for await (const fragment of mp4File.fragmentIterator()) {
+      if (fragment.track !== trackId) {
+        continue;
+      }
+      trackStream.write(Buffer.from(fragment.data), "binary");
+    }
+    trackStream.end();
+    return trackStream;
+  }
+});
+const generateTrack = async (cacheRoot, absolutePath, url) => {
+  try {
+    const trackId = new URL(
+      `http://localhost${url}` ?? "bad-url"
+    ).searchParams.get("trackId");
+    if (trackId === null) {
+      throw new Error(
+        "No trackId provided. IT must be specified in the query string: ?trackId=0"
+      );
+    }
+    return await generateTrackTask(cacheRoot, absolutePath, Number(trackId));
+  } catch (error) {
+    console.error(error);
+    console.trace("Error generating track fragment index", error);
+    throw error;
+  }
+};
+export {
+  generateTrack
+};

package/dist/assets/tasks/generateTrackFragmentIndex.mjs

@@ -0,0 +1,71 @@
+import { idempotentTask } from "../idempotentTask.mjs";
+import { MP4File } from "../../editor/util/MP4File.mjs";
+import debug from "debug";
+import { mp4FileWritable } from "../mp4FileWritable.mjs";
+import { basename } from "path";
+import { Probe } from "../Probe.mjs";
+const generateTrackFragmentIndexFromPath = async (absolutePath) => {
+  const log = debug("@ef:generateTrackFragment");
+  const probe = await Probe.probePath(absolutePath);
+  const readStream = probe.createConformingReadstream();
+  const mp4File = new MP4File();
+  log(`Generating track fragment index for ${absolutePath}`);
+  readStream.pipe(mp4FileWritable(mp4File));
+  await new Promise((resolve, reject) => {
+    readStream.on("end", resolve);
+    readStream.on("error", reject);
+  });
+  const trackFragmentIndexes = {};
+  const trackByteOffsets = {};
+  for await (const fragment of mp4File.fragmentIterator()) {
+    const track = mp4File.getInfo().tracks.find((track2) => track2.id === fragment.track);
+    if (!track) {
+      throw new Error("Track not found");
+    }
+    if (fragment.segment === "init") {
+      trackByteOffsets[fragment.track] = fragment.data.byteLength;
+      trackFragmentIndexes[fragment.track] = {
+        track: fragment.track,
+        type: track?.type ?? "video",
+        timescale: track.timescale,
+        duration: 0,
+        initSegment: {
+          offset: 0,
+          size: fragment.data.byteLength
+        },
+        segments: []
+      };
+    } else {
+      const fragmentIndex = trackFragmentIndexes[fragment.track];
+      if (!fragmentIndex) {
+        throw new Error("Fragment index not found");
+      }
+      fragmentIndex.duration += fragment.duration;
+      fragmentIndex.segments.push({
+        cts: fragment.cts,
+        dts: fragment.dts,
+        duration: fragment.duration,
+        offset: trackByteOffsets[fragment.track],
+        size: fragment.data.byteLength
+      });
+      trackByteOffsets[fragment.track] += fragment.data.byteLength;
+    }
+  }
+  return JSON.stringify(trackFragmentIndexes, null, 2);
+};
+const generateTrackFragmentIndexTask = idempotentTask({
+  label: "trackFragmentIndex",
+  filename: (absolutePath) => `${basename(absolutePath)}.tracks.json`,
+  runner: generateTrackFragmentIndexFromPath
+});
+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
+};

package/dist/editor/util/MP4File.mjs

@@ -0,0 +1,161 @@
+import * as MP4Box from "mp4box";
+class MP4File extends MP4Box.ISOFile {
+  constructor() {
+    super(...arguments);
+    this.readyPromise = new Promise((resolve, reject) => {
+      this.onReady = () => resolve();
+      this.onError = reject;
+    });
+    this.waitingForSamples = [];
+    this._hasSeenLastSamples = false;
+    this._arrayBufferFileStart = 0;
+  }
+  setSegmentOptions(id, user, options) {
+    const trak = this.getTrackById(id);
+    if (trak) {
+      trak.nextSample = 0;
+      this.fragmentedTracks.push({
+        id,
+        user,
+        trak,
+        segmentStream: null,
+        nb_samples: "nbSamples" in options && options.nbSamples || 1e3,
+        rapAlignement: ("rapAlignement" in options && options.rapAlignement) ?? true
+      });
+    }
+  }
+  /**
+   * Fragments all tracks in a file into separate array buffers.
+   */
+  async fragmentAllTracks() {
+    let trackBuffers = {};
+    for await (const segment of this.fragmentIterator()) {
+      (trackBuffers[segment.track] ??= []).push(segment.data);
+    }
+    return trackBuffers;
+  }
+  async *fragmentIterator() {
+    await this.readyPromise;
+    const trackInfo = {};
+    for (const videoTrack of this.getInfo().videoTracks) {
+      trackInfo[videoTrack.id] = { index: 0, complete: false };
+      this.setSegmentOptions(videoTrack.id, null, {
+        rapAlignement: true
+      });
+    }
+    for (const audioTrack of this.getInfo().audioTracks) {
+      trackInfo[audioTrack.id] = { index: 0, complete: false };
+      const sampleRate = audioTrack.audio.sample_rate;
+      const probablePacketSize = 1024;
+      const probableFourSecondsOfSamples = Math.ceil(
+        sampleRate / probablePacketSize * 4
+      );
+      this.setSegmentOptions(audioTrack.id, null, {
+        nbSamples: probableFourSecondsOfSamples
+      });
+    }
+    const initSegments = this.initializeSegmentation();
+    for (const initSegment of initSegments) {
+      yield {
+        track: initSegment.id,
+        segment: "init",
+        data: initSegment.buffer,
+        complete: false
+      };
+    }
+    const fragmentStartSamples = {};
+    let finishedReading = false;
+    const allTracksFinished = () => {
+      for (const fragmentedTrack of this.fragmentedTracks) {
+        if (!trackInfo[fragmentedTrack.id]?.complete) {
+          return false;
+        }
+      }
+      return true;
+    };
+    while (!(finishedReading && allTracksFinished())) {
+      for (const fragTrak of this.fragmentedTracks) {
+        const trak = fragTrak.trak;
+        if (trak.nextSample === void 0) {
+          throw new Error("trak.nextSample is undefined");
+        }
+        if (trak.samples === void 0) {
+          throw new Error("trak.samples is undefined");
+        }
+        eachSample:
+          while (trak.nextSample < trak.samples.length) {
+            let result = void 0;
+            if (trak?.samples[trak.nextSample]) {
+              fragmentStartSamples[fragTrak.id] ||= trak.samples[trak.nextSample];
+            }
+            try {
+              result = this.createFragment(
+                fragTrak.id,
+                trak.nextSample,
+                fragTrak.segmentStream
+              );
+            } catch (error) {
+              console.log("Failed to createFragment", error);
+            }
+            if (result) {
+              fragTrak.segmentStream = result;
+              trak.nextSample++;
+            } else {
+              finishedReading = await this.waitForMoreSamples();
+              break eachSample;
+            }
+            const nextSample = trak.samples[trak.nextSample];
+            const emitSegment = (
+              // if rapAlignement is true, we emit a fragment when we have a rap sample coming up next
+              fragTrak.rapAlignement === true && nextSample?.is_sync || // if rapAlignement is false, we emit a fragment when we have the required number of samples
+              !fragTrak.rapAlignement && trak.nextSample % fragTrak.nb_samples === 0 || // // if this is the last sample, we emit the fragment
+              // finished ||
+              // if we have more samples than the number of samples requested, we emit the fragment
+              trak.nextSample >= trak.samples.length
+            );
+            if (emitSegment) {
+              if (trak.nextSample >= trak.samples.length) {
+                trackInfo[fragTrak.id].complete = true;
+              }
+              const startSample = fragmentStartSamples[fragTrak.id];
+              const endSample = trak.samples[trak.nextSample - 1];
+              if (!startSample || !endSample) {
+                throw new Error("startSample or endSample is undefined");
+              }
+              yield {
+                track: fragTrak.id,
+                segment: trackInfo[fragTrak.id].index,
+                data: fragTrak.segmentStream.buffer,
+                complete: trackInfo[fragTrak.id].complete,
+                cts: startSample.cts,
+                dts: startSample.dts,
+                duration: endSample.dts - startSample.dts + endSample.duration
+              };
+              trackInfo[fragTrak.id].index += 1;
+              fragTrak.segmentStream = null;
+              delete fragmentStartSamples[fragTrak.id];
+            }
+          }
+      }
+      finishedReading = await this.waitForMoreSamples();
+    }
+  }
+  waitForMoreSamples() {
+    if (this._hasSeenLastSamples) {
+      return Promise.resolve(true);
+    }
+    return new Promise((resolve) => {
+      this.waitingForSamples.push(resolve);
+    });
+  }
+  processSamples(last) {
+    this._hasSeenLastSamples = last;
+    for (const observer of this.waitingForSamples) {
+      observer(last);
+    }
+    this.waitingForSamples = [];
+  }
+}
+export {
+  MP4File
+};

package/dist/util/execPromise.mjs

@@ -0,0 +1,6 @@
+import { exec } from "child_process";
+import { promisify } from "util";
+const execPromise = promisify(exec);
+export {
+  execPromise
+};

package/dist/vite-plugin/src/forbidRelativePaths.mjs

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

package/dist/vite-plugin/src/sendTaskResult.mjs

@@ -0,0 +1,54 @@
+import { statSync, createReadStream } from "fs";
+import mime from "mime";
+import debug from "debug";
+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) {
+      let [x, y] = req.headers.range.replace("bytes=", "").split("-");
+      let end = parseInt(y ?? "0", 10) || stats.size - 1;
+      let start = 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",
+        "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",
+        "Contetn-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/dist/vite-plugin/src/vite-plugin-editframe.mjs

@@ -0,0 +1,69 @@
+import path from "path";
+import debug from "debug";
+import { findOrCreateCaptions } from "../../assets/tasks/findOrCreateCaptions.mjs";
+import { generateTrackFragmentIndex } from "../../assets/tasks/generateTrackFragmentIndex.mjs";
+import { generateTrack } from "../../assets/tasks/generateTrack.mjs";
+import { cacheImage } from "../../assets/tasks/cacheImage.mjs";
+import { md5FilePath } from "../../assets/md5.mjs";
+import { forbidRelativePaths } from "./forbidRelativePaths.mjs";
+import { sendTaskResult } from "./sendTaskResult.mjs";
+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(new RegExp("^/@ef-[^/]+/"), "");
+        const assetPath = requestPath.replace(/\?.*$/, "");
+        const absolutePath = 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-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/docker-compose.yaml

@@ -0,0 +1,17 @@
+
+services:
+  build-vite-plugin:
+    image: telecine-runner
+    depends_on:
+      - runner
+    working_dir: /app
+    env_file:
+      - ${PWD}/.env
+    volumes_from:
+      - runner
+    stop_grace_period: 1s
+    init: true
+    scale: 1
+    environment:
+      - SHELL=/bin/sh
+    command: npx vite build --config lib/vite-plugin/vite.config.ts lib/vite-plugin/src/vite-plugin-editframe.ts --watch

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@editframe/vite-plugin",
+  "version": "0.5.0-beta.2",
+  "description": "Editframe vite plugin",
+  "exports": {
+    ".": "./dist/vite-plugin/src/vite-plugin-editframe.mjs"
+  },
+  "scripts": {
+    "build": "vite build"
+  },
+  "author": "",
+  "license": "UNLICENSED",
+  "dependencies": {
+    "debug": "^4.3.4",
+    "mime": "^4.0.3",
+    "node-html-parser": "^6.1.13",
+    "vite": "^5.2.11"
+  },
+  "devDependencies": {
+    "connect": "^3.7.0"
+  }
+}

package/src/forbidRelativePaths.ts

@@ -0,0 +1,7 @@
+import type { IncomingMessage } from "connect";
+
+export const forbidRelativePaths = (req: IncomingMessage) => {
+  if (req.url?.includes("..")) {
+    throw new Error("Relative paths are forbidden");
+  }
+};

package/src/sendTaskResult.ts

@@ -0,0 +1,65 @@
+import { createReadStream, statSync } from "fs";
+import type { ServerResponse } from "http";
+
+import mime from "mime";
+import debug from "debug";
+import type { IncomingMessage } from "connect";
+
+import type { TaskResult } from "@/assets/idempotentTask";
+
+export const sendTaskResult = (
+  req: IncomingMessage,
+  res: ServerResponse<IncomingMessage>,
+  taskResult: 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) {
+      let [x, y] = req.headers.range.replace("bytes=", "").split("-");
+      let end = parseInt(y ?? "0", 10) || stats.size - 1;
+      let start = 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",
+        "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",
+        "Contetn-Length": stats.size,
+      });
+      log(`Sending ${filePath}`);
+      const readStream = createReadStream(filePath);
+      readStream.pipe(res);
+    }
+  } catch (error) {
+    log("Error sending file", error);
+    console.error(error);
+  }
+};

package/src/vite-plugin-editframe.ts

@@ -0,0 +1,95 @@
+import path from "path";
+
+import { Plugin } from "vite";
+import debug from "debug";
+
+import { findOrCreateCaptions } from "@/assets/tasks/findOrCreateCaptions";
+import { generateTrackFragmentIndex } from "@/assets/tasks/generateTrackFragmentIndex";
+import { generateTrack } from "@/assets/tasks/generateTrack";
+import { cacheImage } from "@/assets/tasks/cacheImage";
+import { md5FilePath } from "@/assets/md5";
+
+import { forbidRelativePaths } from "./forbidRelativePaths";
+import { sendTaskResult } from "./sendTaskResult";
+
+interface VitePluginEditframeOptions {
+  root: string;
+  cacheRoot: string;
+}
+
+export const vitePluginEditframe = (options: VitePluginEditframeOptions) => {
+  return {
+    name: "vite-plugin-editframe",
+
+    configureServer(server) {
+      server.middlewares.use(async (req, res, next) => {
+        const log = debug("@ef:vite-plugin");
+        // Forbid relative paths in any request
+        if (req.url?.startsWith("/@ef")) {
+          forbidRelativePaths(req);
+        } else {
+          return next();
+        }
+
+        log(`Handling ${req.url}`);
+
+        const requestPath = req.url.replace(new RegExp("^/@ef-[^/]+/"), "");
+        const assetPath = requestPath.replace(/\?.*$/, "");
+        const absolutePath = 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-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;
+        }
+      });
+    },
+  } satisfies Plugin;
+};

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "ES2015",
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules"],
+  "extends": "../../tsconfig.json"
+}

package/vite.config.ts

@@ -0,0 +1,41 @@
+import path from "path";
+import { defineConfig } from "vite";
+import tsconfigPaths from "vite-tsconfig-paths";
+import rollupTsConfigPaths from "rollup-plugin-tsconfig-paths";
+
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+
+export default defineConfig({
+  esbuild: {
+    target: "es2022",
+    platform: "browser",
+    include: /\.(m?[jt]s|[jt]sx)$/,
+    exclude: [],
+  },
+  plugins: [tsconfigPaths()],
+  appType: "custom",
+  root: __dirname,
+  css: {
+    postcss: __dirname,
+  },
+  build: {
+    ssr: true,
+    target: "es2022",
+    rollupOptions: {
+      treeshake: "recommended",
+      output: {
+        inlineDynamicImports: false,
+        preserveModules: true,
+      },
+      plugins: [rollupTsConfigPaths({})],
+    },
+    emptyOutDir: true,
+    outDir: path.join(__dirname, "dist/"),
+    lib: {
+      entry: path.join(__dirname, "src", "vite-plugin-editframe.ts"),
+      name: "vite-plugin-editframe",
+      fileName: "vite-plugin-editframe",
+      formats: ["es"],
+    },
+  },
+});