reelforge 1.24.2 → 1.25.0

package/dist/data/vlog/pet.md

@@ -1,160 +0,0 @@
-# rf vlog · 宠物赛道剧本（pet）
-
-> 给**上层 agent**（你，正在帮用户做视频的 Claude Code / Cursor 等）读的工作指南。
-> 教你怎么把用户的宠物素材 + 一句话，做成一条第一视角搞笑竖屏 vlog。
->
-> **角色边界（先记死）**
-> - 引擎只给你两样**你做不到**的能力：`rf assets describe`（给视频「眼睛」，你看不到视频帧）、`rf compose`（渲染 + 配音 + 字幕对齐）。
-> - **写旁白 / 脚本是你的活，不是引擎的。** 本剧本只给你「怎么写」的最佳实践，绝不替你写一个字。
-> - 字段 / 参数的精确用法一律以 `rf compose -h`、`rf cover -h` 为准。
-
----
-
-## Step 0 · 动手前先确认输入（别让用户从 0 摸索）
-
-宠物赛道的输入清单 + 默认值。**只问灵魂 2 问，其余用默认，别拿用户看不懂的选项去烦他**：
-
-| 输入 | 默认 | 要问吗 |
-|---|---|---|
-| 素材目录 | — | 必给（让用户指一个文件夹） |
-| **故事方向 / 今天发生了啥** | — | **灵魂问 1** |
-| **音色** | 熊小二（推荐，非强制） | **灵魂问 2**：挑 2-3 个候选给用户选，别让他盲选 |
-| 封面 | 自动取一张高光素材 | 用户想要精致封面时，把模板预览图发他挑 |
-| 字幕风格 | stroke（描边，短视频爆款风） | 默认，不问 |
-| BGM / 分辨率 / 画幅 | 默认 BGM / 1080×1920 / blur-bg | 默认，不问 |
-
----
-
-## Step 1 · 看素材（必做，这是你「看到」素材的唯一方式）
-
-```bash
-rf assets describe ./素材目录/ -o assets.json
-```
-
-返回每个素材的客观描述（图片 ~30 字 / 视频 ~80 字含动作与氛围）+ 视频时长。
-**这是事实地基。后面写旁白，只能基于这里描述出来的真实动作。**
-
-## Step 2 · 你来写旁白 + 给用户过故事板
-
-引擎不替你写。按下面《写作最佳实践》自己写，然后用**人话故事板**（不是 JSON）给用户确认。
-
-## Step 3 · 渲染
-
-```bash
-rf compose pet.compose.json -o ./final.mp4
-```
-
----
-
-## ★ 写作最佳实践（宠物第一视角搞笑）
-
-### 人设 brief
-- 第一人称，宠物自己开口。称主人「铲屎的」，自称「本喵 / 本汪」。
-- 调性：**痞帅自信 → 怂的反差**。先吹牛，翻车了立刻甩锅装无辜。
-- 多内心戏、多吐槽；句子口语、短、有梗。
-
-### 🚫 反虚构铁律（最重要，违反 = 废片）
-**旁白只能解说画面里 `describe` 出来的真实动作。**
-- ✅ 可以编：情绪、内心戏、动机、夸张比喻（画面在踱步 → 写「围着鱼缸转了八圈」可以）。
-- ❌ 不准编：画面没发生的物理事件。
-  - 画面是「伸爪够、够不着」→ 不能写「一爪把鱼捞上来」「鱼归我了」。
-  - 画面是「趴着不动」→ 不能写「它一跃而起」。
-- 不确定画面里到底发生没发生 → 当作没发生，别写。
-
-### 句子写法
-- 写**完整句子、句末带标点**（。！？）。每句 10~30 字都行。
-- **别为字幕节奏手动拆短**——字幕切分是引擎的活（compose 内部按真实配音时间对齐）。
-- 每条旁白是一个独立句子，放进对应 scene 的 `narration` 数组里。
-
-### 范例（同一段「够鱼」画面）
-- ✅ 「想吃，真想吃，可这缸里装的居然是水？本喵金贵爪子凭啥沾水。」
-- ❌ 「本喵一爪下去，鱼就归我了。」（画面根本没捞到——虚构）
-
----
-
-## 音色怎么选（不强制熊小二）
-
-熊小二只是**推荐默认**（痞帅搞笑，贴宠物号），用户想用别的随时换。
-
-查全部音色：
-
-```bash
-rf tts voices --provider relayx --model vox/index-tts-2
-```
-
-按风格筛，例如想要解说腔：
-
-```bash
-rf tts voices --provider relayx --model vox/index-tts-2 | grep 解说
-```
-
-**别让用户从一长串里盲选**：你按他要的调性挑 2-3 个候选报给他，他点一个。
-选定后填进 spec 的 `audio.tts_voice`（就是音色名，如 `"熊小二"`）。
-
----
-
-## 封面怎么选
-
-compose 的 `cover.image` 只收**一张图**。两种做法：
-
-**A. 省事**：直接挑一张高光素材当封面 → `"cover": { "image": "高光帧.jpg" }`。
-
-**B. 套模板（精致）**：引擎内置多个封面模板。先看长啥样——每个模板都带一条预览图链接：
-
-```bash
-rf cover templates           # 人读表格 + 预览链接
-rf cover templates --json    # agent 消费，含每个模板的 preview_url
-```
-
-**把这些预览裸链接发给用户，让他看图挑**（别凭模板名猜）。用户选定后渲封面：
-
-```bash
-rf cover -i 高光帧.jpg -t "橘子大战鱼缸" --template <模板id> -o cover.png
-```
-
-（`--subtitle` / `--badge` / `--param` 等精确用法见 `rf cover -h`。）
-然后填进 spec：`"cover": { "image": "cover.png" }`。
-
----
-
-## compose.v3 spec 模板（pet 默认值已填好）
-
-```json
-{
-  "experimental": "compose.v3",
-  "output": { "width": 1080, "height": 1920, "fps": 30, "layout": "blur-bg" },
-  "audio": { "tts_model": "vox/index-tts-2", "tts_voice": "熊小二", "bgm_volume": 0.12 },
-  "subtitle_style": "stroke",
-  "title": "可选，片头标题",
-  "cover": { "image": "封面.jpg" },
-  "scenes": [
-    { "video": "clip1.mp4", "muted": true, "narration": ["句1。", "句2。"] },
-    { "image": "photo1.jpg", "motion": "zoom-in", "narration": ["句1。"] }
-  ]
-}
-```
-
-- **横屏视频用 `layout: "blur-bg"`**：视频缩放居中 + 模糊垫底，绝不裁掉主角。
-- spec 里**没有任何秒数**；时间由引擎量真实配音派生。
-- 旁白尽量 ≤ 视频时长，省掉片头黑卡；真比视频长时引擎会自动前置一张标题卡。
-
-### 素材 & 画幅（短视频节奏）
-- **优先视频片段，尽量少用静图**：静图即便加 Ken Burns 也会拖慢节奏，不合短视频快感。
-- 竖拍照片用 `fit:"cover"` 铺满（别缩在中间显小）；横屏视频要么 `layout:"blur-bg"`，要么先烤成 9:16 再走 `layout:"full"` 统一全屏。
-- 完整的通用画幅 / 朝向 / 音色 / 封面最佳实践见 `rf vlog general`。
-
-### ⚠️ 照片朝向
-手机竖拍照片常带旋转标记，直接喂可能是横躺的。喂前先摆正、抽帧确认方向：
-
-```bash
-ffmpeg -noautorotate -i in.jpg -vf "transpose=1" up.jpg
-```
-
----
-
-## 提交前自查
-- [ ] 跑过 `rf assets describe`？
-- [ ] 旁白每一句都对得上画面真实动作？（过一遍反虚构铁律）
-- [ ] 给用户看的是**人话故事板**，不是裸 JSON？
-- [ ] 照片朝向已摆正？
-- [ ] output 1080×1920、横屏视频 blur-bg？

