reelforge 1.24.0 → 1.24.1

package/dist/commands/compose.js

@@ -2,6 +2,7 @@ import fs from "node:fs/promises";
 import fsSync from "node:fs";
 import path from "node:path";
 import { post, getServer } from "../client.js";
+import { uploadToOss } from "../utils/oss-upload.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";
@@ -18,15 +19,6 @@ const EXT_TO_MIME = {
     ".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)
@@ -59,35 +51,35 @@ async function readAsDataUri(specPath, baseDir) {
     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_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": "贼喵被抓现行"
+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
@@ -188,14 +180,27 @@ async function renderComposeOnce(specPath, opts) {
     info(`Reading spec from ${specPath}...`);
     const specPaths = listSpecPaths(spec);
     const files = {};
-    let totalBytes = 0;
+    const fileKeys = {};
     for (const p of specPaths) {
-        const r = await readAsDataUri(p, baseDir);
-        files[p] = r.dataUri;
-        totalBytes += r.bytes;
+        const abs = path.isAbsolute(p) ? p : path.resolve(baseDir, p);
+        if (!fsSync.existsSync(abs)) {
+            throw new Error(`compose: spec references "${p}" but file not found at ${abs}`);
+        }
+        try {
+            fileKeys[p] = await uploadToOss(abs);
+        }
+        catch (e) {
+            warn(`${p}: OSS 直传不可用,回退内联上传 (${e instanceof Error ? e.message : e})`);
+            const r = await readAsDataUri(p, baseDir);
+            files[p] = r.dataUri;
+        }
     }
-    info(`Bundling ${specPaths.length} files (${fmtSize(totalBytes)} total)...`);
-    const body = { spec, files };
+    info(`Bundling ${specPaths.length} files (${Object.keys(fileKeys).length} 直传 OSS, ${Object.keys(files).length} 内联)...`);
+    const body = { spec };
+    if (Object.keys(fileKeys).length)
+        body.file_keys = fileKeys;
+    if (Object.keys(files).length)
+        body.files = files;
     if (opts.previewOnly)
         body.preview_only = true;
     const submitted = await post("/api/v1/compose", body);

package/dist/commands/compositions.js

@@ -1,7 +1,8 @@
 import { post } from "../client.js";
 import { downloadTo } from "../utils/download.js";
-import { print, success, info } from "../utils/output.js";
-import { fmtSize, resolveFileInput, resolveFileInputs } from "../utils/file-upload.js";
+import { print, success, info, warn } from "../utils/output.js";
+import { fmtSize, resolveUploadInput, resolveUploadInputs } from "../utils/file-upload.js";
+const onOssFallback = (flagName, reason) => warn(`${flagName}: OSS 直传不可用,回退内联上传 (${reason})`);
 const WHEN_TO_USE = [
     "",
     "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
@@ -52,18 +53,22 @@ export function registerCompositions(program) {
         .action(async (videos, opts) => {
         if (!opts.output)
             throw new Error("--output is required");
-        const { resolved, totalBytes } = await resolveFileInputs(videos, {
+        const { resolved, totalBytes } = await resolveUploadInputs(videos, {
             flagName: "<videos...>",
+            onFallback: onOssFallback,
         });
         const bgm = opts.bgm
-            ? await resolveFileInput(opts.bgm, { flagName: "--bgm" })
+            ? await resolveUploadInput(opts.bgm, { flagName: "--bgm", onFallback: onOssFallback })
             : null;
         if (totalBytes)
             info(`Uploading ${resolved.length} videos (${fmtSize(totalBytes + (bgm?.bytes ?? 0))})...`);
+        const videoKeys = resolved.filter((r) => r.key).map((r) => r.key);
+        const videoUris = resolved.filter((r) => r.url).map((r) => r.url);
         const r = await post("/api/v1/compositions/concat", {
-            videos: resolved.map((r) => r.url),
+            videos: videoUris,
+            video_keys: videoKeys,
             method: opts.method,
-            bgm_path: bgm?.url,
+            ...(bgm?.key ? { bgm_key: bgm.key } : bgm?.url ? { bgm_path: bgm.url } : {}),
             bgm_volume: opts.bgmVolume,
             bgm_mode: opts.bgmMode,
         });
@@ -83,12 +88,12 @@ export function registerCompositions(program) {
         .action(async (opts) => {
         if (!opts.output)
             throw new Error("--output is required");
-        const v = await resolveFileInput(opts.input, { flagName: "-i / --input" });
-        const b = await resolveFileInput(opts.bgm, { flagName: "--bgm" });
+        const v = await resolveUploadInput(opts.input, { flagName: "-i / --input", onFallback: onOssFallback });
+        const b = await resolveUploadInput(opts.bgm, { flagName: "--bgm", onFallback: onOssFallback });
         info(`Uploading video (${fmtSize(v.bytes ?? 0)}) + bgm (${fmtSize(b.bytes ?? 0)})...`);
         const r = await post("/api/v1/compositions/bgm", {
-            video: v.url,
-            bgm: b.url,
+            ...(v.key ? { video_key: v.key } : { video: v.url }),
+            ...(b.key ? { bgm_key: b.key } : { bgm: b.url }),
             volume: opts.volume,
             mode: opts.mode,
         });
@@ -107,12 +112,12 @@ export function registerCompositions(program) {
         .action(async (opts) => {
         if (!opts.output)
             throw new Error("--output is required");
-        const img = await resolveFileInput(opts.image, { flagName: "-i / --image" });
-        const aud = await resolveFileInput(opts.audio, { flagName: "-a / --audio" });
+        const img = await resolveUploadInput(opts.image, { flagName: "-i / --image", onFallback: onOssFallback });
+        const aud = await resolveUploadInput(opts.audio, { flagName: "-a / --audio", onFallback: onOssFallback });
         info(`Uploading image (${fmtSize(img.bytes ?? 0)}) + audio (${fmtSize(aud.bytes ?? 0)})...`);
         const r = await post("/api/v1/compositions/image-to-video", {
-            image: img.url,
-            audio: aud.url,
+            ...(img.key ? { image_key: img.key } : { image: img.url }),
+            ...(aud.key ? { audio_key: aud.key } : { audio: aud.url }),
             fps: opts.fps,
         });
         await downloadTo(r.url, opts.output);
@@ -129,12 +134,12 @@ export function registerCompositions(program) {
         .action(async (opts) => {
         if (!opts.output)
             throw new Error("--output is required");
-        const v = await resolveFileInput(opts.video, { flagName: "-v / --video" });
-        const o = await resolveFileInput(opts.overlay, { flagName: "--overlay" });
+        const v = await resolveUploadInput(opts.video, { flagName: "-v / --video", onFallback: onOssFallback });
+        const o = await resolveUploadInput(opts.overlay, { flagName: "--overlay", onFallback: onOssFallback });
         info(`Uploading video (${fmtSize(v.bytes ?? 0)}) + overlay (${fmtSize(o.bytes ?? 0)})...`);
         const r = await post("/api/v1/compositions/overlay", {
-            video: v.url,
-            overlay_image: o.url,
+            ...(v.key ? { video_key: v.key } : { video: v.url }),
+            ...(o.key ? { overlay_key: o.key } : { overlay_image: o.url }),
         });
         await downloadTo(r.url, opts.output);
         success(`Saved → ${opts.output}`);

package/dist/commands/cover.js

@@ -2,7 +2,9 @@ import fs from "node:fs/promises";
 import fsSync from "node:fs";
 import path from "node:path";
 import { getServer, getApiKey } from "../client.js";
+import { uploadToOss } from "../utils/oss-upload.js";
 import { info, success, warn } from "../utils/output.js";
+const MAX_BYTES = 50 * 1024 * 1024;
 const TEMPLATES = [
     { id: "paper-band", label: "牛皮纸条 横卡", supports: "title, subtitle, badge", useFor: "财经 / 干货 / 商业分析" },
     { id: "carbon-copy", label: "复写纸 暗调", supports: "title, subtitle", useFor: "情感 / 哲思 / 治愈(默认)" },
@@ -17,6 +19,21 @@ const TEMPLATES = [
 const TEMPLATE_IDS = new Set(TEMPLATES.map((t) => t.id));
 const DEFAULT_TEMPLATE = "carbon-copy";
 const SMALL_IMAGE_WARN_BYTES = 100 * 1024;
+async function uploadOrInline(fileAbs, fileMime, label) {
+    const bytes = (await fs.stat(fileAbs)).size;
+    try {
+        const key = await uploadToOss(fileAbs);
+        return { key, bytes };
+    }
+    catch (e) {
+        if (bytes > MAX_BYTES) {
+            throw new Error(`${label} 直传 OSS 失败 (${e instanceof Error ? e.message : e}),且文件 ${fmtSize(bytes)} 超过内联回退上限 ${fmtSize(MAX_BYTES)}。`);
+        }
+        warn(`${label}: OSS 直传不可用,回退内联上传 (${e instanceof Error ? e.message : e})`);
+        const buf = await fs.readFile(fileAbs);
+        return { uri: `data:${fileMime};base64,${buf.toString("base64")}`, bytes };
+    }
+}
 async function resolveImage(input) {
     const t = input.trim();
     if (!t)
@@ -37,9 +54,8 @@ async function resolveImage(input) {
     if (!mime) {
         throw new Error(`--image: unsupported extension ${ext} (use png/jpg/jpeg/webp)`);
     }
-    const buf = await fs.readFile(abs);
-    const url = `data:${mime};base64,${buf.toString("base64")}`;
-    return { url, bytes: buf.byteLength };
+    const up = await uploadOrInline(abs, mime, "--image");
+    return { key: up.key, url: up.uri, bytes: up.bytes };
 }
 function fmtSize(b) {
     if (b < 1024)
@@ -177,7 +193,7 @@ export function registerCover(program) {
         if (missing.length > 0) {
             throw new Error(`required: ${missing.join(", ")}`);
         }
-        const { url: imageUrl, bytes } = await resolveImage(opts.image);
+        const { key: imageKey, url: imageUrl, bytes } = await resolveImage(opts.image);
         if (typeof bytes === "number" && bytes < SMALL_IMAGE_WARN_BYTES) {
             warn(`--image is ${fmtSize(bytes)} — that's quite small, the cover may look blurry. ` +
                 `For best results use a source image of at least 1080×1920.`);
@@ -188,10 +204,13 @@ export function registerCover(program) {
         }
         const params = buildParamsPayload(opts.param, opts.params);
         const body = {
-            image_url: imageUrl,
             template,
             title: opts.title,
         };
+        if (imageKey)
+            body.image_key = imageKey;
+        else
+            body.image_url = imageUrl;
         if (opts.subtitle)
             body.subtitle = opts.subtitle;
         if (opts.badge)
@@ -251,17 +270,22 @@ export function registerCover(program) {
         if (!fsSync.existsSync(coverAbs)) {
             throw new Error(`cover not found: ${coverAbs}`);
         }
-        const coverBuf = await fs.readFile(coverAbs);
-        const videoBuf = await fs.readFile(videoAbs);
         const coverExt = path.extname(coverAbs).toLowerCase();
         const coverMime = coverExt === ".jpg" || coverExt === ".jpeg" ? "image/jpeg" : "image/png";
-        const body = {
-            cover_data_uri: `data:${coverMime};base64,${coverBuf.toString("base64")}`,
-            video_data_uri: `data:video/mp4;base64,${videoBuf.toString("base64")}`,
-        };
+        const coverUp = await uploadOrInline(coverAbs, coverMime, "cover");
+        const videoUp = await uploadOrInline(videoAbs, "video/mp4", "video");
+        const body = {};
+        if (coverUp.key)
+            body.cover_key = coverUp.key;
+        else
+            body.cover_data_uri = coverUp.uri;
+        if (videoUp.key)
+            body.video_key = videoUp.key;
+        else
+            body.video_data_uri = videoUp.uri;
         if (typeof opts.fps === "number")
             body.fps = opts.fps;
-        info(`Prepending cover (${fmtSize(coverBuf.byteLength)}) → video (${fmtSize(videoBuf.byteLength)})...`);
+        info(`Prepending cover (${fmtSize(coverUp.bytes)}) → video (${fmtSize(videoUp.bytes)})...`);
         const server = getServer().replace(/\/+$/, "");
         const apiKey = getApiKey();
         const headers = { "content-type": "application/json" };

package/dist/commands/create.js

@@ -3,6 +3,7 @@ import fsSync from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import { post, getServer } from "../client.js";
+import { uploadToOss } from "../utils/oss-upload.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";
@@ -38,14 +39,15 @@ async function resolveTextOrFile(input) {
     }
     return input;
 }
-async function resolveRefImage(input, flagName) {
+const REF_IMAGE_MAX_BYTES = 15 * 1024 * 1024;
+async function resolveRefImageUpload(input, flagName) {
     if (input === undefined)
         return undefined;
     const t = input.trim();
     if (!t)
         return undefined;
     if (/^https?:\/\//i.test(t) || t.startsWith("data:"))
-        return t;
+        return { passthrough: t };
     const abs = path.resolve(t);
     if (!fsSync.existsSync(abs)) {
         throw new Error(`${flagName}: local file not found: ${abs}`);
@@ -58,8 +60,19 @@ async function resolveRefImage(input, flagName) {
     if (!mime) {
         throw new Error(`${flagName}: unsupported extension ${ext} (use png/jpg/jpeg/webp)`);
     }
-    const buf = await fs.readFile(abs);
-    return `data:${mime};base64,${buf.toString("base64")}`;
+    try {
+        const key = await uploadToOss(abs);
+        return { key };
+    }
+    catch (e) {
+        const sz = (await fs.stat(abs)).size;
+        if (sz > REF_IMAGE_MAX_BYTES) {
+            throw new Error(`${flagName} 直传 OSS 失败 (${e instanceof Error ? e.message : e}),且文件超过内联回退上限 ${REF_IMAGE_MAX_BYTES} 字节。`);
+        }
+        warn(`${flagName}: OSS 直传不可用,回退内联上传 (${e instanceof Error ? e.message : e})`);
+        const buf = await fs.readFile(abs);
+        return { passthrough: `data:${mime};base64,${buf.toString("base64")}` };
+    }
 }
 async function loadRecipe(recipePath) {
     const raw = await fs.readFile(recipePath, "utf-8");
@@ -512,17 +525,30 @@ export function registerCreate(program) {
                 "  # (compose your script using /tmp/ref.txt as raw material in your agent)\n" +
                 "  rf create --script @final.txt -d 60        # render it");
         }
-        const resolvedChar = await resolveRefImage(body.character_ref, "--character-ref");
-        if (resolvedChar !== undefined)
-            body.character_ref = resolvedChar;
-        else
-            delete body.character_ref;
+        const resolvedChar = await resolveRefImageUpload(body.character_ref, "--character-ref");
+        delete body.character_ref;
+        delete body.character_ref_key;
+        if (resolvedChar?.key)
+            body.character_ref_key = resolvedChar.key;
+        else if (resolvedChar?.passthrough)
+            body.character_ref = resolvedChar.passthrough;
         if (body.brand?.logo_url) {
-            const resolvedLogo = await resolveRefImage(body.brand.logo_url, "--brand-logo");
-            if (resolvedLogo !== undefined)
-                body.brand.logo_url = resolvedLogo;
-            else
-                delete body.brand.logo_url;
+            const resolvedLogo = await resolveRefImageUpload(body.brand.logo_url, "--brand-logo");
+            delete body.brand.logo_url;
+            delete body.brand_logo_key;
+            if (resolvedLogo?.key)
+                body.brand_logo_key = resolvedLogo.key;
+            else if (resolvedLogo?.passthrough)
+                body.brand.logo_url = resolvedLogo.passthrough;
+        }
+        if (body.cover?.base) {
+            const resolvedBase = await resolveRefImageUpload(body.cover.base, "--cover-base");
+            delete body.cover.base;
+            delete body.cover_base_key;
+            if (resolvedBase?.key)
+                body.cover_base_key = resolvedBase.key;
+            else if (resolvedBase?.passthrough)
+                body.cover.base = resolvedBase.passthrough;
         }
         const hasTopic = typeof body.topic === "string" && body.topic.trim().length > 0;
         const hasScript = typeof body.script === "string" && body.script.trim().length > 0;
@@ -545,7 +571,11 @@ export function registerCreate(program) {
         }
         info(`Submitting create task (≈ ${formatUsd(estimate)})...`);
         const submitted = await post("/api/v1/pipelines/standard", finalBody);
-        await saveLastCreate(finalBody).catch((e) => {
+        const toSave = { ...finalBody };
+        delete toSave.character_ref_key;
+        delete toSave.brand_logo_key;
+        delete toSave.cover_base_key;
+        await saveLastCreate(toSave).catch((e) => {
             warn(`Could not save last-create.json: ${e.message}`);
         });
         if (opts.wait === false) {

package/dist/commands/dub.js

@@ -2,9 +2,10 @@ import fs from "node:fs/promises";
 import fsSync from "node:fs";
 import path from "node:path";
 import { post } from "../client.js";
+import { uploadToOss } from "../utils/oss-upload.js";
 import { waitForTask } from "../utils/task-waiter.js";
 import { downloadTo } from "../utils/download.js";
-import { formatUsd, humanDuration, info, isJson, print, success } from "../utils/output.js";
+import { formatUsd, humanDuration, info, isJson, print, success, warn } from "../utils/output.js";
 const VIDEO_EXT_TO_MIME = {
     ".mp4": "video/mp4",
     ".mov": "video/quicktime",
@@ -107,14 +108,7 @@ export function registerDub(program) {
         if (!["plate", "stroke", "cinema"].includes(subtitleStyle)) {
             throw new Error(`--subtitle-style must be plate | stroke | cinema (got ${opts.subtitleStyle})`);
         }
-        const buf = await fs.readFile(abs);
-        if (buf.byteLength > MAX_BYTES) {
-            throw new Error(`video is ${fmtSize(buf.byteLength)} — exceeds the ${fmtSize(MAX_BYTES)} upload cap. ` +
-                `Compress / trim it first (e.g. ffmpeg -crf 28).`);
-        }
-        info(`Uploading ${path.basename(abs)} (${fmtSize(buf.byteLength)})...`);
         const body = {
-            video: `data:${mime};base64,${buf.toString("base64")}`,
             voice: opts.voice || "熊小二",
             tts_model: opts.ttsModel || "vox/index-tts-2",
             game_audio_volume: gameVolume,
@@ -132,8 +126,30 @@ export function registerDub(program) {
             body.cover_badge = opts.coverBadge;
         if (opts.theme)
             body.theme = opts.theme;
+        const uploadOrInline = async (fileAbs, fileMime, label) => {
+            try {
+                const key = await uploadToOss(fileAbs);
+                return { key };
+            }
+            catch (e) {
+                const sz = (await fs.stat(fileAbs)).size;
+                if (sz > MAX_BYTES) {
+                    throw new Error(`${label} 直传 OSS 失败 (${e instanceof Error ? e.message : e}),且文件 ${fmtSize(sz)} 超过内联回退上限 ${fmtSize(MAX_BYTES)}。`);
+                }
+                warn(`${label}: OSS 直传不可用,回退内联上传 (${e instanceof Error ? e.message : e})`);
+                const buf = await fs.readFile(fileAbs);
+                return { uri: `data:${fileMime};base64,${buf.toString("base64")}` };
+            }
+        };
+        info(`Uploading ${path.basename(abs)} (${fmtSize((await fs.stat(abs)).size)}) → 直传对象存储...`);
+        const mainUp = await uploadOrInline(abs, mime, "video");
+        if (mainUp.key)
+            body.video_key = mainUp.key;
+        else
+            body.video = mainUp.uri;
         const appendFiles = opts.append ?? [];
         if (appendFiles.length) {
+            const appendKeys = [];
             const appendUris = [];
             for (const f of appendFiles) {
                 const aAbs = path.resolve(f);
@@ -143,14 +159,17 @@ export function registerDub(program) {
                 const aMime = VIDEO_EXT_TO_MIME[aExt];
                 if (!aMime)
                     throw new Error(`--append: unsupported extension "${aExt}" (${path.basename(aAbs)})`);
-                const aBuf = await fs.readFile(aAbs);
-                if (aBuf.byteLength > MAX_BYTES) {
-                    throw new Error(`--append clip ${path.basename(aAbs)} is ${fmtSize(aBuf.byteLength)} — exceeds ${fmtSize(MAX_BYTES)}.`);
-                }
-                info(`  + append ${path.basename(aAbs)} (${fmtSize(aBuf.byteLength)})`);
-                appendUris.push(`data:${aMime};base64,${aBuf.toString("base64")}`);
+                info(`  + append ${path.basename(aAbs)} (${fmtSize((await fs.stat(aAbs)).size)})`);
+                const up = await uploadOrInline(aAbs, aMime, `--append ${path.basename(aAbs)}`);
+                if (up.key)
+                    appendKeys.push(up.key);
+                else if (up.uri)
+                    appendUris.push(up.uri);
             }
-            body.append = appendUris;
+            if (appendKeys.length)
+                body.append_keys = appendKeys;
+            if (appendUris.length)
+                body.append = appendUris;
         }
         if (opts.visionModel)
             body.vision_model = opts.visionModel;

package/dist/commands/extract.js

@@ -2,7 +2,9 @@ import fs from "node:fs/promises";
 import fsSync from "node:fs";
 import path from "node:path";
 import { post } from "../client.js";
-import { info, isJson, print, success } from "../utils/output.js";
+import { uploadToOss } from "../utils/oss-upload.js";
+import { info, isJson, print, success, warn } from "../utils/output.js";
+const MAX_BYTES = 25 * 1024 * 1024;
 const FILE_EXT_TO_MIME = {
     ".pdf": "application/pdf",
     ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
@@ -13,13 +15,13 @@ async function resolveSource(input) {
     if (!t)
         throw new Error("--reference / source is empty");
     if (t.startsWith("data:"))
-        return t;
+        return { source: t };
     if (/^https?:\/\//i.test(t))
-        return t;
+        return { source: t };
     if (/v\.douyin\.com\//i.test(t) || /复制此链接/.test(t) || /打开抖音/.test(t))
-        return t;
+        return { source: t };
     if (/^[a-z0-9][a-z0-9-._]*\/[a-z0-9][a-z0-9-._]*$/i.test(t) && !t.split("/")[0].includes(".")) {
-        return t;
+        return { source: t };
     }
     const abs = path.resolve(t);
     if (!fsSync.existsSync(abs)) {
@@ -32,8 +34,19 @@ async function resolveSource(input) {
         throw new Error(`unsupported file extension "${ext}". ` +
             `Supported: ${Object.keys(FILE_EXT_TO_MIME).join(" / ")}, or pass a URL / github owner/repo / 抖音 link.`);
     }
-    const buf = await fs.readFile(abs);
-    return `data:${mime};base64,${buf.toString("base64")}`;
+    try {
+        const key = await uploadToOss(abs);
+        return { source_key: key };
+    }
+    catch (e) {
+        const sz = (await fs.stat(abs)).size;
+        if (sz > MAX_BYTES) {
+            throw new Error(`${path.basename(abs)} 直传 OSS 失败 (${e instanceof Error ? e.message : e}),且文件超过内联回退上限 ${MAX_BYTES} 字节。`);
+        }
+        warn(`source: OSS 直传不可用,回退内联上传 (${e instanceof Error ? e.message : e})`);
+        const buf = await fs.readFile(abs);
+        return { source: `data:${mime};base64,${buf.toString("base64")}` };
+    }
 }
 export function registerExtract(program) {
     program
@@ -81,7 +94,7 @@ export function registerExtract(program) {
     ].join("\n"))
         .action(async (source, opts) => {
         const resolved = await resolveSource(source);
-        const r = await post("/api/v1/reference/extract", { source: resolved });
+        const r = await post("/api/v1/reference/extract", { ...resolved });
         if (opts.output) {
             const outAbs = path.resolve(opts.output);
             await fs.mkdir(path.dirname(outAbs), { recursive: true });

package/dist/commands/images.js

@@ -2,14 +2,16 @@ import fs from "node:fs/promises";
 import fsSync from "node:fs";
 import path from "node:path";
 import { post } from "../client.js";
+import { uploadToOss } from "../utils/oss-upload.js";
 import { downloadTo } from "../utils/download.js";
-import { print, success } from "../utils/output.js";
+import { print, success, warn } from "../utils/output.js";
+const MAX_REF_BYTES = 15 * 1024 * 1024;
 async function resolveImageRef(input) {
     const t = input.trim();
     if (!t)
         throw new Error("--image: empty value");
     if (/^https?:\/\//i.test(t) || t.startsWith("data:"))
-        return t;
+        return { url: t };
     const abs = path.resolve(t);
     if (!fsSync.existsSync(abs)) {
         throw new Error(`--image: local file not found: ${abs}`);
@@ -22,8 +24,19 @@ async function resolveImageRef(input) {
     if (!mime) {
         throw new Error(`--image: unsupported extension ${ext} (use png/jpg/jpeg/webp)`);
     }
-    const buf = await fs.readFile(abs);
-    return `data:${mime};base64,${buf.toString("base64")}`;
+    try {
+        const key = await uploadToOss(abs);
+        return { key };
+    }
+    catch (e) {
+        const sz = (await fs.stat(abs)).size;
+        if (sz > MAX_REF_BYTES) {
+            throw new Error(`--image ${path.basename(abs)} 直传 OSS 失败 (${e instanceof Error ? e.message : e}),且文件超过内联回退上限 ${MAX_REF_BYTES} 字节。`);
+        }
+        warn(`--image ${path.basename(abs)}: OSS 直传不可用,回退内联上传 (${e instanceof Error ? e.message : e})`);
+        const buf = await fs.readFile(abs);
+        return { url: `data:${mime};base64,${buf.toString("base64")}` };
+    }
 }
 export function registerImages(program) {
     const images = program
@@ -69,7 +82,13 @@ export function registerImages(program) {
             if (opts.image.length > 3) {
                 throw new Error(`--image accepts at most 3 refs (got ${opts.image.length})`);
             }
-            body.image_urls = await Promise.all(opts.image.map(resolveImageRef));
+            const resolved = await Promise.all(opts.image.map(resolveImageRef));
+            const urls = resolved.filter((r) => r.url).map((r) => r.url);
+            const keys = resolved.filter((r) => r.key).map((r) => r.key);
+            if (urls.length)
+                body.image_urls = urls;
+            if (keys.length)
+                body.image_keys = keys;
         }
         const r = await post("/api/v1/images/generate", body);
         if (opts.output && r.images?.[0]) {

package/dist/commands/media.js

@@ -2,7 +2,8 @@ import fs from "node:fs/promises";
 import fsSync from "node:fs";
 import path from "node:path";
 import { post } from "../client.js";
-import { info, isJson, print } from "../utils/output.js";
+import { uploadToOss } from "../utils/oss-upload.js";
+import { info, isJson, print, warn } from "../utils/output.js";
 const MEDIA_EXT_TO_MIME = {
     ".mp4": "video/mp4",
     ".mov": "video/quicktime",
@@ -112,8 +113,15 @@ export function registerMedia(program) {
                 throw new Error(`unsupported extension "${ext}". Supported: ${Object.keys(MEDIA_EXT_TO_MIME).join(" / ")}, ` +
                     `or pass a URL.`);
             }
-            const buf = await fs.readFile(abs);
-            body = { data_uri: `data:${mime};base64,${buf.toString("base64")}` };
+            try {
+                const key = await uploadToOss(abs);
+                body = { key };
+            }
+            catch (e) {
+                warn(`${path.basename(abs)}: OSS 直传不可用,回退内联上传 (${e instanceof Error ? e.message : e})`);
+                const buf = await fs.readFile(abs);
+                body = { data_uri: `data:${mime};base64,${buf.toString("base64")}` };
+            }
             label = path.basename(abs);
         }
         const r = await post("/api/v1/media/probe", body);