@mcptoolshop/toolshopstudio 1.1.0-toolshop

package/smoke.mjs

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+
+/**
+ * Smoke test: runs the full pipeline with mocked ffmpeg/ffprobe.
+ * No real binaries needed — validates the wiring end-to-end.
+ *
+ * Usage: node smoke.mjs
+ */
+
+import { existsSync } from "node:fs";
+import {
+  transcodeForYouTube,
+  createInMemoryCRUD,
+  generateYouTubeThumbnail,
+  pandoc,
+} from "./dist/index.js";
+
+const MOCK_PROBE = {
+  streams: [
+    {
+      codec_name: "h264",
+      codec_type: "video",
+      width: 1920,
+      height: 1080,
+      pix_fmt: "yuv420p",
+      field_order: "progressive",
+      profile: "High",
+    },
+    {
+      codec_name: "aac",
+      codec_type: "audio",
+      channels: 2,
+      sample_rate: "48000",
+    },
+  ],
+  format: {
+    filename: "/data/sandbox/smoke/input.mp4",
+    format_name: "mov,mp4,m4a,3gp,3g2,mj2",
+    duration: "15.0",
+    size: "5000000",
+    bit_rate: "2666666",
+  },
+};
+
+async function main() {
+  console.log("=== ToolShopStudio Smoke Test ===\n");
+
+  const crud = createInMemoryCRUD();
+  const notifications = [];
+  const ac = new AbortController();
+
+  // ── Test 1: SDR 1080p transcode ──────────────────────────────
+  console.log("[1] SDR 1080p transcode...");
+  const asset = await transcodeForYouTube(
+    {
+      inputPath: "/data/sandbox/smoke/input.mp4",
+      outputPath: "/data/sandbox/smoke/output.mp4",
+      preset: "yt-1080p-h264",
+      allowFallback: true,
+      timeoutSeconds: 60,
+    },
+    {
+      signal: ac.signal,
+      userId: "smoke",
+      notify: (n) => notifications.push(n),
+      createAsset: (a) => crud.create(a),
+      runFfmpeg: async (_flags, _signal, onProgress) => {
+        onProgress(25);
+        onProgress(50);
+        onProgress(75);
+        onProgress(100);
+      },
+      runProbe: async () => MOCK_PROBE,
+    },
+  );
+
+  console.log(`  Asset ID: ${asset.id}`);
+  console.log(`  Warnings: ${asset.warnings.length}`);
+  console.log(`  Notifications: ${notifications.length}`);
+
+  // Verify CRUD
+  const stored = await crud.read(asset.id);
+  if (!stored) throw new Error("CRUD read failed");
+  console.log("  CRUD read: OK");
+
+  const listed = await crud.list();
+  if (listed.length !== 1) throw new Error("CRUD list failed");
+  console.log("  CRUD list: OK");
+
+  // ── Test 2: Shorts preset ──────────────────────────────────
+  console.log("\n[2] Shorts H264 transcode...");
+  const shortsAsset = await transcodeForYouTube(
+    {
+      inputPath: "/data/sandbox/smoke/short.mp4",
+      outputPath: "/data/sandbox/smoke/short_out.mp4",
+      preset: "yt-shorts-h264",
+    },
+    {
+      signal: ac.signal,
+      userId: "smoke",
+      notify: () => {},
+      createAsset: (a) => crud.create(a),
+      runFfmpeg: async (_flags, _signal, onProgress) => {
+        onProgress(100);
+      },
+      runProbe: async () => MOCK_PROBE,
+    },
+  );
+  console.log(`  Asset ID: ${shortsAsset.id}`);
+  console.log("  OK");
+
+  // ── Test 3: Verify ready notification shape ──────────────────
+  console.log("\n[3] Verify notification shape...");
+  const ready = notifications.find((n) => n.type === "youtube:ready");
+  if (!ready) throw new Error("No youtube:ready notification");
+  if (ready.type !== "youtube:ready") throw new Error("Wrong type");
+  if (!ready.assetId) throw new Error("Missing assetId");
+  if (!ready.outputPath) throw new Error("Missing outputPath");
+  console.log("  youtube:ready shape: OK");
+
+  // ── Test 4: Verify logo asset exists ────────────────────────
+  console.log("\n[4] Verify logo asset...");
+  if (!existsSync("assets/logo.png")) throw new Error("assets/logo.png missing");
+  console.log("  assets/logo.png: OK");
+
+  // ── Test 5: Pandoc blog-post conversion ──────────────────────
+  console.log("\n[5] Pandoc blog-post conversion...");
+  const pandocCrud = pandoc.createPandocCRUD();
+  const pandocNotifications = [];
+
+  const pandocAsset = await pandoc.convertDocument(
+    {
+      inputPath: "/data/sandbox/smoke/doc.md",
+      outputPath: "/data/sandbox/smoke/doc.html",
+      preset: "blog-post",
+    },
+    {
+      signal: ac.signal,
+      userId: "smoke",
+      notify: (n) => pandocNotifications.push(n),
+      createAsset: (a) => pandocCrud.create(a),
+      runPandoc: async (_args, _signal, onProgress) => {
+        onProgress(25);
+        onProgress(50);
+        onProgress(99);
+      },
+      checkInput: async () => ({
+        ok: true,
+        warnings: [],
+        sizeBytes: 2048,
+        detectedFormat: "markdown",
+      }),
+      assertOutput: async () => ({ ok: true, warnings: [] }),
+      statFile: async () => ({ size: 4096 }),
+    },
+  );
+
+  console.log(`  Asset ID: ${pandocAsset.id}`);
+  console.log(`  Preset: ${pandocAsset.preset}`);
+  console.log(`  Output format: ${pandocAsset.outputMetadata.format}`);
+  console.log(`  Output size: ${pandocAsset.outputMetadata.sizeBytes}`);
+
+  // Verify Pandoc CRUD
+  const pandocStored = await pandocCrud.read(pandocAsset.id);
+  if (!pandocStored) throw new Error("Pandoc CRUD read failed");
+  console.log("  Pandoc CRUD read: OK");
+
+  // Verify Pandoc ready notification
+  const pandocReady = pandocNotifications.find((n) => n.type === "pandoc:ready");
+  if (!pandocReady) throw new Error("No pandoc:ready notification");
+  if (!pandocReady.assetId) throw new Error("Missing pandoc assetId");
+  console.log("  pandoc:ready shape: OK");
+
+  // ── Test 6: Pandoc academic-pdf conversion ─────────────────
+  console.log("\n[6] Pandoc academic-pdf conversion...");
+  const pdfAsset = await pandoc.convertDocument(
+    {
+      inputPath: "/data/sandbox/smoke/thesis.md",
+      outputPath: "/data/sandbox/smoke/thesis.pdf",
+      preset: "academic-pdf",
+    },
+    {
+      signal: ac.signal,
+      userId: "smoke",
+      notify: () => {},
+      createAsset: (a) => pandocCrud.create(a),
+      runPandoc: async (_args, _signal, onProgress) => {
+        onProgress(99);
+      },
+      checkInput: async () => ({
+        ok: true,
+        warnings: [],
+        sizeBytes: 10240,
+        detectedFormat: "markdown",
+      }),
+      assertOutput: async () => ({ ok: true, warnings: [] }),
+      statFile: async () => ({ size: 8192 }),
+    },
+  );
+  console.log(`  Asset ID: ${pdfAsset.id}`);
+  console.log(`  Output format: ${pdfAsset.outputMetadata.format}`);
+  console.log("  OK");
+
+  // Verify both Pandoc assets in CRUD
+  const allPandocAssets = await pandocCrud.list();
+  if (allPandocAssets.length !== 2) throw new Error(`Expected 2 Pandoc assets, got ${allPandocAssets.length}`);
+  console.log("  Pandoc CRUD list (2 assets): OK");
+
+  // ── Summary ──────────────────────────────────────────────────
+  const allAssets = await crud.list();
+  console.log(`\n=== Smoke Test PASSED ===`);
+  console.log(`  FFmpeg assets: ${allAssets.length}`);
+  console.log(`  Pandoc assets: ${allPandocAssets.length}`);
+  console.log(`  FFmpeg notifications: ${notifications.length}`);
+  console.log(`  Pandoc notifications: ${pandocNotifications.length}`);
+}
+
+main().catch((err) => {
+  console.error("\n=== Smoke Test FAILED ===");
+  console.error(err);
+  process.exit(1);
+});