package/dist/index.js

@@ -1,183 +0,0 @@
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import path from "node:path";
-import { Command } from "commander";
-import { setServer, setApiKey } from "./client.js";
-import { setOutputOptions } from "./utils/output.js";
-const pkgPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "package.json");
-const pkgVersion = JSON.parse(readFileSync(pkgPath, "utf-8")).version;
-import { registerAuth } from "./commands/auth.js";
-import { registerCreate } from "./commands/create.js";
-import { registerRender } from "./commands/render.js";
-import { registerRegen } from "./commands/regen.js";
-import { registerLlm } from "./commands/llm.js";
-import { registerModels } from "./commands/models.js";
-import { registerTts } from "./commands/tts.js";
-import { registerImages } from "./commands/images.js";
-import { registerContent } from "./commands/content.js";
-import { registerAudio } from "./commands/audio.js";
-import { registerSubtitles } from "./commands/subtitles.js";
-import { registerCompositions } from "./commands/compositions.js";
-import { registerPipelines } from "./commands/pipelines.js";
-import { registerBgm } from "./commands/bgm.js";
-import { registerFiles } from "./commands/files.js";
-import { registerTasks } from "./commands/tasks.js";
-import { registerHistory } from "./commands/history.js";
-import { registerConfig } from "./commands/config.js";
-import { registerHealth } from "./commands/health.js";
-import { registerPlatform } from "./commands/platform.js";
-import { registerFetch } from "./commands/fetch.js";
-import { registerCover } from "./commands/cover.js";
-import { registerStyles } from "./commands/styles.js";
-import { registerAssets } from "./commands/assets.js";
-import { registerExtract } from "./commands/extract.js";
-import { registerMedia } from "./commands/media.js";
-import { registerScript } from "./commands/script.js";
-import { registerCompose } from "./commands/compose.js";
-import { registerDub } from "./commands/dub.js";
-import { registerClip } from "./commands/clip.js";
-import { registerVlog } from "./commands/vlog.js";
-import { error as logError } from "./utils/output.js";
-import { ApiCallError } from "./client.js";
-const program = new Command();
-program
-    .name("reelforge")
-    .description([
-    "ReelForge — AI 视频生成与媒体处理 CLI。一句话主题或自己的脚本 → 抖音/TikTok/视频号竖屏 MP4。",
-    "",
-    "本 CLI 是工具型原子能力集合 — 解析 / 文字 / 语音 / 视觉 / 媒体处理 / 渲染六层全覆盖,",
-    "做的是确定性原子操作。脚本写作、多轮创作迭代等创意性工作请在上层(自己脑子或 Claude Code)做完再来调命令。",
-    "",
-    "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
-    "做视频前的决策指南",
-    "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
-    "你手头有什么                            用哪个命令",
-    "  一句话主题 / 想法                      `rf create -t \"<topic>\"`",
-    "                                          (AI 全权: 写文案 + 配音 + 出视觉)",
-    "  自己写好的文案脚本                     `rf create --script @file.txt`",
-    "                                          (AI 配视觉 / 配音 / 字幕)",
-    "  现成视频/图片素材 + 仅要拼接 + BGM     `rf compositions concat ...`",
-    "                                          (底层 ffmpeg, 不做 AI)",
-    "  现成素材 + 想 AI 加文案配音            分两步: 先 `rf create --script` 出 AI",
-    "                                          那段,再 `rf compositions concat`",
-    "                                          把 AI 段跟现成素材拼起来",
-    "  别人的视频/链接做参考                  先 `rf extract <url>` 拿文案 →",
-    "                                          整理脚本 → `rf create --script ...`",
-    "  完全自定义每帧                         `rf compose <spec.json>` (EXPERIMENTAL)",
-    "  想看『你们有哪些风格 / 封面?』         `rf styles list --json` /",
-    "                                          `rf cover templates --json`",
-    "                                          (输出含 preview URL,可用 markdown ",
-    "                                          `![](url)` 在聊天界面渲染成缩略图)",
-    "",
-    "→ 如果不确定哪种方式适合,可以从下面 4 个常见场景里选一个:",
-    "    (A) AI 写全文案+场景, 我只挑风格    → rf create -t",
-    "    (B) 我有文案, AI 配视觉/配音        → rf create --script",
-    "    (C) 我有素材, 只要拼接+BGM           → rf compositions concat",
-    "    (D) 我有素材+脚本, 想 AI 配视觉到我的素材上 → 暂不支持,分 (B)+(C) 两段",
-    "",
-    "  默认服务器: 托管服务(无需配置)",
-    "  自定义服务器: --server <url>  或  REELFORGE_SERVER=<url>",
-    "  短别名:     `rf` 等价于 `reelforge`(如 `rf create ...`)",
-    "",
-    "任意子命令加 --help 看用法。例: `rf cover prepend --help` / `rf media probe --help`。",
-].join("\n"))
-    .version(pkgVersion, "-v, --version", "显示 CLI 版本")
-    .helpOption("-h, --help", "显示帮助")
-    .addHelpCommand("help [command]", "查看某个子命令的帮助")
-    .showHelpAfterError("(用 `reelforge <command> --help` 查看用法)")
-    .showSuggestionAfterError(true)
-    .option("-s, --server <url>", "服务器地址 (默认托管服务, 或环境变量 $REELFORGE_SERVER, 或 login 保存的)")
-    .option("-k, --api-key <key>", "API key (覆盖 $REELFORGE_API_KEY 和 login 保存的 key)")
-    .option("--json", "输出原始 JSON 而不是格式化文本")
-    .option("--quiet", "静默模式 - 不打 stderr 的提示信息")
-    .hook("preAction", (thisCommand) => {
-    const opts = thisCommand.optsWithGlobals();
-    if (opts.server)
-        setServer(opts.server);
-    if (opts.apiKey)
-        setApiKey(opts.apiKey);
-    setOutputOptions({ json: !!opts.json, quiet: !!opts.quiet });
-});
-program.addHelpText("after", [
-    "",
-    "示例:",
-    "  rf create '为什么我们还没有找到外星文明？'        自动保存到 ./<title>-<id>.mp4",
-    "  rf create '...' -o ./videos/space.mp4         指定输出路径",
-    "  rf create --script @story.txt                  用自己的脚本生成",
-    "  rf llm chat -p '帮我解释一下反脆弱'             直通 LLM 单轮对话",
-    "  rf tts relayx --text 'hello' -o out.mp3        生成语音",
-    "  rf images generate -p '一只橘猫' -o cat.png    生成图片",
-    "  rf extract <PDF|抖音|URL|github>               解析素材为文本",
-    "  rf fetch '<抖音分享链接>' -t                    下载抖音 MP4 + ASR 转写",
-    "  rf cover -i scene.png -t '标题' -o cover.png   单图渲染封面",
-    "  rf assets describe ./photo.jpg                  图片 / 视频 → 一句话描述",
-    "  rf dub ./clip.mp4                              一个视频 → 自动解说配音+字幕成片",
-    "  rf history list                                 看之前生成的视频",
-    "  rf tasks list --status running                  看进行中的任务",
-    "",
-    "做 vlog?(用户拍的素材 → 视频)先看赛道剧本:",
-    "  rf vlog                                         列出可用赛道",
-    "  rf vlog pet                                     宠物第一视角搞笑 SOP",
-    "  rf vlog general                                 通用 SOP(没专门赛道就用它兜底)",
-    "  → 拿到 SOP 后照着走:rf assets describe(看素材) → 写旁白 → rf compose(渲染)",
-].join("\n"));
-registerAuth(program);
-registerCreate(program);
-registerRender(program);
-registerRegen(program);
-registerLlm(program);
-registerModels(program);
-registerTts(program);
-registerImages(program);
-registerContent(program);
-registerAudio(program);
-registerSubtitles(program);
-registerCompositions(program);
-registerPipelines(program);
-registerBgm(program);
-registerFiles(program);
-registerTasks(program);
-registerHistory(program);
-registerConfig(program);
-registerHealth(program);
-registerPlatform(program);
-registerFetch(program);
-registerCover(program);
-registerStyles(program);
-registerAssets(program);
-registerExtract(program);
-registerMedia(program);
-registerScript(program);
-registerCompose(program);
-registerDub(program);
-registerClip(program);
-registerVlog(program);
-async function main() {
-    if (process.argv.length <= 2) {
-        program.outputHelp();
-        process.exit(0);
-    }
-    try {
-        await program.parseAsync(process.argv);
-        process.exit(0);
-    }
-    catch (err) {
-        if (err instanceof ApiCallError) {
-            const hint = err.status === 401
-                ? "  → Run `reelforge login <api_key>` first, or pass --api-key <key>."
-                : err.status === 402
-                    ? "  → Insufficient balance. Top up via admin."
-                    : err.status === 403
-                        ? "  → Key revoked or account disabled. Contact admin."
-                        : err.status === 429
-                            ? "  → Rate-limited by jarvis-auth. Try again shortly."
-                            : "";
-            logError(`${err.status ? `[${err.status}] ` : ""}${err.message}${hint ? `\n${hint}` : ""}`);
-        }
-        else {
-            logError(err instanceof Error ? err.message : String(err));
-        }
-        process.exit(1);
-    }
-}
-main();

