videodraft 0.20.0 → 0.22.0

package/dist/client.js

@@ -643,8 +643,8 @@ var VideoDraftClient = class {
    * MCP tool by design). Uses the same bearer token + 401 refresh as rpc().
    * Returns the parsed JSON body; throws on non-2xx with the server's error.
    */
-  async restRequest(method, path5, body) {
-    const doFetch = (token2) => this.fetchImpl(`${this.baseUrl}${path5}`, {
+  async restRequest(method, path6, body) {
+    const doFetch = (token2) => this.fetchImpl(`${this.baseUrl}${path6}`, {
       method,
       headers: {
         "content-type": "application/json",
@@ -1406,6 +1406,7 @@ var MIME_BY_EXT = {
   jpg: "image/jpeg",
   jpeg: "image/jpeg",
   webp: "image/webp",
+  avif: "image/avif",
   gif: "image/gif",
   heic: "image/heic",
   mp4: "video/mp4",
@@ -1426,11 +1427,30 @@ function guessContentType(filename) {
   return MIME_BY_EXT[ext];
 }
 async function uploadFile(client, localPath, options = {}) {
+  return upload(client, localPath, options, false);
+}
+async function upload3DFile(client, localPath, options = {}) {
+  if (path4.extname(localPath).toLowerCase() !== ".glb") {
+    throw new CliError(
+      "3D rigging uploads require a self-contained .glb file."
+    );
+  }
+  return upload(
+    client,
+    localPath,
+    { ...options, contentType: "model/gltf-binary" },
+    true
+  );
+}
+async function upload(client, localPath, options, model3d) {
   const fetchImpl = options.fetchImpl ?? fetch;
   const resolved = path4.resolve(localPath);
   if (!fs4.existsSync(resolved)) {
     throw new CliError(`File not found: ${resolved}`);
   }
+  if (!fs4.statSync(resolved).isFile()) {
+    throw new CliError(`Expected a file: ${resolved}`);
+  }
   const filename = path4.basename(resolved);
   const contentType = options.contentType ?? guessContentType(filename);
   if (!contentType) {
@@ -1438,21 +1458,59 @@ async function uploadFile(client, localPath, options = {}) {
       `Cannot infer media type for "${filename}". Pass --content-type (image/*, video/* or audio/*).`
     );
   }
-  const created = await client.callTool("create_media_upload", {
+  const createTool = model3d ? "create_3d_upload" : "create_media_upload";
+  const finalizeTool = model3d ? "finalize_3d_upload" : "finalize_media_upload";
+  const created = await client.callTool(createTool, {
     filename,
     content_type: contentType
   });
   const uploadUrl = created?.upload_url;
   const filePath = created?.file_path;
   if (!uploadUrl || !filePath) {
-    throw new CliError(
-      "create_media_upload did not return upload_url/file_path."
-    );
+    throw new CliError(`${createTool} did not return upload_url/file_path.`);
   }
   const { size } = fs4.statSync(resolved);
+  const headers = {
+    "content-type": contentType,
+    "content-length": String(size)
+  };
+  if (model3d) {
+    const maxBytes = created?.max_bytes;
+    if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0) {
+      throw new CliError(
+        "create_3d_upload did not return a valid max_bytes limit."
+      );
+    }
+    if (size > maxBytes) {
+      throw new CliError(
+        `3D upload is ${size} bytes; the server allows at most ${maxBytes} bytes.`
+      );
+    }
+    if (!created.headers || typeof created.headers !== "object" || Array.isArray(created.headers)) {
+      throw new CliError(
+        "create_3d_upload did not return the required signed PUT headers."
+      );
+    }
+    for (const [name, value] of Object.entries(created.headers)) {
+      if (typeof value !== "string")
+        throw new CliError(
+          `create_3d_upload returned an invalid ${name} header.`
+        );
+      headers[name.toLowerCase()] = value;
+    }
+    headers["content-length"] = String(size);
+    const range = /^(\d+),(\d+)$/.exec(
+      headers["x-goog-content-length-range"] ?? ""
+    );
+    if (range && (size < Number(range[1]) || size > Number(range[2]))) {
+      throw new CliError(
+        `3D upload must contain between ${range[1]} and ${range[2]} bytes.`
+      );
+    }
+  }
   const putRes = await fetchImpl(uploadUrl, {
     method: "PUT",
-    headers: { "content-type": contentType, "content-length": String(size) },
+    headers,
     body: Readable2.toWeb(
       fs4.createReadStream(resolved)
     ),
@@ -1465,16 +1523,494 @@ async function uploadFile(client, localPath, options = {}) {
       `Upload PUT failed (HTTP ${putRes.status}). The presigned URL may have expired \u2014 retry.`
     );
   }
-  const finalized = await client.callTool("finalize_media_upload", {
+  const finalized = await client.callTool(finalizeTool, {
     file_path: filePath,
     original_filename: filename
   });
   const url = finalized?.url ?? finalized?.cdn_url;
   if (!url) {
-    throw new CliError("finalize_media_upload did not return a public url.");
+    throw new CliError(`${finalizeTool} did not return a public url.`);
   }
   return { ...finalized, url, file_path: filePath };
 }
+
+// src/core/model3d.ts
+import fs5 from "fs";
+import path5 from "path";
+import { randomUUID } from "crypto";
+
+// src/core/media.ts
+var IMAGE_EXTS = /* @__PURE__ */ new Set([
+  "png",
+  "jpg",
+  "jpeg",
+  "webp",
+  "gif",
+  "bmp",
+  "heic",
+  "heif",
+  "avif",
+  "svg"
+]);
+var VIDEO_EXTS = /* @__PURE__ */ new Set(["mp4", "webm", "mov", "m4v"]);
+var AUDIO_EXTS = /* @__PURE__ */ new Set([
+  "mp3",
+  "wav",
+  "pcm",
+  "opus",
+  "m4a",
+  "ogg",
+  "flac",
+  "aac"
+]);
+function kindOf(url, typeHint) {
+  const t = (typeHint ?? "").toLowerCase();
+  if (t.includes("image")) return "image";
+  if (t.includes("video")) return "video";
+  if (t.includes("audio") || t.includes("music") || t.includes("sound") || t.includes("voice") || t.includes("speech") || t.includes("tts")) {
+    return "audio";
+  }
+  const path6 = url.split(/[?#]/)[0]?.toLowerCase() ?? "";
+  if (path6.includes("/img/")) return "image";
+  if (path6.includes("/vid/")) return "video";
+  if (path6.includes("/aud/")) return "audio";
+  const ext = path6.match(/\.([a-z0-9]+)$/)?.[1];
+  if (ext) {
+    if (IMAGE_EXTS.has(ext)) return "image";
+    if (VIDEO_EXTS.has(ext)) return "video";
+    if (AUDIO_EXTS.has(ext)) return "audio";
+  }
+  return null;
+}
+function buildMediaDescriptors(urls, typeHint) {
+  if (!Array.isArray(urls)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const url of urls) {
+    if (typeof url !== "string" || !/^https?:\/\//i.test(url) || seen.has(url))
+      continue;
+    const kind = kindOf(url, typeHint);
+    if (!kind) continue;
+    seen.add(url);
+    out.push({ kind, url });
+  }
+  return out;
+}
+
+// src/core/model3d.ts
+function isModel3DResult(payload) {
+  return payload?.type === "model3d";
+}
+function warningStrings(value) {
+  return Array.isArray(value) ? value.filter(
+    (warning) => typeof warning === "string" && Boolean(warning.trim())
+  ) : [];
+}
+function model3DWarnings(payload, localWarnings = []) {
+  return [
+    .../* @__PURE__ */ new Set([
+      ...warningStrings(payload?.artifact_warnings),
+      ...warningStrings(payload?.package_warnings),
+      ...localWarnings
+    ])
+  ];
+}
+function model3DArtifacts(payload) {
+  const artifacts = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of Array.isArray(payload?.artifacts) ? payload.artifacts : []) {
+    if (!item || typeof item.url !== "string" || !/^https?:\/\//i.test(item.url))
+      continue;
+    const filename = typeof item.filename === "string" ? item.filename : "";
+    const key = `${item.url}
+${filename}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    artifacts.push({
+      id: String(item.id ?? `artifact-${artifacts.length}`),
+      role: String(item.role ?? "other"),
+      url: item.url,
+      filename: filename || `artifact-${artifacts.length}.${extFromUrl(item.url)}`,
+      ...typeof item.content_type === "string" ? { content_type: item.content_type } : {},
+      ...typeof item.bytes === "number" ? { bytes: item.bytes } : {},
+      ...Array.isArray(item.aliases) ? {
+        aliases: item.aliases.filter(
+          (alias) => typeof alias === "string"
+        )
+      } : {}
+    });
+  }
+  const urls = Array.isArray(payload?.output_urls) ? payload.output_urls : payload?.outputs;
+  for (const url of Array.isArray(urls) ? urls : []) {
+    if (typeof url !== "string" || !/^https?:\/\//i.test(url) || artifacts.some((a) => a.url === url))
+      continue;
+    artifacts.push({
+      id: `model-${artifacts.length}`,
+      role: "model",
+      url,
+      filename: `model-${artifacts.length}.${extFromUrl(url)}`
+    });
+  }
+  if (typeof payload?.preview_url === "string" && /^https?:\/\//i.test(payload.preview_url) && !artifacts.some((a) => a.url === payload.preview_url)) {
+    artifacts.push({
+      id: "preview",
+      role: "preview",
+      url: payload.preview_url,
+      filename: `preview.${extFromUrl(payload.preview_url, "png")}`
+    });
+  }
+  return artifacts;
+}
+function model3DOutputFields(payload) {
+  const artifacts = model3DArtifacts(payload);
+  const previews = artifacts.filter((a) => a.role === "preview");
+  return {
+    output_files: artifacts,
+    artifact_warnings: warningStrings(payload?.artifact_warnings),
+    package_warnings: model3DWarnings(payload),
+    output_media: previews.flatMap(
+      (a) => buildMediaDescriptors([a.url], a.content_type)
+    )
+  };
+}
+function safeName(value, fallback) {
+  const name = value.replace(/[^a-zA-Z0-9._ -]/g, "_").replace(/^\.+/, "");
+  return name && name !== "." && name !== ".." ? name : fallback;
+}
+function safeRelativeFilename(filename, index) {
+  return normalizeThreeDArtifactFilename(filename || `artifact-${index}.bin`);
+}
+function truncateUtf8(value, maximum) {
+  let result = "";
+  let bytes = 0;
+  for (const character of Array.from(value)) {
+    const size = Buffer.byteLength(character);
+    if (bytes + size > maximum) break;
+    result += character;
+    bytes += size;
+  }
+  return result;
+}
+function normalizeThreeDArtifactFilename(name, extension, suffix = "") {
+  const cleaned = name.replace(/\\/g, "/").replace(/^[A-Za-z]:\//, "").replace(/^\/+/, "");
+  const parts = cleaned.split("/").filter((part) => part && part !== "." && part !== "..");
+  const safeParts = parts.map((part, index) => {
+    const sanitized = part.replace(/[\x00-\x1f\x7f<>:"|?*]/g, "_");
+    const last = index === parts.length - 1;
+    const originalExtension = path5.posix.extname(sanitized);
+    const keptExtension = last && extension ? `.${extension.replace(/^\./, "")}` : truncateUtf8(originalExtension, 24);
+    const keptSuffix = last ? truncateUtf8(suffix, 64) : "";
+    const base = originalExtension ? sanitized.slice(0, -originalExtension.length) : sanitized;
+    const stem = truncateUtf8(
+      base,
+      180 - Buffer.byteLength(keptExtension + keptSuffix)
+    );
+    return `${stem || "artifact"}${keptSuffix}${keptExtension}`;
+  });
+  while (safeParts.length > 1 && Buffer.byteLength(safeParts.join("/")) > 700)
+    safeParts.shift();
+  return safeParts.join("/") || `artifact.${extension || "bin"}`;
+}
+function model3DPackageDirectory(payload, target) {
+  const id = safeName(
+    String(payload?.asset_id ?? payload?.job_id ?? payload?.id ?? "asset"),
+    "asset"
+  );
+  if (target === true) return path5.join("media", "3d", id);
+  if (/\{(?:index|ext|name)\}/.test(target)) {
+    throw new CliError(
+      "3D downloads need a package directory. Use --download './media/3d/{job_id}' (no {index}, {name}, or {ext}).",
+      EXIT.USAGE
+    );
+  }
+  const expanded = target.replaceAll("{job_id}", safeName(String(payload?.job_id ?? id), "job")).replaceAll("{asset_id}", id);
+  if (/\.(?:glb|gltf|fbx|obj|mtl|stl|usdz|zip|bin)$/i.test(expanded)) {
+    throw new CliError(
+      "3D downloads contain a model, dependencies, and a manifest. Pass a directory to --download, such as ./media/3d.",
+      EXIT.USAGE
+    );
+  }
+  return /\{(?:job_id|asset_id)\}/.test(target) ? expanded : path5.join(expanded, id);
+}
+function writeDependencyAliases(directory, artifacts) {
+  const occupied = new Map(
+    artifacts.map((artifact) => [
+      artifact.local_path.toLowerCase(),
+      artifact.url
+    ])
+  );
+  occupied.set("manifest.json", "manifest");
+  const warnings = [];
+  const files = [];
+  for (const artifact of artifacts) {
+    const aliases = [];
+    for (const original of artifact.aliases ?? []) {
+      const relative = original.replace(/\\/g, "/");
+      const segments = relative.split("/");
+      if (!relative || path5.posix.isAbsolute(relative) || segments.some(
+        (segment) => !segment || segment === "." || segment === ".." || /[\x00-\x1f\x7f<>:"|?*]/.test(segment)
+      )) {
+        warnings.push(
+          `${artifact.local_path}: unsafe dependency alias was not saved: ${original}`
+        );
+        continue;
+      }
+      if (relative === artifact.local_path) {
+        aliases.push(relative);
+        continue;
+      }
+      const lower = relative.toLowerCase();
+      const conflict = Array.from(occupied).some(
+        ([name, url]) => name === lower && url !== artifact.url || name.startsWith(lower + "/") || lower.startsWith(name + "/")
+      );
+      if (conflict) {
+        warnings.push(
+          `${artifact.local_path}: dependency alias collides with another artifact: ${relative}`
+        );
+        continue;
+      }
+      const dest = path5.join(directory, relative);
+      if (!fs5.existsSync(dest)) {
+        fs5.mkdirSync(path5.dirname(dest), { recursive: true });
+        fs5.copyFileSync(
+          path5.join(directory, artifact.local_path),
+          dest,
+          fs5.constants.COPYFILE_EXCL
+        );
+        files.push({
+          url: artifact.url,
+          path: dest,
+          bytes: artifact.downloaded_bytes
+        });
+      }
+      aliases.push(relative);
+      occupied.set(lower, artifact.url);
+    }
+    if (aliases.length) artifact.local_aliases = aliases;
+  }
+  return { files, warnings };
+}
+function localizeDependencies(directory, artifacts) {
+  const warnings = [];
+  const matching = (source, reference) => {
+    let decoded = reference;
+    try {
+      decoded = decodeURIComponent(reference);
+    } catch {
+    }
+    const sourceRelative = path5.posix.normalize(
+      path5.posix.join(
+        path5.posix.dirname(source.source_filename.replace(/\\/g, "/")),
+        decoded.replace(/\\/g, "/")
+      )
+    );
+    const absoluteUrl = (() => {
+      try {
+        return new URL(reference, source.url).href;
+      } catch {
+        return "";
+      }
+    })();
+    const precise = artifacts.filter(
+      (a) => a.url === reference || a.url === absoluteUrl || a.source_filename.replace(/\\/g, "/") === sourceRelative
+    );
+    if (precise.length === 1) return precise[0];
+    const byFilename = artifacts.filter(
+      (a) => path5.posix.basename(a.source_filename.replace(/\\/g, "/")) === path5.posix.basename(decoded.replace(/\\/g, "/"))
+    );
+    return byFilename.length === 1 ? byFilename[0] : void 0;
+  };
+  const rewrite = (source, reference, encode) => {
+    if (/^data:/i.test(reference)) return reference;
+    const found = matching(source, reference);
+    if (!found) {
+      warnings.push(
+        `${source.local_path}: dependency could not be matched to a saved artifact: ${reference}`
+      );
+      return reference;
+    }
+    const relative = path5.posix.relative(
+      path5.posix.dirname(source.local_path),
+      found.local_path
+    );
+    return encode ? relative.split("/").map(encodeURIComponent).join("/") : relative;
+  };
+  for (const artifact of artifacts) {
+    const filename = path5.join(directory, artifact.local_path);
+    const ext = path5.extname(artifact.local_path).toLowerCase();
+    if (ext === ".gltf") {
+      try {
+        const document = JSON.parse(fs5.readFileSync(filename, "utf8"));
+        const visit = (value) => {
+          if (Array.isArray(value)) {
+            value.forEach(visit);
+            return;
+          }
+          if (!value || typeof value !== "object") return;
+          for (const [key, child] of Object.entries(value)) {
+            if (key === "uri" && typeof child === "string")
+              value[key] = rewrite(
+                artifact,
+                child,
+                true
+              );
+            else visit(child);
+          }
+        };
+        visit(document);
+        fs5.writeFileSync(filename, JSON.stringify(document, null, 2) + "\n");
+      } catch (error) {
+        warnings.push(
+          `${artifact.local_path}: could not resolve glTF dependencies (${error instanceof Error ? error.message : String(error)}).`
+        );
+      }
+    } else if (ext === ".obj" || ext === ".mtl") {
+      const contents = fs5.readFileSync(filename, "utf8");
+      const updated = contents.replace(
+        /^(\s*(?:mtllib|map_[a-z0-9_]+|bump|disp|decal|norm|refl)\s+)(.+)$/gim,
+        (line, prefix, raw) => {
+          const reference = raw.trim();
+          if (reference.startsWith("-")) {
+            const candidates = artifacts.filter(
+              (a) => reference.endsWith(a.url) || reference.endsWith(a.source_filename) || reference.endsWith(path5.posix.basename(a.source_filename))
+            );
+            if (candidates.length === 1) {
+              const candidate = candidates[0];
+              const name = reference.endsWith(candidate.url) ? candidate.url : reference.endsWith(candidate.source_filename) ? candidate.source_filename : path5.posix.basename(candidate.source_filename);
+              return prefix + reference.slice(0, -name.length) + rewrite(artifact, name, false);
+            }
+            warnings.push(
+              `${artifact.local_path}: could not resolve material reference: ${reference}`
+            );
+            return line;
+          }
+          if (/mtllib/i.test(prefix) && !matching(artifact, reference)) {
+            const references = [...reference.matchAll(/"([^"]+)"|(\S+)/g)].map(
+              (match) => match[1] ?? match[2]
+            );
+            if (references.length > 1 && references.every((ref) => matching(artifact, ref))) {
+              return references.map((ref) => prefix + rewrite(artifact, ref, false)).join("\n");
+            }
+          }
+          return prefix + rewrite(artifact, reference, false);
+        }
+      );
+      fs5.writeFileSync(filename, updated);
+    }
+    artifact.downloaded_bytes = fs5.statSync(filename).size;
+  }
+  return [...new Set(warnings)];
+}
+async function downloadModel3DPackage(payload, target, fetchImpl = fetch) {
+  try {
+    return await downloadPackage(payload, target, fetchImpl);
+  } catch (error) {
+    const id = payload?.asset_id ?? payload?.job_id ?? payload?.id;
+    throw new CliError(
+      error instanceof Error ? error.message : String(error),
+      error instanceof CliError ? error.exitCode : EXIT.ERROR,
+      id ? `The saved 3D asset remains available. Retry downloading with: videodraft assets 3d get ${id} --download` : void 0,
+      {
+        asset_id: payload?.asset_id,
+        job_id: payload?.job_id,
+        request_id: payload?.request_id
+      }
+    );
+  }
+}
+async function downloadPackage(payload, target, fetchImpl) {
+  const artifacts = model3DArtifacts(payload);
+  if (artifacts.length === 0)
+    throw new CliError("The 3D asset has no downloadable artifacts yet.");
+  const preferredDirectory = model3DPackageDirectory(payload, target);
+  fs5.mkdirSync(path5.dirname(preferredDirectory), { recursive: true });
+  let directory = preferredDirectory;
+  for (let suffix = 2; ; suffix++) {
+    try {
+      fs5.mkdirSync(directory);
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      directory = `${preferredDirectory}-${suffix}`;
+    }
+  }
+  const used = /* @__PURE__ */ new Set(["manifest.json"]);
+  const local = artifacts.map((artifact, index) => {
+    const original = safeRelativeFilename(artifact.filename, index);
+    let relative = original;
+    let suffix = 1;
+    while (Array.from(used).some(
+      (name) => name === relative.toLowerCase() || name.startsWith(relative.toLowerCase() + "/") || relative.toLowerCase().startsWith(name + "/")
+    )) {
+      relative = normalizeThreeDArtifactFilename(
+        path5.posix.basename(original),
+        void 0,
+        `-${suffix++}`
+      );
+    }
+    used.add(relative.toLowerCase());
+    return {
+      ...artifact,
+      local_path: relative,
+      source_filename: artifact.filename,
+      downloaded_bytes: 0
+    };
+  });
+  const files = [];
+  for (const artifact of local) {
+    const dest = path5.join(directory, artifact.local_path);
+    const temporary = `${dest}.partial-${randomUUID()}`;
+    try {
+      const file = await downloadUrl(artifact.url, temporary, fetchImpl);
+      fs5.renameSync(temporary, dest);
+      artifact.downloaded_bytes = file.bytes;
+      files.push({ ...file, path: dest });
+    } finally {
+      fs5.rmSync(temporary, { force: true });
+    }
+  }
+  const warnings = localizeDependencies(directory, local);
+  for (let index = 0; index < files.length; index++) {
+    const file = files[index];
+    file.bytes = local[index].downloaded_bytes;
+    if (local[index].role === "preview") {
+      const preview = await writePreview(
+        file.path,
+        file.url,
+        file.bytes,
+        fetchImpl
+      );
+      if (preview) file.preview = preview;
+    }
+  }
+  const aliases = writeDependencyAliases(directory, local);
+  files.push(...aliases.files);
+  warnings.push(...aliases.warnings);
+  const manifestPath = path5.join(directory, "manifest.json");
+  const temporaryManifest = `${manifestPath}.partial-${randomUUID()}`;
+  const manifest = {
+    version: 1,
+    type: "model3d",
+    asset_id: payload?.asset_id ?? payload?.id,
+    job_id: payload?.job_id,
+    model: payload?.model,
+    credits: payload?.credits,
+    byok: payload?.byok,
+    complete: warnings.length === 0,
+    complete_scope: "returned_artifacts",
+    artifact_warnings: warningStrings(payload?.artifact_warnings),
+    warnings: model3DWarnings(payload, warnings),
+    artifacts: local
+  };
+  fs5.writeFileSync(temporaryManifest, JSON.stringify(manifest, null, 2) + "\n");
+  fs5.renameSync(temporaryManifest, manifestPath);
+  return {
+    downloaded_files: files,
+    package_directory: directory,
+    manifest_path: manifestPath,
+    package_warnings: model3DWarnings(payload, warnings)
+  };
+}
 export {
   AuthError,
   CliError,
@@ -1493,6 +2029,7 @@ export {
   configPath,
   createConnectionSessionStore,
   createPkcePair,
+  downloadModel3DPackage,
   downloadOutputs,
   downloadUrl,
   exchangeCode,
@@ -1500,6 +2037,9 @@ export {
   extractOutputUrls,
   getProfile,
   guessContentType,
+  isModel3DResult,
+  model3DArtifacts,
+  model3DOutputFields,
   nextPollDelay,
   pollExport,
   pollGeneration,
@@ -1517,6 +2057,7 @@ export {
   sessionScope,
   staticTokenProvider,
   updateConfig,
+  upload3DFile,
   uploadFile,
   writeConfig
 };