takomi 2.5.1 → 2.5.4

package/assets/.agent/skills/hyperframes-media/scripts/lib/tts.spawn.test.mjs

@@ -1,97 +1,97 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { EventEmitter } from "node:events";
-import { resolveNpxCliFromNpmExecPath, resolveSpawnCommand, spawnP } from "./tts.mjs";
-
-// Regression: on Windows, npx resolves to npx.cmd, which spawn() cannot exec
-// without shell:true — it fails ENOENT, silently swallowed as ok:false by the
-// caller. spawnP takes injectable platform/spawnFn params so this doesn't
-// need to touch the real process.platform or mock node:child_process (whose
-// ESM exports are non-configurable).
-function fakeSpawn(captured) {
-  return (cmd, args, opts) => {
-    captured.push({ cmd, args, opts });
-    const p = new EventEmitter();
-    setImmediate(() => p.emit("exit", 0));
-    return p;
-  };
-}
-
-const envWithNpxCli = {
-  npm_execpath: "/opt/node/lib/node_modules/npm/bin/npm-cli.js",
-  npm_node_execpath: "/opt/node/bin/node",
-};
-const npxCliPath = "/opt/node/lib/node_modules/npm/bin/npx-cli.js";
-const pathExists = (path) => path === npxCliPath;
-
-test("resolveNpxCliFromNpmExecPath finds npx-cli next to npm-cli", () => {
-  assert.equal(resolveNpxCliFromNpmExecPath(envWithNpxCli.npm_execpath, pathExists), npxCliPath);
-});
-
-test("resolveSpawnCommand routes npx through node+npx-cli on win32 without shell:true", () => {
-  const resolved = resolveSpawnCommand(
-    "npx",
-    ["hyperframes", "tts", "C:\\Users\\Test User\\line.txt", "--voice", "am_michael"],
-    {},
-    "win32",
-    envWithNpxCli,
-    pathExists,
-  );
-  assert.ok(resolved);
-  assert.equal(resolved.cmd, envWithNpxCli.npm_node_execpath);
-  assert.deepEqual(resolved.args, [
-    npxCliPath,
-    "hyperframes",
-    "tts",
-    "C:\\Users\\Test User\\line.txt",
-    "--voice",
-    "am_michael",
-  ]);
-  assert.equal(resolved.opts.shell, undefined);
-});
-
-test("resolveSpawnCommand preserves Windows npx shell metacharacters as argv data", () => {
-  const resolved = resolveSpawnCommand(
-    "npx",
-    ["hyperframes", "tts", "hello & calc"],
-    {},
-    "win32",
-    envWithNpxCli,
-    pathExists,
-  );
-  assert.ok(resolved);
-  assert.deepEqual(resolved.args, [npxCliPath, "hyperframes", "tts", "hello & calc"]);
-});
-
-test("spawnP uses the resolved node+npx-cli command for npx on win32", async () => {
-  const captured = [];
-  await spawnP(
-    "npx",
-    ["hyperframes", "tts"],
-    {},
-    "win32",
-    fakeSpawn(captured),
-    envWithNpxCli,
-    pathExists,
-  );
-  assert.equal(captured.length, 1);
-  assert.equal(captured[0].cmd, envWithNpxCli.npm_node_execpath);
-  assert.deepEqual(captured[0].args, [npxCliPath, "hyperframes", "tts"]);
-  assert.equal(captured[0].opts.shell, undefined);
-});
-
-test("spawnP does not enable shell for npx on darwin/linux", async () => {
-  const captured = [];
-  await spawnP("npx", ["hyperframes", "tts"], {}, "darwin", fakeSpawn(captured));
-  assert.equal(captured[0].cmd, "npx");
-  assert.deepEqual(captured[0].args, ["hyperframes", "tts"]);
-  assert.equal(captured[0].opts.shell, undefined);
-});
-
-test("spawnP does not enable shell for non-npx commands even on win32", async () => {
-  const captured = [];
-  await spawnP("python3", ["-c", "pass"], {}, "win32", fakeSpawn(captured));
-  assert.equal(captured[0].cmd, "python3");
-  assert.deepEqual(captured[0].args, ["-c", "pass"]);
-  assert.equal(captured[0].opts.shell, undefined);
-});
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import { resolveNpxCliFromNpmExecPath, resolveSpawnCommand, spawnP } from "./tts.mjs";
+
+// Regression: on Windows, npx resolves to npx.cmd, which spawn() cannot exec
+// without shell:true — it fails ENOENT, silently swallowed as ok:false by the
+// caller. spawnP takes injectable platform/spawnFn params so this doesn't
+// need to touch the real process.platform or mock node:child_process (whose
+// ESM exports are non-configurable).
+function fakeSpawn(captured) {
+  return (cmd, args, opts) => {
+    captured.push({ cmd, args, opts });
+    const p = new EventEmitter();
+    setImmediate(() => p.emit("exit", 0));
+    return p;
+  };
+}
+
+const envWithNpxCli = {
+  npm_execpath: "/opt/node/lib/node_modules/npm/bin/npm-cli.js",
+  npm_node_execpath: "/opt/node/bin/node",
+};
+const npxCliPath = "/opt/node/lib/node_modules/npm/bin/npx-cli.js";
+const pathExists = (path) => path === npxCliPath;
+
+test("resolveNpxCliFromNpmExecPath finds npx-cli next to npm-cli", () => {
+  assert.equal(resolveNpxCliFromNpmExecPath(envWithNpxCli.npm_execpath, pathExists), npxCliPath);
+});
+
+test("resolveSpawnCommand routes npx through node+npx-cli on win32 without shell:true", () => {
+  const resolved = resolveSpawnCommand(
+    "npx",
+    ["hyperframes", "tts", "C:\\Users\\Test User\\line.txt", "--voice", "am_michael"],
+    {},
+    "win32",
+    envWithNpxCli,
+    pathExists,
+  );
+  assert.ok(resolved);
+  assert.equal(resolved.cmd, envWithNpxCli.npm_node_execpath);
+  assert.deepEqual(resolved.args, [
+    npxCliPath,
+    "hyperframes",
+    "tts",
+    "C:\\Users\\Test User\\line.txt",
+    "--voice",
+    "am_michael",
+  ]);
+  assert.equal(resolved.opts.shell, undefined);
+});
+
+test("resolveSpawnCommand preserves Windows npx shell metacharacters as argv data", () => {
+  const resolved = resolveSpawnCommand(
+    "npx",
+    ["hyperframes", "tts", "hello & calc"],
+    {},
+    "win32",
+    envWithNpxCli,
+    pathExists,
+  );
+  assert.ok(resolved);
+  assert.deepEqual(resolved.args, [npxCliPath, "hyperframes", "tts", "hello & calc"]);
+});
+
+test("spawnP uses the resolved node+npx-cli command for npx on win32", async () => {
+  const captured = [];
+  await spawnP(
+    "npx",
+    ["hyperframes", "tts"],
+    {},
+    "win32",
+    fakeSpawn(captured),
+    envWithNpxCli,
+    pathExists,
+  );
+  assert.equal(captured.length, 1);
+  assert.equal(captured[0].cmd, envWithNpxCli.npm_node_execpath);
+  assert.deepEqual(captured[0].args, [npxCliPath, "hyperframes", "tts"]);
+  assert.equal(captured[0].opts.shell, undefined);
+});
+
+test("spawnP does not enable shell for npx on darwin/linux", async () => {
+  const captured = [];
+  await spawnP("npx", ["hyperframes", "tts"], {}, "darwin", fakeSpawn(captured));
+  assert.equal(captured[0].cmd, "npx");
+  assert.deepEqual(captured[0].args, ["hyperframes", "tts"]);
+  assert.equal(captured[0].opts.shell, undefined);
+});
+
+test("spawnP does not enable shell for non-npx commands even on win32", async () => {
+  const captured = [];
+  await spawnP("python3", ["-c", "pass"], {}, "win32", fakeSpawn(captured));
+  assert.equal(captured[0].cmd, "python3");
+  assert.deepEqual(captured[0].args, ["-c", "pass"]);
+  assert.equal(captured[0].opts.shell, undefined);
+});

