videodraft 0.5.0 → 0.7.0

package/README.md

@@ -124,7 +124,7 @@ npx videodraft skills install                  # zero-install: npx fetches the C
 videodraft skills install                      # if the CLI is on PATH — auto-detects your installed agents
 videodraft skills install --agent claude,codex # target specific agents (repeatable/comma; --all for every agent)
 videodraft skills install --project            # into ./.claude/skills for just this repo (else global)
-videodraft skills show                         # print the skill (also: skills show models|examples|pipeline|--all)
+videodraft skills show                         # print the skill (also: skills show editor|models|examples|pipeline|--all)
 
 # Or install straight from the repo — no CLI on PATH needed first:
 npx -y skills add videodraft-ai/cli -g         # vercel-labs skills tool; npx -y skips npx's install prompt; -g = user scope

package/dist/client.d.ts

@@ -217,6 +217,12 @@ interface DownloadedFile {
     url: string;
     path: string;
     bytes: number;
+    /** Downscaled view copy in <dir>/previews/ (images over the size threshold
+     *  only). Agents should inspect this instead of the full-res original —
+     *  every full-res image an agent views is re-sent with each later message
+     *  of its chat. Best-effort: absent when preview generation failed or was
+     *  skipped. The original at `path` is always the deliverable. */
+    preview?: string;
 }
 declare function extFromUrl(url: string, fallback?: string): string;
 declare function renderTemplate(template: string, vars: {

package/dist/client.js

@@ -818,10 +818,136 @@ async function pollGenerations(client, jobIds, options = {}) {
 }
 
 // src/core/download.ts
+import { execFile } from "child_process";
 import fs2 from "fs";
 import path2 from "path";
 import { pipeline } from "stream/promises";
+import { promisify } from "util";
 import { Readable } from "stream";
+var execFileAsync = promisify(execFile);
+var PREVIEW_SOURCE_RE = /\.(png|jpe?g|webp|tiff?)$/i;
+var PREVIEW_SKIP_BYTES = 500 * 1024;
+var PREVIEW_MAX_DIM = 1536;
+var PREVIEW_JPEG_QUALITY = 85;
+var PREVIEW_CDN_WIDTH = 1080;
+var PREVIEW_EXTS = ["jpg", "webp", "png"];
+function previewPathFor(originalPath, ext = "jpg") {
+  return path2.join(
+    path2.dirname(originalPath),
+    "previews",
+    `${path2.basename(originalPath)}.${ext}`
+  );
+}
+function invalidatePreviews(originalPath) {
+  for (const ext of PREVIEW_EXTS) {
+    try {
+      fs2.rmSync(previewPathFor(originalPath, ext), { force: true });
+    } catch {
+    }
+  }
+}
+function shouldWritePreview(originalPath, bytes) {
+  return PREVIEW_SOURCE_RE.test(originalPath) && bytes >= PREVIEW_SKIP_BYTES;
+}
+function tempPreviewPath(previewPath) {
+  return `${previewPath}.tmp-${process.pid}`;
+}
+function commitPreview(tmpPath, previewPath) {
+  try {
+    if (fs2.existsSync(tmpPath) && fs2.statSync(tmpPath).size > 0) {
+      fs2.renameSync(tmpPath, previewPath);
+      return true;
+    }
+  } catch {
+  }
+  fs2.rmSync(tmpPath, { force: true });
+  return false;
+}
+async function writePreviewWithSips(originalPath, previewPath) {
+  if (process.platform !== "darwin") return false;
+  const tmp = tempPreviewPath(previewPath);
+  try {
+    await execFileAsync(
+      "sips",
+      [
+        "-Z",
+        String(PREVIEW_MAX_DIM),
+        "-s",
+        "format",
+        "jpeg",
+        "-s",
+        "formatOptions",
+        String(PREVIEW_JPEG_QUALITY),
+        originalPath,
+        "--out",
+        tmp
+      ],
+      { timeout: 1e4 }
+    );
+  } catch {
+    fs2.rmSync(tmp, { force: true });
+    return false;
+  }
+  return commitPreview(tmp, previewPath);
+}
+var cdnPreviewConsecutiveFailures = 0;
+var PREVIEW_CDN_MAX_CONSECUTIVE_FAILURES = 2;
+var PREVIEW_CDN_TIMEOUT_MS = 1e4;
+async function writePreviewFromCdn(sourceUrl, originalPath, fetchImpl) {
+  let host;
+  try {
+    host = new URL(sourceUrl).hostname;
+  } catch {
+    return void 0;
+  }
+  if (host !== "cdn.videodraft.ai") return void 0;
+  if (cdnPreviewConsecutiveFailures >= PREVIEW_CDN_MAX_CONSECUTIVE_FAILURES) return void 0;
+  const variant = `${DEFAULT_BASE_URL}/_next/image?url=${encodeURIComponent(sourceUrl)}&w=${PREVIEW_CDN_WIDTH}&q=75`;
+  let res;
+  try {
+    res = await fetchImpl(variant, {
+      headers: { Accept: "image/webp,image/jpeg,image/*" },
+      signal: AbortSignal.timeout(PREVIEW_CDN_TIMEOUT_MS)
+    });
+  } catch (err) {
+    cdnPreviewConsecutiveFailures++;
+    throw err;
+  }
+  if (!res.ok || !res.body) {
+    cdnPreviewConsecutiveFailures++;
+    return void 0;
+  }
+  cdnPreviewConsecutiveFailures = 0;
+  const contentType = res.headers.get("content-type") ?? "";
+  const ext = contentType.includes("webp") ? "webp" : contentType.includes("jpeg") || contentType.includes("jpg") ? "jpg" : contentType.includes("png") ? "png" : "webp";
+  const previewPath = previewPathFor(originalPath, ext);
+  const tmp = tempPreviewPath(previewPath);
+  try {
+    await pipeline(Readable.fromWeb(res.body), fs2.createWriteStream(tmp));
+  } catch {
+    fs2.rmSync(tmp, { force: true });
+    return void 0;
+  }
+  return commitPreview(tmp, previewPath) ? previewPath : void 0;
+}
+async function writePreview(originalPath, sourceUrl, bytes, fetchImpl = fetch) {
+  if (!PREVIEW_SOURCE_RE.test(originalPath)) return void 0;
+  invalidatePreviews(originalPath);
+  if (!shouldWritePreview(originalPath, bytes)) return void 0;
+  try {
+    const jpgPath = previewPathFor(originalPath, "jpg");
+    fs2.mkdirSync(path2.dirname(jpgPath), { recursive: true });
+    if (await writePreviewWithSips(originalPath, jpgPath).catch(() => false)) {
+      return jpgPath;
+    }
+    const cdnPath = await writePreviewFromCdn(sourceUrl, originalPath, fetchImpl).catch(
+      () => void 0
+    );
+    if (cdnPath) return cdnPath;
+  } catch {
+  }
+  return void 0;
+}
 function extFromUrl(url, fallback = "bin") {
   try {
     const pathname = new URL(url).pathname;
@@ -866,7 +992,10 @@ async function downloadOutputs(urls, template, vars, fetchImpl = fetch) {
       index: i,
       ext: extFromUrl(url)
     });
-    files.push(await downloadUrl(url, dest, fetchImpl));
+    const file = await downloadUrl(url, dest, fetchImpl);
+    const preview = await writePreview(file.path, url, file.bytes, fetchImpl);
+    if (preview) file.preview = preview;
+    files.push(file);
   }
   return files;
 }