package/src/__snapshots__/engine.test.ts.snap

@@ -0,0 +1,148 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`buildFlags > hdr_pq_4k: produces correct flags for yt-4k-hdr-h265 1`] = `
+[
+  "-i",
+  "/sandbox/user1/hdr_input.mp4",
+  "-movflags",
+  "+faststart",
+  "-avoid_negative_ts",
+  "make_zero",
+  "-fflags",
+  "+genpts",
+  "-video_track_timescale",
+  "90000",
+  "-g",
+  "60",
+  "-keyint_min",
+  "60",
+  "-c:a",
+  "aac",
+  "-ar",
+  "48000",
+  "-ac",
+  "2",
+  "-b:a",
+  "192k",
+  "-vf",
+  "scale=3840:2160:force_original_aspect_ratio=decrease,pad=3840:2160:(ow-iw)/2:(oh-ih)/2",
+  "-c:v",
+  "libx265",
+  "-pix_fmt",
+  "yuv420p10le",
+  "-profile:v",
+  "main10",
+  "-crf",
+  "18",
+  "-maxrate",
+  "40M",
+  "-bufsize",
+  "80M",
+  "-color_primaries",
+  "bt2020",
+  "-color_trc",
+  "smpte2084",
+  "-colorspace",
+  "bt2020nc",
+  "-x265-params",
+  "open-gop=0:scenecut=0",
+  "-progress",
+  "pipe:2",
+  "-y",
+  "/sandbox/user1/hdr_output.mp4",
+]
+`;
+
+exports[`buildFlags > sdr_1080p: produces correct flags for yt-1080p-h264 1`] = `
+[
+  "-i",
+  "/sandbox/user1/input.mp4",
+  "-movflags",
+  "+faststart",
+  "-avoid_negative_ts",
+  "make_zero",
+  "-fflags",
+  "+genpts",
+  "-video_track_timescale",
+  "90000",
+  "-g",
+  "60",
+  "-keyint_min",
+  "60",
+  "-c:a",
+  "aac",
+  "-ar",
+  "48000",
+  "-ac",
+  "2",
+  "-b:a",
+  "192k",
+  "-vf",
+  "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2",
+  "-c:v",
+  "libx264",
+  "-pix_fmt",
+  "yuv420p",
+  "-profile:v",
+  "high",
+  "-crf",
+  "18",
+  "-maxrate",
+  "12M",
+  "-bufsize",
+  "24M",
+  "-x264-params",
+  "keyint=60:min-keyint=60:scenecut=0",
+  "-progress",
+  "pipe:2",
+  "-y",
+  "/sandbox/user1/output.mp4",
+]
+`;
+
+exports[`buildFlags > shorts_sdr_1080x1920: produces correct flags for yt-shorts-h264 1`] = `
+[
+  "-i",
+  "/sandbox/user1/short.mp4",
+  "-movflags",
+  "+faststart",
+  "-avoid_negative_ts",
+  "make_zero",
+  "-fflags",
+  "+genpts",
+  "-video_track_timescale",
+  "90000",
+  "-g",
+  "60",
+  "-keyint_min",
+  "60",
+  "-c:a",
+  "aac",
+  "-ar",
+  "48000",
+  "-ac",
+  "2",
+  "-b:a",
+  "192k",
+  "-vf",
+  "scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2",
+  "-c:v",
+  "libx264",
+  "-pix_fmt",
+  "yuv420p",
+  "-profile:v",
+  "high",
+  "-crf",
+  "18",
+  "-maxrate",
+  "12M",
+  "-bufsize",
+  "24M",
+  "-x264-params",
+  "keyint=60:min-keyint=60:scenecut=0",
+  "-progress",
+  "pipe:2",
+  "-y",
+  "/sandbox/user1/short_out.mp4",
+]
+`;