package/dist/utils/config-file.js

@@ -1,37 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import os from "node:os";
-function configDir() {
-    return path.join(os.homedir(), ".reelforge");
-}
-function configPath() {
-    return path.join(configDir(), "config.json");
-}
-export async function loadConfig() {
-    try {
-        const raw = await fs.readFile(configPath(), "utf-8");
-        const parsed = JSON.parse(raw);
-        return typeof parsed === "object" && parsed ? parsed : {};
-    }
-    catch {
-        return {};
-    }
-}
-export async function saveConfig(c) {
-    await fs.mkdir(configDir(), { recursive: true });
-    const p = configPath();
-    await fs.writeFile(p, JSON.stringify(c, null, 2) + "\n", { mode: 0o600 });
-    return p;
-}
-export async function deleteConfig() {
-    try {
-        await fs.unlink(configPath());
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export function getConfigPath() {
-    return configPath();
-}

package/dist/utils/download.js

@@ -1,13 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { getServer } from "../client.js";
-export async function downloadTo(url, dest) {
-    await fs.mkdir(path.dirname(path.resolve(dest)), { recursive: true });
-    const full = /^https?:\/\//i.test(url) ? url : `${getServer()}${url.startsWith("/") ? url : `/${url}`}`;
-    const r = await fetch(full);
-    if (!r.ok)
-        throw new Error(`Download failed (${r.status}) for ${full}`);
-    const buf = Buffer.from(await r.arrayBuffer());
-    await fs.writeFile(dest, buf);
-    return dest;
-}

package/dist/utils/file-upload.js

@@ -1,102 +0,0 @@
-import fs from "node:fs/promises";
-import fsSync from "node:fs";
-import path from "node:path";
-import { uploadToOss } from "./oss-upload.js";
-export const EXT_TO_MIME = {
-    ".png": "image/png",
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-    ".webp": "image/webp",
-    ".mp3": "audio/mpeg",
-    ".wav": "audio/wav",
-    ".m4a": "audio/mp4",
-    ".aac": "audio/aac",
-    ".ogg": "audio/ogg",
-    ".flac": "audio/flac",
-    ".mp4": "video/mp4",
-    ".mov": "video/quicktime",
-    ".webm": "video/webm",
-    ".mkv": "video/x-matroska",
-};
-export async function resolveFileInput(input, opts) {
-    const t = input.trim();
-    if (!t)
-        throw new Error(`${opts.flagName}: empty value`);
-    if (/^https?:\/\//i.test(t))
-        return { url: t, kind: "http-url" };
-    if (t.startsWith("data:"))
-        return { url: t, kind: "data-uri" };
-    const abs = path.resolve(t);
-    if (!fsSync.existsSync(abs)) {
-        throw new Error(`${opts.flagName}: local file not found: ${abs}\n` +
-            `  (Acceptable forms: local path / https:// URL / data: URI. ` +
-            `Server-side paths like 'data/uploads/...' do NOT work — CLI commands ` +
-            `auto-upload local files, so just pass the local path directly.)`);
-    }
-    const ext = path.extname(abs).toLowerCase();
-    const map = opts.extToMime ?? EXT_TO_MIME;
-    const mime = map[ext];
-    if (!mime) {
-        throw new Error(`${opts.flagName}: unsupported file extension "${ext}" (path: ${abs}). ` +
-            `Supported: ${Object.keys(map).join(" / ")}`);
-    }
-    const buf = await fs.readFile(abs);
-    const url = `data:${mime};base64,${buf.toString("base64")}`;
-    return { url, bytes: buf.byteLength, kind: "local-file" };
-}
-export async function resolveFileInputs(inputs, opts) {
-    const resolved = await Promise.all(inputs.map((input) => resolveFileInput(input, opts)));
-    const totalBytes = resolved.reduce((n, r) => n + (r.bytes ?? 0), 0);
-    return { resolved, totalBytes };
-}
-export 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`;
-}
-export async function resolveUploadInput(input, opts) {
-    const t = input.trim();
-    if (!t)
-        throw new Error(`${opts.flagName}: empty value`);
-    if (/^https?:\/\//i.test(t))
-        return { url: t, kind: "http-url" };
-    if (t.startsWith("data:"))
-        return { url: t, kind: "data-uri" };
-    const abs = path.resolve(t);
-    if (!fsSync.existsSync(abs)) {
-        throw new Error(`${opts.flagName}: local file not found: ${abs}\n` +
-            `  (Acceptable forms: local path / https:// URL / data: URI. ` +
-            `Server-side paths like 'data/uploads/...' do NOT work — CLI commands ` +
-            `auto-upload local files, so just pass the local path directly.)`);
-    }
-    const ext = path.extname(abs).toLowerCase();
-    const map = opts.extToMime ?? EXT_TO_MIME;
-    const mime = map[ext];
-    if (!mime) {
-        throw new Error(`${opts.flagName}: unsupported file extension "${ext}" (path: ${abs}). ` +
-            `Supported: ${Object.keys(map).join(" / ")}`);
-    }
-    const bytes = (await fs.stat(abs)).size;
-    try {
-        const key = await uploadToOss(abs);
-        return { key, bytes, kind: "oss-key" };
-    }
-    catch (e) {
-        const reason = e instanceof Error ? e.message : String(e);
-        opts.onFallback?.(opts.flagName, reason);
-        const buf = await fs.readFile(abs);
-        return { url: `data:${mime};base64,${buf.toString("base64")}`, bytes, kind: "local-file-inline" };
-    }
-}
-export async function resolveUploadInputs(inputs, opts) {
-    const resolved = [];
-    for (const input of inputs) {
-        resolved.push(await resolveUploadInput(input, opts));
-    }
-    const totalBytes = resolved.reduce((n, r) => n + (r.bytes ?? 0), 0);
-    return { resolved, totalBytes };
-}

package/dist/utils/oss-upload.js

@@ -1,44 +0,0 @@
-import fs from "node:fs/promises";
-import fsSync from "node:fs";
-import path from "node:path";
-import { post } from "../client.js";
-const EXT_TO_MIME = {
-    ".mp4": "video/mp4",
-    ".mov": "video/quicktime",
-    ".webm": "video/webm",
-    ".mkv": "video/x-matroska",
-    ".m4v": "video/mp4",
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-    ".png": "image/png",
-    ".webp": "image/webp",
-    ".mp3": "audio/mpeg",
-    ".wav": "audio/wav",
-    ".m4a": "audio/mp4",
-    ".ogg": "audio/ogg",
-    ".flac": "audio/flac",
-    ".pdf": "application/pdf",
-};
-export function mimeForFile(filePath) {
-    return EXT_TO_MIME[path.extname(filePath).toLowerCase()] || "application/octet-stream";
-}
-export async function uploadToOss(filePath) {
-    if (!fsSync.existsSync(filePath))
-        throw new Error(`file not found: ${filePath}`);
-    const ext = path.extname(filePath).toLowerCase();
-    const contentType = mimeForFile(filePath);
-    const signed = await post("/api/v1/uploads/sign", { ext, content_type: contentType });
-    if (!signed?.put_url || !signed?.key)
-        throw new Error("uploads/sign returned no put_url/key");
-    const bytes = await fs.readFile(filePath);
-    const res = await fetch(signed.put_url, {
-        method: "PUT",
-        headers: { "Content-Type": contentType },
-        body: bytes,
-    });
-    if (!res.ok) {
-        const detail = await res.text().catch(() => "");
-        throw new Error(`OSS PUT failed: ${res.status} ${res.statusText} ${detail.slice(0, 200)}`);
-    }
-    return signed.key;
-}

package/dist/utils/output.js

@@ -1,91 +0,0 @@
-import kleur from "kleur";
-let opts = {};
-export function setOutputOptions(o) {
-    opts = { ...opts, ...o };
-}
-export function isJson() {
-    return !!opts.json;
-}
-export function print(data) {
-    if (opts.json) {
-        process.stdout.write(JSON.stringify(data, null, 2) + "\n");
-        return;
-    }
-    if (data === null || data === undefined)
-        return;
-    if (typeof data === "string") {
-        process.stdout.write(data + "\n");
-        return;
-    }
-    process.stdout.write(JSON.stringify(data, null, 2) + "\n");
-}
-export function info(msg) {
-    if (opts.quiet || opts.json)
-        return;
-    process.stderr.write(kleur.cyan("›") + " " + msg + "\n");
-}
-export function success(msg) {
-    if (opts.quiet || opts.json)
-        return;
-    process.stderr.write(kleur.green("✔") + " " + msg + "\n");
-}
-export function warn(msg) {
-    if (opts.quiet)
-        return;
-    process.stderr.write(kleur.yellow("!") + " " + msg + "\n");
-}
-export function error(msg) {
-    process.stderr.write(kleur.red("✗") + " " + msg + "\n");
-}
-export function table(rows, columns) {
-    if (opts.json) {
-        print(rows);
-        return;
-    }
-    if (!rows.length) {
-        info("(empty)");
-        return;
-    }
-    const cols = columns || Object.keys(rows[0]);
-    const widths = cols.map((c) => Math.max(c.length, ...rows.map((r) => String(r[c] ?? "").length)));
-    const fmt = (cells) => cells.map((cell, i) => cell.padEnd(widths[i])).join("  ");
-    process.stdout.write(kleur.bold(fmt(cols)) + "\n");
-    process.stdout.write(cols.map((_, i) => "-".repeat(widths[i])).join("  ") + "\n");
-    for (const r of rows) {
-        process.stdout.write(fmt(cols.map((c) => String(r[c] ?? ""))) + "\n");
-    }
-}
-export function formatUsd(usd) {
-    if (usd == null)
-        return "-";
-    const abs = Math.abs(usd);
-    const decimals = abs > 0 && abs < 0.01 ? 6 : 4;
-    return `$${usd.toFixed(decimals)}`;
-}
-export function bytes(n) {
-    if (n == null)
-        return "-";
-    if (n < 1024)
-        return `${n} B`;
-    if (n < 1024 * 1024)
-        return `${(n / 1024).toFixed(1)} KB`;
-    if (n < 1024 * 1024 * 1024)
-        return `${(n / 1024 / 1024).toFixed(1)} MB`;
-    return `${(n / 1024 / 1024 / 1024).toFixed(2)} GB`;
-}
-export function humanDuration(ms) {
-    if (ms == null)
-        return "-";
-    const totalSec = Math.round(ms / 1000);
-    const h = Math.floor(totalSec / 3600);
-    const m = Math.floor((totalSec % 3600) / 60);
-    const s = totalSec % 60;
-    const parts = [];
-    if (h > 0)
-        parts.push(`${h}h`);
-    if (m > 0)
-        parts.push(`${m}m`);
-    if (s > 0 || parts.length === 0)
-        parts.push(`${s}s`);
-    return parts.join("");
-}

package/dist/utils/task-waiter.js

@@ -1,40 +0,0 @@
-import { get } from "../client.js";
-import kleur from "kleur";
-import { isJson } from "./output.js";
-export async function waitForTask(taskId, opts = {}) {
-    const pollMs = opts.pollMs ?? 1500;
-    const deadline = opts.timeoutMs ? Date.now() + opts.timeoutMs : Number.POSITIVE_INFINITY;
-    const show = opts.showProgress !== false && !isJson();
-    let lastLine = "";
-    while (true) {
-        const t = await get(`/api/v1/tasks/${taskId}`);
-        if (show) {
-            const last = t.events[t.events.length - 1];
-            const evt = last?.eventType || last?.event_type || "";
-            const action = last?.action ? ` · ${last.action}` : "";
-            const frame = last && (last.frameCurrent || last.frame_current)
-                ? ` · frame ${last.frameCurrent ?? last.frame_current}/${last.frameTotal ?? last.frame_total}`
-                : "";
-            const line = `${(t.progress * 100).toFixed(0).padStart(3)}%  ${t.status}  ${evt}${action}${frame}`;
-            if (line !== lastLine) {
-                process.stderr.write("\r" + " ".repeat(Math.max(lastLine.length, line.length)) + "\r");
-                process.stderr.write(kleur.cyan("⟳ ") + line);
-                lastLine = line;
-            }
-        }
-        if (t.status === "completed" || t.status === "failed" || t.status === "cancelled") {
-            if (show)
-                process.stderr.write("\n");
-            return t;
-        }
-        if (Date.now() > deadline) {
-            if (show)
-                process.stderr.write("\n");
-            throw new Error(`Timed out after ${opts.timeoutMs} ms waiting for task ${taskId}`);
-        }
-        await sleep(pollMs);
-    }
-}
-function sleep(ms) {
-    return new Promise((res) => setTimeout(res, ms));
-}