reelforge 1.18.2

package/dist/commands/audio.js

@@ -0,0 +1,73 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { uploadMultipart, post } from "../client.js";
+import { print } from "../utils/output.js";
+export function registerAudio(program) {
+    const audio = program
+        .command("audio")
+        .description("音频原子能力: 转写 (音频 → 文字 + 词级时间戳)")
+        .helpOption("-h, --help", "show help");
+    audio
+        .command("transcribe")
+        .description("Transcribe an audio file to text + word-level timestamps")
+        .helpOption("-h, --help", "show help")
+        .option("-f, --file <path>", "local audio file (mp3/wav/m4a). Use this OR --url.")
+        .option("-u, --url <url>", "remote audio URL — server downloads and transcribes.")
+        .option("-l, --language <code>", "language hint (e.g. zh, en). Optional — auto-detected.")
+        .option("-m, --model <id>", "override the ASR model id (defaults to the server's)")
+        .option("-o, --output <file>", "write the full JSON response to this file as well as stdout")
+        .addHelpText("after", [
+        "",
+        "Examples:",
+        " rf audio transcribe -f ./narration.mp3",
+        " rf audio transcribe --url https://example.com/clip.mp3 --language zh",
+        " rf audio transcribe -f ./voice.wav --json | jq '.words[:5]'",
+    ].join("\n"))
+        .action(async (opts) => {
+        if (!opts.file && !opts.url) {
+            throw new Error("either --file or --url is required");
+        }
+        if (opts.file && opts.url) {
+            throw new Error("--file and --url are mutually exclusive");
+        }
+        let r;
+        if (opts.file) {
+            const buf = await fs.readFile(opts.file);
+            const filename = path.basename(opts.file);
+            const ext = path.extname(filename).toLowerCase();
+            const mime = ext === ".wav" ? "audio/wav" :
+                ext === ".m4a" ? "audio/mp4" :
+                    ext === ".flac" ? "audio/flac" :
+                        ext === ".ogg" ? "audio/ogg" :
+                            "audio/mpeg";
+            const fileBlob = new File([new Uint8Array(buf)], filename, { type: mime });
+            const fields = { file: fileBlob };
+            if (opts.language)
+                fields.language = opts.language;
+            if (opts.model)
+                fields.model = opts.model;
+            r = await uploadMultipart("/api/v1/audio/transcribe", fields);
+        }
+        else {
+            const body = { audio_url: opts.url };
+            if (opts.language)
+                body.language = opts.language;
+            if (opts.model)
+                body.model = opts.model;
+            r = await post("/api/v1/audio/transcribe", body);
+        }
+        if (opts.output) {
+            await fs.writeFile(opts.output, JSON.stringify(r, null, 2), "utf-8");
+        }
+        print({
+            model: r.model,
+            language: r.language,
+            duration: r.duration,
+            text: r.text,
+            n_segments: r.segments.length,
+            n_words: r.words.length,
+            segments: r.segments,
+            words: r.words,
+        });
+    });
+}

package/dist/commands/auth.js