package/src/build-flags.ts

@@ -0,0 +1,124 @@
+/**
+ * Pure, deterministic ffmpeg flag builder.
+ * YouTube 2026 invariant compliant.
+ *
+ * Takes a transcode request + probe result, returns the full ffmpeg
+ * argv (minus the `ffmpeg` binary itself). No side effects.
+ */
+
+import type { TranscodeForYouTube, ProbeResult } from "./schemas.js";
+import { PRESET_SPECS, buildBaseFlags } from "./preset-spec.js";
+
+/**
+ * Build the complete ffmpeg flag array for a YouTube-safe transcode.
+ *
+ * Order: input → base flags → video filter → codec/pixFmt/profile/crf/maxrate →
+ *        HDR tags → customBitrate override → closed-GOP params → -y output
+ */
+export function buildFlags(
+  req: TranscodeForYouTube,
+  probe: ProbeResult,
+): string[] {
+  const spec = PRESET_SPECS[req.preset];
+  const flags: string[] = [];
+
+  // ── Input ───────────────────────────────────────────────────────
+  flags.push("-i", req.inputPath);
+
+  // ── Base invariants ─────────────────────────────────────────────
+  flags.push(...buildBaseFlags());
+
+  // ── Video filter (orientation-aware) ────────────────────────────
+  flags.push("-vf", resolveVf(spec.vf, req.orientationHint, probe));
+
+  // ── Codec, pixel format, profile, CRF, rate control ─────────────
+  flags.push("-c:v", spec.codec);
+  flags.push("-pix_fmt", spec.pixFmt);
+  flags.push("-profile:v", spec.profile);
+  flags.push("-crf", String(spec.crf));
+  flags.push("-maxrate", spec.maxrate);
+  flags.push("-bufsize", spec.bufsize);
+
+  // ── HDR tags (only for HDR presets) ─────────────────────────────
+  if (spec.hdrTags) {
+    for (const [key, value] of Object.entries(spec.hdrTags)) {
+      flags.push(`-${key}`, value);
+    }
+  }
+
+  // ── Custom bitrate override ─────────────────────────────────────
+  if (req.customBitrate?.videoMbps) {
+    flags.push("-b:v", `${req.customBitrate.videoMbps}M`);
+  }
+  if (req.customBitrate?.audioBitrate) {
+    flags.push("-b:a", req.customBitrate.audioBitrate);
+  }
+
+  // ── Closed-GOP encoder params ───────────────────────────────────
+  if (spec.codec === "libx264" && spec.x264Params) {
+    flags.push("-x264-params", spec.x264Params);
+  }
+  if (spec.codec === "libx265" && spec.x265Params) {
+    flags.push("-x265-params", spec.x265Params);
+  }
+
+  // ── Progress pipe (stderr key=value parsing) ────────────────────
+  flags.push("-progress", "pipe:2");
+
+  // ── Output (overwrite) ──────────────────────────────────────────
+  flags.push("-y", req.outputPath);
+
+  return flags;
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────
+
+/**
+ * Resolve the video filter string. If an orientationHint is given
+ * and differs from the spec's default, swap width/height in the
+ * scale+pad chain. Otherwise use the spec's vf as-is.
+ */
+function resolveVf(
+  specVf: string,
+  orientationHint: TranscodeForYouTube["orientationHint"],
+  _probe: ProbeResult,
+): string {
+  if (!orientationHint) return specVf;
+
+  // Parse the spec's scale dimensions from the vf string
+  const scaleMatch = specVf.match(
+    /scale=(\d+):(\d+):force_original_aspect_ratio=decrease,pad=(\d+):(\d+)/,
+  );
+  if (!scaleMatch) return specVf;
+
+  const [, sw, sh, pw, ph] = scaleMatch;
+  const specW = Number(sw);
+  const specH = Number(sh);
+  const specIsLandscape = specW > specH;
+
+  const wantLandscape = orientationHint === "landscape";
+  const wantPortrait = orientationHint === "portrait";
+  const wantSquare = orientationHint === "square";
+
+  // If hint matches spec orientation, no change needed
+  if ((wantLandscape && specIsLandscape) || (wantPortrait && !specIsLandscape)) {
+    return specVf;
+  }
+
+  // Swap dimensions for orientation mismatch
+  if ((wantPortrait && specIsLandscape) || (wantLandscape && !specIsLandscape)) {
+    return specVf
+      .replace(`scale=${sw}:${sh}`, `scale=${sh}:${sw}`)
+      .replace(`pad=${pw}:${ph}`, `pad=${ph}:${pw}`);
+  }
+
+  // Square: use min dimension for both
+  if (wantSquare) {
+    const dim = Math.min(specW, specH);
+    return specVf
+      .replace(`scale=${sw}:${sh}`, `scale=${dim}:${dim}`)
+      .replace(`pad=${pw}:${ph}`, `pad=${dim}:${dim}`);
+  }
+
+  return specVf;
+}

package/src/crud.ts

@@ -0,0 +1,89 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+import type { YouTubeMediaAsset } from "./schemas.js";
+import type { YouTubeMediaAssetCRUD } from "./types.js";
+
+// ── In-memory CRUD ────────────────────────────────────────────────
+
+/**
+ * Create an in-memory CRUD store. Optionally persists to a JSON file
+ * on every write for dev/debug use.
+ *
+ * @param persistPath - optional path to a JSON file for persistence
+ */
+export function createInMemoryCRUD(
+  persistPath?: string,
+): YouTubeMediaAssetCRUD {
+  const store = new Map<string, YouTubeMediaAsset>();
+
+  async function persist(): Promise<void> {
+    if (!persistPath) return;
+    await mkdir(path.dirname(persistPath), { recursive: true });
+    const data = JSON.stringify(Array.from(store.values()), null, 2);
+    await writeFile(persistPath, data, "utf8");
+  }
+
+  async function hydrate(): Promise<void> {
+    if (!persistPath) return;
+    try {
+      const data = await readFile(persistPath, "utf8");
+      const items: YouTubeMediaAsset[] = JSON.parse(data);
+      for (const item of items) {
+        store.set(item.id, item);
+      }
+    } catch {
+      // File doesn't exist yet — start fresh
+    }
+  }
+
+  // Hydrate on first access (lazy)
+  let hydrated = false;
+  async function ensureHydrated(): Promise<void> {
+    if (!hydrated) {
+      await hydrate();
+      hydrated = true;
+    }
+  }
+
+  return {
+    async create(asset: YouTubeMediaAsset): Promise<YouTubeMediaAsset> {
+      await ensureHydrated();
+      store.set(asset.id, asset);
+      await persist();
+      return asset;
+    },
+
+    async read(id: string): Promise<YouTubeMediaAsset | null> {
+      await ensureHydrated();
+      return store.get(id) ?? null;
+    },
+
+    async list(filter?: { userId?: string }): Promise<YouTubeMediaAsset[]> {
+      await ensureHydrated();
+      const all = Array.from(store.values());
+      // userId filter is a no-op for now (assets don't store userId)
+      return filter?.userId ? all : all;
+    },
+
+    async update(
+      id: string,
+      patch: Partial<YouTubeMediaAsset>,
+    ): Promise<YouTubeMediaAsset> {
+      await ensureHydrated();
+      const existing = store.get(id);
+      if (!existing) throw new Error(`Asset ${id} not found.`);
+      const updated = { ...existing, ...patch, id }; // id is immutable
+      store.set(id, updated);
+      await persist();
+      return updated;
+    },
+
+    async delete(id: string): Promise<void> {
+      await ensureHydrated();
+      if (!store.delete(id)) {
+        throw new Error(`Asset ${id} not found.`);
+      }
+      await persist();
+    },
+  };
+}