hyper-animator-codex 0.2.0 → 0.4.0

package/skills/hyper-animator-codex/scripts/generate_minimax_music.mjs

@@ -0,0 +1,346 @@
+#!/usr/bin/env node
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  DEFAULT_MINIMAX_MODEL,
+  readMinimaxRuntimeConfig,
+  redactMinimaxConfig,
+  validateMinimaxConfig,
+} from "./minimax_runtime_config.mjs";
+
+const ENDPOINT = "https://api.minimaxi.com/v1/music_generation";
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const skillRoot = dirname(scriptDir);
+
+function requireValue(args, index, flag) {
+  const value = args[index + 1];
+
+  if (!value || value.startsWith("--")) {
+    throw new Error(`${flag} requires a value`);
+  }
+
+  return value;
+}
+
+function parseArgs(args) {
+  const parsed = {
+    prompt: undefined,
+    lyrics: undefined,
+    lyrics_optimizer: false,
+    is_instrumental: true,
+    output_dir: join(process.cwd(), "hyper-animator-output", "music"),
+    output_format: "hex",
+    audio_format: "mp3",
+    sample_rate: 44100,
+    bitrate: 256000,
+    model: undefined,
+    config_path: undefined,
+    dry_run: false,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (arg === "--prompt") {
+      parsed.prompt = requireValue(args, index, arg);
+      index += 1;
+    } else if (arg === "--lyrics") {
+      parsed.lyrics = requireValue(args, index, arg);
+      index += 1;
+    } else if (arg === "--lyrics-optimizer") {
+      parsed.lyrics_optimizer = true;
+    } else if (arg === "--instrumental") {
+      parsed.is_instrumental = true;
+    } else if (arg === "--vocal") {
+      parsed.is_instrumental = false;
+    } else if (arg === "--output-dir") {
+      parsed.output_dir = requireValue(args, index, arg);
+      index += 1;
+    } else if (arg === "--output-format") {
+      parsed.output_format = requireValue(args, index, arg);
+      index += 1;
+    } else if (arg === "--format") {
+      parsed.audio_format = requireValue(args, index, arg);
+      index += 1;
+    } else if (arg === "--sample-rate") {
+      parsed.sample_rate = Number.parseInt(requireValue(args, index, arg), 10);
+      index += 1;
+    } else if (arg === "--bitrate") {
+      parsed.bitrate = Number.parseInt(requireValue(args, index, arg), 10);
+      index += 1;
+    } else if (arg === "--model") {
+      parsed.model = requireValue(args, index, arg);
+      index += 1;
+    } else if (arg === "--config") {
+      parsed.config_path = requireValue(args, index, arg);
+      index += 1;
+    } else if (arg === "--dry-run") {
+      parsed.dry_run = true;
+    } else if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+    } else {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+
+  return parsed;
+}
+
+function printHelp() {
+  console.log(`Usage:
+  node scripts/generate_minimax_music.mjs --prompt <text> [options]
+
+Options:
+  --prompt <text>              Music style, mood, and scene prompt
+  --lyrics <text>              Lyrics for vocal generation
+  --lyrics-optimizer           Let MiniMax generate lyrics from prompt for vocal generation
+  --instrumental               Generate instrumental music, default
+  --vocal                      Generate vocal music; requires --lyrics or --lyrics-optimizer
+  --output-dir <dir>           Directory for generated audio and metadata
+  --output-format <hex|url>    MiniMax response format, default hex
+  --format <mp3|wav|pcm>       Audio encoding format, default mp3
+  --sample-rate <rate>         16000, 24000, 32000, or 44100; default 44100
+  --bitrate <bits>             32000, 64000, 128000, or 256000; default 256000
+  --model <model>              music-2.6 or music-2.6-free
+  --config <file>              Explicit MiniMax config JSON
+  --dry-run                    Print redacted request without contacting MiniMax
+`);
+}
+
+function validateOptions(options) {
+  if (!options.prompt || options.prompt.trim().length === 0) {
+    throw new Error("--prompt is required");
+  }
+
+  if (options.prompt.length > 2000) {
+    throw new Error("--prompt must be 2000 characters or fewer");
+  }
+
+  if (!["hex", "url"].includes(options.output_format)) {
+    throw new Error("--output-format must be hex or url");
+  }
+
+  if (!["mp3", "wav", "pcm"].includes(options.audio_format)) {
+    throw new Error("--format must be mp3, wav, or pcm");
+  }
+
+  if (![16000, 24000, 32000, 44100].includes(options.sample_rate)) {
+    throw new Error("--sample-rate must be 16000, 24000, 32000, or 44100");
+  }
+
+  if (![32000, 64000, 128000, 256000].includes(options.bitrate)) {
+    throw new Error("--bitrate must be 32000, 64000, 128000, or 256000");
+  }
+
+  if (!options.is_instrumental && !options.lyrics && !options.lyrics_optimizer) {
+    throw new Error("Vocal MiniMax generation requires --lyrics or --lyrics-optimizer");
+  }
+
+  if (options.lyrics && options.lyrics.length > 3500) {
+    throw new Error("--lyrics must be 3500 characters or fewer");
+  }
+}
+
+function buildRequest(options, config) {
+  const model = options.model || config.model || DEFAULT_MINIMAX_MODEL;
+  const validatedConfig = validateMinimaxConfig({
+    ...config,
+    model,
+  });
+
+  const request = {
+    model: validatedConfig.model,
+    prompt: options.prompt,
+    stream: false,
+    output_format: options.output_format,
+    audio_setting: {
+      sample_rate: options.sample_rate,
+      bitrate: options.bitrate,
+      format: options.audio_format,
+    },
+    is_instrumental: options.is_instrumental,
+  };
+
+  if (options.lyrics) {
+    request.lyrics = options.lyrics;
+  }
+
+  if (options.lyrics_optimizer) {
+    request.lyrics_optimizer = true;
+  }
+
+  return request;
+}
+
+function safeFileStem(prompt) {
+  const stem = prompt
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 48);
+
+  return stem || "minimax-music";
+}
+
+async function downloadUrl(url) {
+  const response = await fetch(url);
+
+  if (!response.ok) {
+    throw new Error(`MiniMax audio URL download failed with HTTP ${response.status}`);
+  }
+
+  return Buffer.from(await response.arrayBuffer());
+}
+
+function decodeHexAudio(value) {
+  if (!/^[0-9a-fA-F]+$/.test(value) || value.length % 2 !== 0) {
+    throw new Error("MiniMax response audio is not valid hex data");
+  }
+
+  return Buffer.from(value, "hex");
+}
+
+async function callMiniMax(config, request) {
+  const response = await fetch(ENDPOINT, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.api_key}`,
+    },
+    body: JSON.stringify(request),
+  });
+
+  const text = await response.text();
+  let json;
+
+  try {
+    json = JSON.parse(text);
+  } catch (error) {
+    throw new Error(`MiniMax returned non-JSON response with HTTP ${response.status}`);
+  }
+
+  if (!response.ok) {
+    const message = json.base_resp?.status_msg || `HTTP ${response.status}`;
+    throw new Error(`MiniMax request failed: ${message}`);
+  }
+
+  const statusCode = json.base_resp?.status_code;
+  if (statusCode !== 0) {
+    const message = json.base_resp?.status_msg || "unknown MiniMax error";
+    throw new Error(`MiniMax request failed with status_code ${statusCode}: ${message}`);
+  }
+
+  if (json.data?.status !== 2) {
+    throw new Error(`MiniMax generation is not complete; data.status is ${json.data?.status}`);
+  }
+
+  if (!json.data?.audio) {
+    throw new Error("MiniMax response did not include data.audio");
+  }
+
+  return json;
+}
+
+async function writeAudioOutput({ responseJson, request, outputDir, prompt }) {
+  await mkdir(outputDir, { recursive: true });
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const stem = `${safeFileStem(prompt)}-${timestamp}`;
+  const extension = request.audio_setting.format === "pcm" ? "pcm" : request.audio_setting.format;
+  const audioPath = join(outputDir, `${stem}.${extension}`);
+  const metadataPath = join(outputDir, `${stem}.minimax.json`);
+  const audioValue = responseJson.data.audio;
+  const audioBuffer = request.output_format === "url"
+    ? await downloadUrl(audioValue)
+    : decodeHexAudio(audioValue);
+
+  await writeFile(audioPath, audioBuffer);
+  await writeFile(
+    metadataPath,
+    `${JSON.stringify({
+      provider: "minimax",
+      endpoint: ENDPOINT,
+      request,
+      response: {
+        base_resp: responseJson.base_resp,
+        data: {
+          status: responseJson.data.status,
+        },
+        extra_info: responseJson.extra_info,
+        trace_id: responseJson.trace_id,
+      },
+      audio_path: audioPath,
+    }, null, 2)}\n`,
+    "utf8",
+  );
+
+  return {
+    audioPath,
+    metadataPath,
+  };
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+
+  if (options.help) {
+    printHelp();
+    return;
+  }
+
+  validateOptions(options);
+
+  const runtime = await readMinimaxRuntimeConfig({
+    skillRoot,
+    env: process.env,
+    configPath: options.config_path,
+  });
+
+  if (!runtime) {
+    throw new Error("MiniMax config not found. Run hyper-animator-codex install with --minimax-api-key and --minimax-group-id, or set MINIMAX_API_KEY and MINIMAX_GROUP_ID.");
+  }
+
+  const request = buildRequest(options, runtime.config);
+  const redactedConfig = redactMinimaxConfig(runtime.config);
+
+  if (options.dry_run) {
+    console.log(JSON.stringify({
+      ok: true,
+      dry_run: true,
+      provider: "minimax",
+      endpoint: ENDPOINT,
+      config: {
+        source: runtime.source,
+        path: runtime.configPath,
+        redacted: redactedConfig,
+      },
+      request,
+      output_dir: options.output_dir,
+    }, null, 2));
+    return;
+  }
+
+  const responseJson = await callMiniMax(runtime.config, request);
+  const output = await writeAudioOutput({
+    responseJson,
+    request,
+    outputDir: options.output_dir,
+    prompt: options.prompt,
+  });
+
+  console.log(JSON.stringify({
+    ok: true,
+    provider: "minimax",
+    model: request.model,
+    output_path: output.audioPath,
+    metadata_path: output.metadataPath,
+    beat_analysis_command: `python3 scripts/analyze_music_beats.py ${output.audioPath} -o ${join(options.output_dir, "beat-map.json")} --fps 60 --pretty`,
+  }, null, 2));
+}
+
+main().catch((error) => {
+  console.error(`Error: ${error.message}`);
+  process.exitCode = 1;
+});

package/skills/hyper-animator-codex/scripts/inject_preview_controls.mjs

@@ -0,0 +1,338 @@
+#!/usr/bin/env node
+import { readFile, stat, writeFile } from "node:fs/promises";
+
+const MARKER = "<!-- hyper-animator-preview-controls:start -->";
+const PREVIEW_UI_MARKER = /<[A-Za-z][A-Za-z0-9:-]*(?:\s[^<>]*?)?\sdata-hyper-preview-ui(?:\s|=|\/?>)/i;
+
+function parseArgs(args) {
+  const parsed = { input: undefined, output: undefined, force: false, componentId: undefined };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "-o" || arg === "--output") {
+      parsed.output = requireValue(args, index, arg);
+      index += 1;
+    } else if (arg === "--force") {
+      parsed.force = true;
+    } else if (arg === "--component-id") {
+      parsed.componentId = requireValue(args, index, arg);
+      index += 1;
+    } else if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+    } else if (!parsed.input) {
+      parsed.input = arg;
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+  return parsed;
+}
+
+function requireValue(args, index, flag) {
+  const value = args[index + 1];
+  if (!value || value.startsWith("-")) {
+    throw new Error(`${flag} requires a value`);
+  }
+  return value;
+}
+
+function printHelp() {
+  console.log(`Usage:
+  node scripts/inject_preview_controls.mjs input.html [-o preview.html] [--force] [--component-id <id>]
+
+Options:
+  -o, --output <file>      Write preview HTML to a separate file
+  --force                 Allow overwriting the output file
+  --component-id <id>     Use a specific data-composition-id for timeline seeking
+`);
+}
+
+async function pathExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch (error) {
+    if (error && error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+
+function findCompositionId(html, explicitId) {
+  if (explicitId) return explicitId;
+  const match = html.match(/data-composition-id\s*=\s*["']([^"']+)["']/i);
+  if (!match) {
+    throw new Error("Cannot inject preview controls: missing data-composition-id. Pass --component-id to override.");
+  }
+  return match[1];
+}
+
+function serializeJsString(value) {
+  return JSON.stringify(value)
+    .replace(/</g, "\\u003C")
+    .replace(/\u2028/g, "\\u2028")
+    .replace(/\u2029/g, "\\u2029");
+}
+
+function findTagEnd(html, startIndex) {
+  let quote = null;
+  for (let index = startIndex + 1; index < html.length; index += 1) {
+    const char = html[index];
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char === ">") {
+      return index;
+    }
+  }
+  return -1;
+}
+
+function scanLastClosingBodyTagIndex(html) {
+  const lower = html.toLowerCase();
+  let index = 0;
+  let lastClosingBodyTagIndex = -1;
+  let rawTextTag = "";
+
+  while (index < html.length) {
+    if (rawTextTag) {
+      const closingTag = `</${rawTextTag}`;
+      const closingTagIndex = lower.indexOf(closingTag, index);
+      if (closingTagIndex === -1) {
+        return lastClosingBodyTagIndex;
+      }
+      const closingTagEndIndex = findTagEnd(html, closingTagIndex);
+      if (closingTagEndIndex === -1) {
+        return lastClosingBodyTagIndex;
+      }
+      index = closingTagEndIndex + 1;
+      rawTextTag = "";
+      continue;
+    }
+
+    const nextTagIndex = html.indexOf("<", index);
+    if (nextTagIndex === -1) {
+      return lastClosingBodyTagIndex;
+    }
+
+    if (lower.startsWith("<!--", nextTagIndex)) {
+      const commentEndIndex = lower.indexOf("-->", nextTagIndex + 4);
+      if (commentEndIndex === -1) {
+        return lastClosingBodyTagIndex;
+      }
+      index = commentEndIndex + 3;
+      continue;
+    }
+
+    const tagEndIndex = findTagEnd(html, nextTagIndex);
+    if (tagEndIndex === -1) {
+      return lastClosingBodyTagIndex;
+    }
+
+    const tagContent = lower.slice(nextTagIndex + 1, tagEndIndex).trimStart();
+    if (/^\/\s*body\b/.test(tagContent)) {
+      lastClosingBodyTagIndex = nextTagIndex;
+    } else if (/^(script|style|textarea|title)\b/.test(tagContent)) {
+      rawTextTag = tagContent.match(/^(script|style|textarea|title)\b/)[1];
+    }
+
+    index = tagEndIndex + 1;
+  }
+
+  return lastClosingBodyTagIndex;
+}
+
+function findLastClosingBodyTagIndex(html) {
+  return scanLastClosingBodyTagIndex(html);
+}
+
+function injectPreviewControls(html, componentId) {
+  if (PREVIEW_UI_MARKER.test(html)) {
+    return html;
+  }
+
+  const escapedId = serializeJsString(componentId);
+  const controls = `<!-- hyper-animator-preview-controls:start -->
+<style data-hyper-preview-style>
+.hyper-preview-ui {
+  position: fixed;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  z-index: 2147483647;
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr);
+  align-items: center;
+  gap: 10px;
+  padding: 6px 10px 8px;
+  color: rgba(255, 255, 255, 0.86);
+  font: 12px/1.2 system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  pointer-events: none;
+  background: linear-gradient(to top, rgba(0, 0, 0, 0.34), rgba(0, 0, 0, 0));
+}
+.hyper-preview-ui[hidden] {
+  display: none !important;
+}
+.hyper-preview-page {
+  min-width: 42px;
+  text-align: center;
+  font-variant-numeric: tabular-nums lining-nums;
+  text-shadow: 0 1px 2px rgba(0, 0, 0, 0.45);
+}
+.hyper-preview-progress {
+  width: 100%;
+  height: 3px;
+  accent-color: rgba(255, 255, 255, 0.92);
+  cursor: pointer;
+  pointer-events: auto;
+}
+</style>
+<div class="hyper-preview-ui" data-hyper-preview-ui hidden aria-label="Animation preview controls">
+  <div class="hyper-preview-page" data-hyper-preview-page aria-live="polite">1 / 1</div>
+  <input class="hyper-preview-progress" data-hyper-preview-progress type="range" min="0" max="1000" step="1" value="0" aria-label="Preview progress" />
+</div>
+<script data-hyper-preview-script>
+(function () {
+  const componentId = ${escapedId};
+  const params = new URLSearchParams(window.location.search);
+  const renderMode = params.get("render") === "1" || params.get("preview") === "0" || document.documentElement.dataset.renderMode === "video";
+  const root = document.querySelector("[data-hyper-preview-ui]");
+  if (!root) return;
+  if (renderMode) {
+    root.hidden = true;
+    root.style.display = "none";
+    return;
+  }
+
+  const pageLabel = root.querySelector("[data-hyper-preview-page]");
+  const progress = root.querySelector("[data-hyper-preview-progress]");
+  const composition = findComposition();
+  const duration = readDuration(composition);
+  const pages = readPages(composition, duration);
+  let pageIndex = 0;
+
+  root.hidden = false;
+  root.style.display = "";
+  updateForTime(0);
+
+  progress.addEventListener("input", function () {
+    const seconds = (Number(progress.value) / Number(progress.max)) * duration;
+    seek(seconds);
+    updateForTime(seconds);
+  });
+
+  document.addEventListener("keydown", function (event) {
+    if (event.defaultPrevented || event.metaKey || event.ctrlKey || event.altKey || renderMode) return;
+    if (event.key === "ArrowLeft") {
+      event.preventDefault();
+      goToPage(Math.max(0, pageIndex - 1));
+    } else if (event.key === "ArrowRight") {
+      event.preventDefault();
+      goToPage(Math.min(pages.length - 1, pageIndex + 1));
+    }
+  });
+
+  function readDuration(element) {
+    const raw = element ? Number(element.dataset.duration) : NaN;
+    const timelineDuration = getTimeline() && typeof getTimeline().duration === "function" ? Number(getTimeline().duration()) : NaN;
+    const value = Number.isFinite(raw) && raw > 0 ? raw : timelineDuration;
+    return Number.isFinite(value) && value > 0 ? value : 1;
+  }
+
+  function readPages(element, totalDuration) {
+    if (element && element.dataset.previewPages) {
+      const parsed = element.dataset.previewPages.split(",").map((value) => Number(value.trim())).filter((value) => Number.isFinite(value) && value >= 0 && value <= totalDuration);
+      if (parsed.length > 0) return parsed;
+    }
+    const count = element && Number.parseInt(element.dataset.previewPageCount || "", 10);
+    if (Number.isFinite(count) && count > 1) {
+      return Array.from({ length: count }, (_, index) => (totalDuration / count) * index);
+    }
+    return [0];
+  }
+
+  function getTimeline() {
+    return window.__timelines && window.__timelines[componentId];
+  }
+
+  function findComposition() {
+    const compositions = document.querySelectorAll("[data-composition-id]");
+    for (const element of compositions) {
+      if (element.dataset.compositionId === componentId) {
+        return element;
+      }
+    }
+    return null;
+  }
+
+  function seek(seconds) {
+    const timeline = getTimeline();
+    if (!timeline) return;
+    if (typeof timeline.time === "function") {
+      timeline.time(Math.max(0, Math.min(duration, seconds)));
+    } else if (typeof timeline.progress === "function") {
+      timeline.progress(Math.max(0, Math.min(1, seconds / duration)));
+    }
+  }
+
+  function goToPage(nextIndex) {
+    pageIndex = nextIndex;
+    const seconds = pages[pageIndex] || 0;
+    seek(seconds);
+    updateForTime(seconds);
+  }
+
+  function updateForTime(seconds) {
+    pageIndex = activePageIndex(seconds);
+    pageLabel.textContent = String(pageIndex + 1) + " / " + String(pages.length);
+    progress.value = String(Math.round((Math.max(0, Math.min(duration, seconds)) / duration) * Number(progress.max)));
+  }
+
+  function activePageIndex(seconds) {
+    let active = 0;
+    for (let index = 0; index < pages.length; index += 1) {
+      if (seconds + 0.0001 >= pages[index]) active = index;
+    }
+    return active;
+  }
+})();
+</script>
+<!-- hyper-animator-preview-controls:end -->`;
+
+  const closingBodyTagIndex = findLastClosingBodyTagIndex(html);
+  if (closingBodyTagIndex !== -1) {
+    return `${html.slice(0, closingBodyTagIndex)}${controls}\n${html.slice(closingBodyTagIndex)}`;
+  }
+  return `${html}\n${controls}\n`;
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  if (options.help) {
+    printHelp();
+    return;
+  }
+  if (!options.input) {
+    throw new Error("input.html is required");
+  }
+
+  const output = options.output || options.input;
+  if (options.output && !options.force && await pathExists(output)) {
+    throw new Error(`Output already exists: ${output}. Re-run with --force to overwrite.`);
+  }
+
+  const html = await readFile(options.input, "utf8");
+  const componentId = findCompositionId(html, options.componentId);
+  await writeFile(output, injectPreviewControls(html, componentId), "utf8");
+  console.log(`Preview controls written to: ${output}`);
+}
+
+main().catch((error) => {
+  console.error(`Error: ${error.message}`);
+  process.exitCode = 1;
+});