@@ -0,0 +1,170 @@
+import http from "node:http";
+import crypto from "node:crypto";
+import os from "node:os";
+import { spawn } from "node:child_process";
+import { get, setApiKey, setServer, getServer } from "../client.js";
+import { loadConfig, saveConfig, deleteConfig, getConfigPath } from "../utils/config-file.js";
+import { info, success, print, table, formatUsd } from "../utils/output.js";
+function openBrowser(url) {
+    const cmd = process.platform === "darwin"
+        ? "open"
+        : process.platform === "win32"
+            ? "rundll32"
+            : "xdg-open";
+    const args = process.platform === "win32"
+        ? ["url.dll,FileProtocolHandler", url]
+        : [url];
+    try {
+        spawn(cmd, args, { detached: true, stdio: "ignore" }).unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function browserOAuthFlow(serverUrl) {
+    const state = crypto.randomBytes(16).toString("hex");
+    const hostname = (os.hostname() || "device").slice(0, 64);
+    return new Promise((resolve, reject) => {
+        let timer = null;
+        const server = http.createServer((req, res) => {
+            const url = new URL(req.url || "/", "http://127.0.0.1");
+            if (url.pathname !== "/cb") {
+                res.writeHead(404, { "Content-Type": "text/plain" }).end("Not found");
+                return;
+            }
+            const gotState = url.searchParams.get("state");
+            const token = url.searchParams.get("token");
+            const errCode = url.searchParams.get("error");
+            const finish = (statusCode, title, body, outcome) => {
+                res.writeHead(statusCode, {
+                    "Content-Type": "text/html; charset=utf-8",
+                    Connection: "close",
+                }).end(`<!DOCTYPE html><html lang="zh-CN"><head><meta charset="utf-8"><title>ReelForge CLI</title><style>body{font-family:-apple-system,system-ui,"Segoe UI",sans-serif;display:flex;align-items:center;justify-content:center;min-height:100vh;margin:0;background:#fafaf7;color:#222}div{text-align:center;max-width:24rem;padding:1.5rem}h1{font-size:1.5rem;margin:0 0 .5rem;font-weight:600}p{color:#666;font-size:.875rem;line-height:1.5}</style></head><body><div><h1>${title}</h1><p>${body}</p></div><script>setTimeout(()=>window.close?.(),2000)</script></body></html>`);
+                if (timer)
+                    clearTimeout(timer);
+                server.close();
+                server.closeAllConnections?.();
+                if (outcome.ok)
+                    resolve(outcome.token);
+                else
+                    reject(outcome.err);
+            };
+            if (gotState !== state) {
+                finish(400, "授权失败", "state 不匹配，可能是 CSRF。请重新跑 reelforge login。", {
+                    ok: false,
+                    err: new Error("state mismatch"),
+                });
+                return;
+            }
+            if (errCode || !token) {
+                finish(400, "授权被取消", "可以关闭此页面回到 CLI。", {
+                    ok: false,
+                    err: new Error(errCode || "no token returned"),
+                });
+                return;
+            }
+            finish(200, "✓ 授权成功", "可以关闭此页面，CLI 已自动接收 key。", {
+                ok: true,
+                token,
+            });
+        });
+        server.listen(0, "127.0.0.1", () => {
+            const addr = server.address();
+            const port = typeof addr === "object" && addr ? addr.port : 0;
+            const callback = `http://127.0.0.1:${port}/cb`;
+            const authUrl = new URL("/cli-auth", serverUrl);
+            authUrl.searchParams.set("callback", callback);
+            authUrl.searchParams.set("state", state);
+            authUrl.searchParams.set("hostname", hostname);
+            info(`Listening on ${callback}`);
+            info("正在打开浏览器完成授权...");
+            const opened = openBrowser(authUrl.toString());
+            if (!opened) {
+                info("(打开浏览器失败，请手动访问以下 URL):");
+                info(authUrl.toString());
+            }
+            else {
+                info(`(如果浏览器没自动弹出，请手动访问: ${authUrl.toString()})`);
+            }
+        });
+        timer = setTimeout(() => {
+            server.close();
+            reject(new Error("授权超时（5 分钟）。请重新跑 reelforge login"));
+        }, 5 * 60 * 1000);
+    });
+}
+export function registerAuth(program) {
+    program
+        .command("login [api_key]")
+        .description("登录: 不带参数自动开浏览器 OAuth; 带 api_key 直接保存")
+        .helpOption("-h, --help", "show help")
+        .option("--server <url>", "also persist a custom server URL")
+        .addHelpText("after", [
+        "",
+        "Examples:",
+        "  reelforge login                            # browser OAuth (recommended)",
+        "  reelforge login JK1234567890ABCDEF         # manual paste (SSH / headless)",
+        "  reelforge login --server http://nas:8501   # OAuth against a self-hosted server",
+        "",
+        "The token is verified against /api/v1/me before being saved.",
+    ].join("\n"))
+        .action(async (apiKey, opts) => {
+        if (opts.server)
+            setServer(opts.server);
+        let token;
+        if (apiKey) {
+            token = apiKey;
+        }
+        else {
+            info(`Starting browser OAuth against ${getServer()}`);
+            token = await browserOAuthFlow(getServer());
+        }
+        setApiKey(token);
+        const me = await get("/api/v1/me");
+        const existing = await loadConfig();
+        const saved = await saveConfig({
+            ...existing,
+            api_key: token,
+            ...(opts.server ? { server: opts.server } : {}),
+        });
+        success(`Saved → ${saved}`);
+        info(`Account: ${me.account.account_number}${me.account.label ? ` · ${me.account.label}` : ""}`);
+        info(`Balance: ${formatUsd(me.account.balance / 1_000_000)}`);
+        info(`Server:  ${getServer()}`);
+    });
+    program
+        .command("logout")
+        .description("登出: 删除本地保存的 API key 和 server")
+        .helpOption("-h, --help", "show help")
+        .action(async () => {
+        const path = getConfigPath();
+        const deleted = await deleteConfig();
+        if (deleted) {
+            success(`Deleted ${path}`);
+        }
+        else {
+            info(`No config to delete (${path} not found)`);
+        }
+    });
+    program
+        .command("whoami")
+        .description("查看当前账户: 余额 / API key 列表 / 调用统计")
+        .helpOption("-h, --help", "show help")
+        .action(async () => {
+        const me = await get("/api/v1/me");
+        print({
+            account: me.account,
+        });
+        if (me.api_keys.length) {
+            info(`API keys (${me.api_keys.length}):`);
+            table(me.api_keys.map((k) => ({
+                id: k.id,
+                api_key: k.api_key,
+                label: k.label ?? "",
+                status: k.status,
+                last_used_at: k.last_used_at ?? "—",
+            })));
+        }
+    });
+}

package/dist/commands/bgm.js

@@ -0,0 +1,45 @@
+import fs from "node:fs";
+import path from "node:path";
+import { del, get, uploadMultipart } from "../client.js";
+import { print, table, success, bytes } from "../utils/output.js";
+export function registerBgm(program) {
+    const bgm = program
+        .command("bgm")
+        .description("BGM 库管理 (内置 + 用户上传)")
+        .helpOption("-h, --help", "show help");
+    bgm
+        .command("list")
+        .description("List all BGM files (default + user-uploaded)")
+        .helpOption("-h, --help", "show help")
+        .action(async () => {
+        const r = await get("/api/v1/bgm");
+        table(r.bgm.map((b) => ({
+            name: b.name,
+            size: bytes(b.size_bytes),
+            source: b.source,
+            path: b.relative_path,
+        })));
+    });
+    bgm
+        .command("upload <file>")
+        .description("Upload a new BGM file (saved under data/bgm/)")
+        .helpOption("-h, --help", "show help")
+        .action(async (file) => {
+        const abs = path.resolve(file);
+        const buf = fs.readFileSync(abs);
+        const name = path.basename(abs);
+        const fileObj = new File([new Uint8Array(buf)], name, { type: "audio/mpeg" });
+        const r = await uploadMultipart("/api/v1/bgm", { file: fileObj });
+        success(`Uploaded ${name}`);
+        print(r);
+    });
+    bgm
+        .command("delete <name>")
+        .alias("rm")
+        .description("Delete a user-uploaded BGM (default repo BGM is protected)")
+        .helpOption("-h, --help", "show help")
+        .action(async (name) => {
+        const r = await del(`/api/v1/bgm/${encodeURIComponent(name)}`);
+        print(r);
+    });
+}

package/dist/commands/compose.js

@@ -0,0 +1,293 @@
+import fs from "node:fs/promises";
+import fsSync from "node:fs";
+import path from "node:path";
+import { post, getServer } from "../client.js";
+import { waitForTask } from "../utils/task-waiter.js";
+import { downloadTo } from "../utils/download.js";
+import { formatUsd, humanDuration, info, print, success, warn } from "../utils/output.js";
+const EXT_TO_MIME = {
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".m4a": "audio/mp4",
+    ".ogg": "audio/ogg",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+    ".mp4": "video/mp4",
+    ".mov": "video/quicktime",
+    ".webm": "video/webm",
+};
+function fmtSize(bytes) {
+    if (!bytes)
+        return "0";
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+function listSpecPaths(spec) {
+    const paths = new Set();
+    if (spec.audio.narration)
+        paths.add(spec.audio.narration);
+    if (spec.audio.bgm)
+        paths.add(spec.audio.bgm);
+    for (const s of spec.scenes) {
+        if (s.image)
+            paths.add(s.image);
+        if (s.video)
+            paths.add(s.video);
+    }
+    if (spec.cover)
+        paths.add(spec.cover.image);
+    if (spec.brand?.logo)
+        paths.add(spec.brand.logo);
+    return [...paths];
+}
+async function readAsDataUri(specPath, baseDir) {
+    const abs = path.isAbsolute(specPath) ? specPath : path.resolve(baseDir, specPath);
+    if (!fsSync.existsSync(abs)) {
+        throw new Error(`compose: spec references "${specPath}" but file not found at ${abs}`);
+    }
+    const ext = path.extname(abs).toLowerCase();
+    const mime = EXT_TO_MIME[ext];
+    if (!mime) {
+        throw new Error(`compose: unsupported file extension "${ext}" (path: ${abs}). Supported: ` +
+            Object.keys(EXT_TO_MIME).join(" / "));
+    }
+    const buf = await fs.readFile(abs);
+    return { dataUri: `data:${mime};base64,${buf.toString("base64")}`, bytes: buf.byteLength };
+}
+const EXAMPLE_SPEC_HINT = `{
+  "experimental": "compose.v2",
+  "audio": { "narration": "./narration.mp3" },
+  "scenes": [
+    { "start_sec": 0,  "end_sec": 5,  "image": "./s1.png",  "motion": "zoom-in"   },
+    { "start_sec": 5,  "end_sec": 11, "video": "./clip.mp4", "muted": true        }
+  ],
+  "subtitles": [
+    { "start_sec": 0, "end_sec": 5,  "text": "为什么咖啡因让人精神" },
+    { "start_sec": 5, "end_sec": 11, "text": "原来它跟睡眠物质是同一把钥匙" }
+  ],
+  "title": "咖啡因的真相"
+}`;
+const EXAMPLE_SPEC_V3_HINT = `{
+  "experimental": "compose.v3",
+  "audio": { "tts_voice": "熊小二" },
+  "scenes": [
+    {
+      "video": "./s1.mp4", "muted": true,
+      "narration": ["今天热得不行", "我跑厕所睡觉"],
+      "intro_title": "热到躲厕所"
+    },
+    {
+      "image": "./splash.jpg",
+      "narration": ["主人你找拖鞋去吧"]
+    }
+  ],
+  "subtitle_style": "stroke",
+  "title": "贼喵被抓现行"
+}`;
+export function registerCompose(program) {
+    program
+        .command("compose <spec>")
+        .description("⚠️ EXPERIMENTAL · 从 JSON spec 渲染 MP4 — 调用方精确指定每个 scene 的图/视频 / 时间 / 字幕")
+        .helpOption("-h, --help", "show help")
+        .option("-o, --output <file>", "output MP4 path. Default: <spec-basename>.mp4 in cwd")
+        .option("--preview-only", "build the composition and return preview URLs; skip MP4 render (faster + cheaper iteration)")
+        .option("--poll-ms <ms>", "poll interval while waiting", (v) => parseInt(v, 10), 1500)
+        .option("--timeout-ms <ms>", "max wait time before aborting", (v) => parseInt(v, 10))
+        .option("--watch", "监听 spec.json,每次保存让 server 重建 HF preview(自动 --preview-only,不渲 MP4),打印一个 preview URL — 任何设备浏览器打开即可看效果。Ctrl-C 退出")
+        .option("--watch-debounce-ms <ms>", "watch 模式下文件变化的 debounce 时长", (v) => parseInt(v, 10), 400)
+        .addHelpText("after", [
+        "",
+        "⚠️ Schema versioning",
+        "  Two schemas coexist; the server picks one via spec.experimental.",
+        "    compose.v2 — you write every start_sec/end_sec yourself.",
+        "    compose.v3 — audio-first: server runs TTS+ASR and derives times.",
+        "  Both are EXPERIMENTAL; pin your CLI (e.g. reelforge@1.16.x) if you",
+        "  build an agent against them.",
+        "",
+        "compose.v2 minimal example (manual timing):",
+        EXAMPLE_SPEC_HINT,
+        "",
+        "compose.v3 minimal example (audio-first, recommended for short videos):",
+        EXAMPLE_SPEC_V3_HINT,
+        "",
+        "Path resolution:",
+        "  File paths in the spec are resolved RELATIVE to the spec.json's",
+        "  directory. Absolute paths are also accepted. The CLI reads each",
+        "  file and base64-encodes it into the request body — no separate",
+        "  upload step needed.",
+        "",
+        "Supported file types:",
+        "  audio:  .mp3 .wav .m4a .ogg",
+        "  image:  .png .jpg .jpeg .webp",
+        "  video:  .mp4 .mov .webm",
+        "",
+        "Scene visuals:",
+        "  Each scene has exactly one of `image` or `video`. Video scenes",
+        "  play their source clip; if the clip is shorter than the scene",
+        "  window, the last frame freezes (Ken-Burns continues, so the held",
+        "  shot doesn't look frozen). Use `muted: true` to silence the clip's",
+        "  own audio — default lets it mix with the narration.",
+        "",
+        "Size limits:",
+        "  total decoded payload ≤ 55 MB (server cap). Stays in the safe-upload",
+        "  envelope. Typical 30s spec (5 scenes + narration) is ~5-10 MB.",
+        "",
+        "Examples:",
+        "  # Render directly to a file",
+        "  rf compose ./my-video-spec.json -o ./output.mp4",
+        "",
+        "  # Preview only — prints preview URL, no MP4 yet (~2 min, ~$0.05)",
+        "  rf compose ./my-video-spec.json --preview-only",
+        "",
+        "  # Watch mode — 编辑 spec → 保存 → server 重建 preview → CLI 打印 URL,手机/浏览器点开看效果",
+        "  rf compose ./my-video-spec.json --watch",
+        "",
+        "  # JSON output (parse from agent)",
+        "  rf compose ./my-video-spec.json --json",
+        "",
+        "Full schema reference + worked examples (cognitive science / mixed",
+        "image+video / dual-language financial / minimal) live at:",
+        "  docs/compose-spec.md in the ReelForge repo",
+        "",
+        "Use-case workflows (compose is the generic primitive; use-case SOPs",
+        "live under their own namespace):",
+        "  rf assets workflow      用户素材 → 视频 工作流",
+        "",
+        "(`rf` works wherever you see `reelforge`)",
+    ].join("\n"))
+        .action(async (specPathArg, opts) => {
+        const specPath = path.resolve(specPathArg);
+        if (!fsSync.existsSync(specPath)) {
+            throw new Error(`spec not found: ${specPath}`);
+        }
+        await renderComposeOnce(specPath, opts);
+        if (opts.watch) {
+            await runWatchLoop(specPath, opts);
+        }
+    });
+}
+async function renderComposeOnce(specPath, opts) {
+    let spec;
+    try {
+        const raw = await fs.readFile(specPath, "utf-8");
+        spec = JSON.parse(raw);
+    }
+    catch (e) {
+        throw new Error(`failed to read / parse spec ${specPath}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    if (spec.experimental !== "compose.v2" && spec.experimental !== "compose.v3") {
+        throw new Error(`spec.experimental must be "compose.v2" or "compose.v3" (got: ${JSON.stringify(spec.experimental)}). ` +
+            `See docs/compose-spec.md or docs/assets-to-video-workflow.md.`);
+    }
+    const baseDir = path.dirname(specPath);
+    info(`Reading spec from ${specPath}...`);
+    const specPaths = listSpecPaths(spec);
+    const files = {};
+    let totalBytes = 0;
+    for (const p of specPaths) {
+        const r = await readAsDataUri(p, baseDir);
+        files[p] = r.dataUri;
+        totalBytes += r.bytes;
+    }
+    info(`Bundling ${specPaths.length} files (${fmtSize(totalBytes)} total)...`);
+    const body = { spec, files };
+    if (opts.previewOnly)
+        body.preview_only = true;
+    const submitted = await post("/api/v1/compose", body);
+    info(`Submitted task: ${submitted.task_id}`);
+    const t = await waitForTask(submitted.task_id, {
+        pollMs: opts.pollMs,
+        timeoutMs: opts.timeoutMs,
+    });
+    if (t.status !== "completed") {
+        throw new Error(t.error || `Task ended with status ${t.status}`);
+    }
+    const result = t.result;
+    const serverBase = getServer().replace(/\/+$/, "");
+    const previewPageAbs = result?.preview_urls?.page ? serverBase + result.preview_urls.page : undefined;
+    const previewPlayerAbs = result?.preview_urls?.player ? serverBase + result.preview_urls.player : undefined;
+    if (previewPageAbs)
+        info(`Preview page: ${previewPageAbs}`);
+    if (previewPlayerAbs)
+        info(`Player only: ${previewPlayerAbs}`);
+    if (result?.render_pending) {
+        info(`MP4 render skipped (--preview-only). Run \`rf render ${t.id}\` to finalize.`);
+    }
+    else if (result?.video_url) {
+        const stdoutIsPipe = !process.stdout.isTTY;
+        const skipDownload = stdoutIsPipe && !opts.output;
+        let savedPath;
+        if (opts.output) {
+            savedPath = opts.output;
+        }
+        else if (!skipDownload) {
+            const stem = path.parse(specPath).name;
+            savedPath = path.resolve(`${stem}-${t.id.slice(0, 8)}.mp4`);
+        }
+        if (savedPath) {
+            await downloadTo(result.video_url, savedPath);
+            success(`Saved → ${savedPath}`);
+        }
+    }
+    if (result?.generation_ms != null) {
+        const gen = humanDuration(result.generation_ms);
+        const playback = result.duration != null ? `, video ${result.duration.toFixed(1)}s` : "";
+        info(`generated in ${gen}${playback}`);
+    }
+    if (result?.price_usd != null)
+        info(`charge: ${formatUsd(result.price_usd)}`);
+    print({ task_id: t.id, status: t.status, ...result });
+}
+async function runWatchLoop(specPath, opts) {
+    const debounceMs = opts.watchDebounceMs ?? 400;
+    const watchOpts = { ...opts, previewOnly: true };
+    if (opts.output) {
+        warn(`   --output is ignored in --watch mode (preview-only — no MP4 is produced)`);
+    }
+    info(`👀 watching ${specPath} — preview iteration mode`);
+    info(`   server: ${getServer()}`);
+    info(`   each save → server rebuilds preview (NO MP4 render) → prints URL`);
+    info(`   open the URL on any device (phone / laptop) to scrub HF player`);
+    info(`   Ctrl-C to stop`);
+    let running = false;
+    let queued = false;
+    let debounceTimer = null;
+    const rerender = async () => {
+        if (running) {
+            queued = true;
+            return;
+        }
+        running = true;
+        try {
+            const t0 = Date.now();
+            info(`\n— rebuild —`);
+            await renderComposeOnce(specPath, watchOpts);
+            info(`✓ rebuilt in ${humanDuration(Date.now() - t0)}; refresh / open the URL above`);
+        }
+        catch (e) {
+            warn(`✗ rebuild failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        finally {
+            running = false;
+            if (queued) {
+                queued = false;
+                setTimeout(rerender, 50);
+            }
+        }
+    };
+    fsSync.watch(specPath, () => {
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(rerender, debounceMs);
+    });
+    process.on("SIGINT", () => {
+        info("\n👋 watch stopped");
+        process.exit(0);
+    });
+    await new Promise(() => { });
+}