package/assets/.agent/skills/hyperframes-media/scripts/lib/tts.test.mjs

@@ -1,66 +1,66 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, writeFileSync, chmodSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { parseFfmpegDurationBanner, ffprobeDuration } from "./tts.mjs";
-
-test("parseFfmpegDurationBanner reads ffmpeg's stderr Duration line", () => {
-  const stderr = [
-    "ffmpeg version 6.0",
-    "Input #0, wav, from 'a.wav':",
-    "  Duration: 00:00:03.42, bitrate: 705 kb/s",
-    "At least one output file must be specified",
-  ].join("\n");
-  assert.equal(parseFfmpegDurationBanner(stderr), 3.42);
-});
-
-test("parseFfmpegDurationBanner handles an hours component", () => {
-  const stderr = "  Duration: 01:02:03.50, start: 0.000000, bitrate: 128 kb/s";
-  assert.equal(parseFfmpegDurationBanner(stderr), 3723.5);
-});
-
-test("parseFfmpegDurationBanner returns NaN when there is no Duration line", () => {
-  assert.ok(Number.isNaN(parseFfmpegDurationBanner("ffmpeg: command not found")));
-  assert.ok(Number.isNaN(parseFfmpegDurationBanner("")));
-  assert.ok(Number.isNaN(parseFfmpegDurationBanner(undefined)));
-});
-
-// Regression for the actual bug: ffprobeDuration used to collapse "ffprobe
-// binary is missing" (ENOENT — the "essentials"-style Windows ffmpeg build
-// with no ffprobe.exe) and "file is genuinely unreadable" into the same NaN,
-// giving audio.mjs no way to tell "measure differently" from "give up".
-//
-// Builds an isolated PATH containing only a fake `ffmpeg` stub (no `ffprobe`
-// at all) so ffprobeDuration's spawnSync("ffprobe", ...) call ENOENTs for
-// real, then verifies it recovers the duration via the ffmpeg fallback
-// instead of returning NaN.
-test("ffprobeDuration falls back to ffmpeg when the ffprobe binary itself is missing", () => {
-  const dir = mkdtempSync(join(tmpdir(), "tts-ffprobe-fallback-"));
-  const fakeFfmpeg = join(dir, "ffmpeg");
-  writeFileSync(
-    fakeFfmpeg,
-    "#!/bin/sh\necho 'Duration: 00:00:02.50, start: 0.000000, bitrate: 128 kb/s' 1>&2\nexit 1\n",
-  );
-  chmodSync(fakeFfmpeg, 0o755);
-  const originalPath = process.env.PATH;
-  try {
-    process.env.PATH = dir; // only the fake ffmpeg resolves; no real ffprobe on this PATH
-    assert.equal(ffprobeDuration("/does/not/matter.wav"), 2.5);
-  } finally {
-    process.env.PATH = originalPath;
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("ffprobeDuration returns NaN when neither ffprobe nor ffmpeg resolve", () => {
-  const dir = mkdtempSync(join(tmpdir(), "tts-no-binaries-"));
-  const originalPath = process.env.PATH;
-  try {
-    process.env.PATH = dir; // empty directory — nothing resolves
-    assert.ok(Number.isNaN(ffprobeDuration("/does/not/matter.wav")));
-  } finally {
-    process.env.PATH = originalPath;
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, writeFileSync, chmodSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { parseFfmpegDurationBanner, ffprobeDuration } from "./tts.mjs";
+
+test("parseFfmpegDurationBanner reads ffmpeg's stderr Duration line", () => {
+  const stderr = [
+    "ffmpeg version 6.0",
+    "Input #0, wav, from 'a.wav':",
+    "  Duration: 00:00:03.42, bitrate: 705 kb/s",
+    "At least one output file must be specified",
+  ].join("\n");
+  assert.equal(parseFfmpegDurationBanner(stderr), 3.42);
+});
+
+test("parseFfmpegDurationBanner handles an hours component", () => {
+  const stderr = "  Duration: 01:02:03.50, start: 0.000000, bitrate: 128 kb/s";
+  assert.equal(parseFfmpegDurationBanner(stderr), 3723.5);
+});
+
+test("parseFfmpegDurationBanner returns NaN when there is no Duration line", () => {
+  assert.ok(Number.isNaN(parseFfmpegDurationBanner("ffmpeg: command not found")));
+  assert.ok(Number.isNaN(parseFfmpegDurationBanner("")));
+  assert.ok(Number.isNaN(parseFfmpegDurationBanner(undefined)));
+});
+
+// Regression for the actual bug: ffprobeDuration used to collapse "ffprobe
+// binary is missing" (ENOENT — the "essentials"-style Windows ffmpeg build
+// with no ffprobe.exe) and "file is genuinely unreadable" into the same NaN,
+// giving audio.mjs no way to tell "measure differently" from "give up".
+//
+// Builds an isolated PATH containing only a fake `ffmpeg` stub (no `ffprobe`
+// at all) so ffprobeDuration's spawnSync("ffprobe", ...) call ENOENTs for
+// real, then verifies it recovers the duration via the ffmpeg fallback
+// instead of returning NaN.
+test("ffprobeDuration falls back to ffmpeg when the ffprobe binary itself is missing", () => {
+  const dir = mkdtempSync(join(tmpdir(), "tts-ffprobe-fallback-"));
+  const fakeFfmpeg = join(dir, "ffmpeg");
+  writeFileSync(
+    fakeFfmpeg,
+    "#!/bin/sh\necho 'Duration: 00:00:02.50, start: 0.000000, bitrate: 128 kb/s' 1>&2\nexit 1\n",
+  );
+  chmodSync(fakeFfmpeg, 0o755);
+  const originalPath = process.env.PATH;
+  try {
+    process.env.PATH = dir; // only the fake ffmpeg resolves; no real ffprobe on this PATH
+    assert.equal(ffprobeDuration("/does/not/matter.wav"), 2.5);
+  } finally {
+    process.env.PATH = originalPath;
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("ffprobeDuration returns NaN when neither ffprobe nor ffmpeg resolve", () => {
+  const dir = mkdtempSync(join(tmpdir(), "tts-no-binaries-"));
+  const originalPath = process.env.PATH;
+  try {
+    process.env.PATH = dir; // empty directory — nothing resolves
+    assert.ok(Number.isNaN(ffprobeDuration("/does/not/matter.wav")));
+  } finally {
+    process.env.PATH = originalPath;
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/assets/.agent/skills/hyperframes-media/scripts/lyria-recipe.py

@@ -1,128 +1,128 @@
-#!/usr/bin/env python3
-"""Generate BGM using Google Lyria RealTime API.
-
-Usage:
-    python lyria-recipe.py --output <path> --duration <seconds> [tuning flags]
-
-Requires:
-    $GOOGLE_API_KEY or $GEMINI_API_KEY environment variable (treated as aliases).
-    pip install google-genai python-dotenv. audio.mjs Step 4b installs these on
-    demand when a key is set but google.genai is not importable; if that install
-    fails it falls back to local MusicGen rather than leaving the video with no BGM.
-"""
-
-from __future__ import annotations
-
-import argparse
-import asyncio
-import os
-import sys
-import wave
-from pathlib import Path
-
-DEFAULT_PROMPT = "Uplifting corporate tech, bright and modern, gentle piano with synth pads"
-SAMPLE_RATE = 48000
-CHANNELS = 2
-SAMPLE_WIDTH = 2  # 16-bit
-
-
-def parse_args() -> argparse.Namespace:
-    p = argparse.ArgumentParser(description="Generate BGM via Google Lyria RealTime.")
-    p.add_argument("--output", required=True, help="Output WAV path.")
-    p.add_argument("--duration", type=float, required=True, help="Target duration in seconds.")
-    p.add_argument("--prompt", default=DEFAULT_PROMPT, help="Mood / instrumentation prompt.")
-    p.add_argument("--negative-prompt", default=None, help="Styles to exclude (optional).")
-    p.add_argument("--bpm", type=int, default=110)
-    p.add_argument("--brightness", type=float, default=0.8, help="0-1, higher = brighter mood.")
-    p.add_argument("--density", type=float, default=0.5, help="0-1, higher = fuller mix.")
-    p.add_argument(
-        "--scale",
-        default="MAJOR",
-        help="MAJOR / MINOR / PENTATONIC / etc. — see google.genai.types.Scale. Pass empty string for none.",
-    )
-    return p.parse_args()
-
-
-async def generate_bgm(args: argparse.Namespace) -> dict:
-    from google import genai
-    from google.genai import types
-
-    api_key = os.environ.get("GOOGLE_API_KEY") or os.environ.get("GEMINI_API_KEY") or ""
-    if not api_key:
-        raise RuntimeError("Neither GOOGLE_API_KEY nor GEMINI_API_KEY is set.")
-
-    client = genai.Client(
-        api_key=api_key,
-        http_options={"api_version": "v1alpha"},
-    )
-
-    out_path = Path(args.output)
-    out_path.parent.mkdir(parents=True, exist_ok=True)
-
-    target_bytes = int(args.duration * SAMPLE_RATE * CHANNELS * SAMPLE_WIDTH)
-
-    cfg: dict = {"bpm": args.bpm, "temperature": 1.0}
-    if args.density is not None:
-        cfg["density"] = args.density
-    if args.brightness is not None:
-        cfg["brightness"] = args.brightness
-    if args.scale:
-        scale_enum = getattr(types.Scale, args.scale, None)
-        if scale_enum:
-            cfg["scale"] = scale_enum
-
-    prompts = [types.WeightedPrompt(text=args.prompt, weight=1.0)]
-    if args.negative_prompt:
-        prompts.append(types.WeightedPrompt(text=args.negative_prompt, weight=-1.0))
-
-    buf = bytearray()
-    timeout = args.duration + 8
-
-    async with client.aio.live.music.connect(
-        model="models/lyria-realtime-exp",
-    ) as session:
-        await session.set_weighted_prompts(prompts=prompts)
-        await session.set_music_generation_config(
-            config=types.LiveMusicGenerationConfig(**cfg),
-        )
-        await session.play()
-
-        async def collect():
-            while len(buf) < target_bytes:
-                async for msg in session.receive():
-                    sc = msg.server_content
-                    if sc and sc.audio_chunks:
-                        for chunk in sc.audio_chunks:
-                            buf.extend(chunk.data)
-                            if len(buf) >= target_bytes:
-                                return
-                await asyncio.sleep(1e-6)
-
-        try:
-            await asyncio.wait_for(collect(), timeout=timeout)
-        except TimeoutError:
-            print(f"Timeout after {timeout:.0f}s, collected {len(buf)} bytes", file=sys.stderr)
-
-    audio = bytes(buf[:target_bytes])
-    with wave.open(str(out_path), "wb") as wf:
-        wf.setnchannels(CHANNELS)
-        wf.setsampwidth(SAMPLE_WIDTH)
-        wf.setframerate(SAMPLE_RATE)
-        wf.writeframes(audio)
-
-    actual_duration = len(audio) / (SAMPLE_RATE * CHANNELS * SAMPLE_WIDTH)
-    print(f"BGM: {out_path} ({actual_duration:.2f}s)")
-    return {"file": str(out_path), "duration_sec": round(actual_duration, 2)}
-
-
-def main() -> None:
-    args = parse_args()
-    try:
-        asyncio.run(generate_bgm(args))
-    except RuntimeError as exc:
-        print(f"BGM generation failed: {exc}", file=sys.stderr)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()
+#!/usr/bin/env python3
+"""Generate BGM using Google Lyria RealTime API.
+
+Usage:
+    python lyria-recipe.py --output <path> --duration <seconds> [tuning flags]
+
+Requires:
+    $GOOGLE_API_KEY or $GEMINI_API_KEY environment variable (treated as aliases).
+    pip install google-genai python-dotenv. audio.mjs Step 4b installs these on
+    demand when a key is set but google.genai is not importable; if that install
+    fails it falls back to local MusicGen rather than leaving the video with no BGM.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import os
+import sys
+import wave
+from pathlib import Path
+
+DEFAULT_PROMPT = "Uplifting corporate tech, bright and modern, gentle piano with synth pads"
+SAMPLE_RATE = 48000
+CHANNELS = 2
+SAMPLE_WIDTH = 2  # 16-bit
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="Generate BGM via Google Lyria RealTime.")
+    p.add_argument("--output", required=True, help="Output WAV path.")
+    p.add_argument("--duration", type=float, required=True, help="Target duration in seconds.")
+    p.add_argument("--prompt", default=DEFAULT_PROMPT, help="Mood / instrumentation prompt.")
+    p.add_argument("--negative-prompt", default=None, help="Styles to exclude (optional).")
+    p.add_argument("--bpm", type=int, default=110)
+    p.add_argument("--brightness", type=float, default=0.8, help="0-1, higher = brighter mood.")
+    p.add_argument("--density", type=float, default=0.5, help="0-1, higher = fuller mix.")
+    p.add_argument(
+        "--scale",
+        default="MAJOR",
+        help="MAJOR / MINOR / PENTATONIC / etc. — see google.genai.types.Scale. Pass empty string for none.",
+    )
+    return p.parse_args()
+
+
+async def generate_bgm(args: argparse.Namespace) -> dict:
+    from google import genai
+    from google.genai import types
+
+    api_key = os.environ.get("GOOGLE_API_KEY") or os.environ.get("GEMINI_API_KEY") or ""
+    if not api_key:
+        raise RuntimeError("Neither GOOGLE_API_KEY nor GEMINI_API_KEY is set.")
+
+    client = genai.Client(
+        api_key=api_key,
+        http_options={"api_version": "v1alpha"},
+    )
+
+    out_path = Path(args.output)
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+
+    target_bytes = int(args.duration * SAMPLE_RATE * CHANNELS * SAMPLE_WIDTH)
+
+    cfg: dict = {"bpm": args.bpm, "temperature": 1.0}
+    if args.density is not None:
+        cfg["density"] = args.density
+    if args.brightness is not None:
+        cfg["brightness"] = args.brightness
+    if args.scale:
+        scale_enum = getattr(types.Scale, args.scale, None)
+        if scale_enum:
+            cfg["scale"] = scale_enum
+
+    prompts = [types.WeightedPrompt(text=args.prompt, weight=1.0)]
+    if args.negative_prompt:
+        prompts.append(types.WeightedPrompt(text=args.negative_prompt, weight=-1.0))
+
+    buf = bytearray()
+    timeout = args.duration + 8
+
+    async with client.aio.live.music.connect(
+        model="models/lyria-realtime-exp",
+    ) as session:
+        await session.set_weighted_prompts(prompts=prompts)
+        await session.set_music_generation_config(
+            config=types.LiveMusicGenerationConfig(**cfg),
+        )
+        await session.play()
+
+        async def collect():
+            while len(buf) < target_bytes:
+                async for msg in session.receive():
+                    sc = msg.server_content
+                    if sc and sc.audio_chunks:
+                        for chunk in sc.audio_chunks:
+                            buf.extend(chunk.data)
+                            if len(buf) >= target_bytes:
+                                return
+                await asyncio.sleep(1e-6)
+
+        try:
+            await asyncio.wait_for(collect(), timeout=timeout)
+        except TimeoutError:
+            print(f"Timeout after {timeout:.0f}s, collected {len(buf)} bytes", file=sys.stderr)
+
+    audio = bytes(buf[:target_bytes])
+    with wave.open(str(out_path), "wb") as wf:
+        wf.setnchannels(CHANNELS)
+        wf.setsampwidth(SAMPLE_WIDTH)
+        wf.setframerate(SAMPLE_RATE)
+        wf.writeframes(audio)
+
+    actual_duration = len(audio) / (SAMPLE_RATE * CHANNELS * SAMPLE_WIDTH)
+    print(f"BGM: {out_path} ({actual_duration:.2f}s)")
+    return {"file": str(out_path), "duration_sec": round(actual_duration, 2)}
+
+
+def main() -> None:
+    args = parse_args()
+    try:
+        asyncio.run(generate_bgm(args))
+    except RuntimeError as exc:
+        print(f"BGM generation failed: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()