122 lines
7.3 KiB
Python
122 lines
7.3 KiB
Python
"""Reproducible, version-checked local-video extension for HuobaoDrama 4.0.10.
|
|
|
|
Prepare by default; --install replaces the archive/frontend after the app closes.
|
|
Original files stay in integration-work/backups/multivideo-4.0.10.
|
|
"""
|
|
import hashlib
|
|
import json
|
|
from pathlib import Path
|
|
import shutil
|
|
import struct
|
|
import sys
|
|
|
|
ROOT = Path(__file__).resolve().parent.parent
|
|
WORK = ROOT / "integration-work"
|
|
RES = ROOT / "HuobaoDrama/resources"
|
|
BACKUP = WORK / "backups/multivideo-4.0.10"
|
|
MODELS = ["MiniMax-H3", "MiniMax-H3-Hybrid", "MiniMax-H3-R2V-4Step", "LTX-2.3", "LTX-2.3-Text-Preserve", "Wan2.2-I2V"]
|
|
|
|
|
|
def replace_once(text, old, new):
|
|
if text.count(old) != 1:
|
|
raise RuntimeError("Desktop version mismatch: " + old[:90])
|
|
return text.replace(old, new, 1)
|
|
|
|
|
|
def prepare():
|
|
# Never rebuild a newer installation from an old backup archive.
|
|
installed = (RES / 'app.asar').read_bytes()
|
|
_, hs, _, js = struct.unpack('<4I', installed[:16])
|
|
header = json.loads(installed[16:16 + js])
|
|
entry = header['files']['package.json']
|
|
start = 8 + hs + int(entry['offset'])
|
|
version = json.loads(installed[start:start + entry['size']])['version']
|
|
if version != '4.0.10':
|
|
raise RuntimeError('This legacy patch supports only 4.0.10; installed version is ' + version)
|
|
BACKUP.mkdir(parents=True, exist_ok=True)
|
|
archive = RES / "app.asar"
|
|
frontend = RES / "frontend/_nuxt/D3oBzv6c.js"
|
|
locale = RES / "frontend/_nuxt/BU13Ari2.js"
|
|
for source in (archive, frontend, locale):
|
|
target = BACKUP / source.name
|
|
if not target.exists():
|
|
shutil.copy2(source, target)
|
|
raw = (BACKUP / "app.asar").read_bytes()
|
|
_, header_size, _, json_size = struct.unpack("<4I", raw[:16])
|
|
tree = json.loads(raw[16:16 + json_size])
|
|
data = raw[8 + header_size:]
|
|
entry = tree["files"]["build"]["files"]["backend.mjs"]
|
|
offset, size = int(entry["offset"]), entry["size"]
|
|
original = data[offset:offset + size]
|
|
if hashlib.sha256(original).hexdigest() != "0fc3b513625e17fc31822b2c5c5d7527a103d163c872e08535d2b4792df60ae2":
|
|
raise RuntimeError("Expected the inspected HuobaoDrama 4.0.10 backend")
|
|
backend = original.decode("utf-8")
|
|
start = backend.index("var MiniMaxVideoAdapter = class {")
|
|
end = backend.index("\n// ../backend/src/services/adapters/aliyun-wan-video.ts", start)
|
|
adapter = backend[start:end].replace("MiniMaxVideoAdapter", "LocalVideoAdapter").replace('provider = "minimax"', 'provider = "localvideo"')
|
|
guard_start = adapter.index(" if (!model.toLowerCase()")
|
|
guard_end = adapter.index(" const prompt =", guard_start)
|
|
adapter = adapter[:guard_start] + " if (!" + json.dumps(MODELS) + ".includes(model)) throw new Error(`Unknown local video model: ${model}`);\n" + adapter[guard_end:]
|
|
adapter = adapter.replace("MiniMax H3", "Local video")
|
|
resolution_start = adapter.index(" normalizeResolution(resolution) {")
|
|
adapter = adapter[:resolution_start] + ''' normalizeResolution(resolution) {
|
|
const value = (resolution || "720p").toUpperCase();
|
|
if (!["480P", "720P", "1080P", "768P", "2K"].includes(value)) throw new Error("Unsupported local video resolution");
|
|
return value;
|
|
}
|
|
};
|
|
'''
|
|
# Do not silently throw away file/link attachments unsupported by the local pool.
|
|
adapter = replace_once(adapter, ' const prompt =', ' if (record2.referenceFileUrl || record2.referenceLinkUrl) throw new Error("Local video requires image references");\n const prompt =')
|
|
backend = replace_once(backend, 'video: ["volcengine", "minimax", "aliyun"]', 'video: ["volcengine", "minimax", "aliyun", "localvideo"]')
|
|
backend = replace_once(backend, "var videoAdapters = {", adapter + "\nvar videoAdapters = {\n localvideo: new LocalVideoAdapter(),")
|
|
backend = replace_once(backend, ' if (p === "openai") {', ' if (p === "openai" || p === "localvideo") {')
|
|
encoded = backend.encode("utf-8")
|
|
entry["offset"], entry["size"] = str(len(data)), len(encoded)
|
|
block_size = entry["integrity"]["blockSize"]
|
|
entry["integrity"].update(hash=hashlib.sha256(encoded).hexdigest(), blocks=[hashlib.sha256(encoded[i:i + block_size]).hexdigest() for i in range(0, len(encoded), block_size)])
|
|
header = json.dumps(tree, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
|
|
pad = (-len(header)) % 4
|
|
header_size = 8 + len(header) + pad
|
|
# Keep production data beside the installation, outside the resettable
|
|
# Electron profile. An explicit storage-config.json still takes precedence.
|
|
main_entry = tree["files"]["dist"]["files"]["main.js"]
|
|
main_start = int(main_entry["offset"])
|
|
main_source = data[main_start:main_start + main_entry["size"]].decode("utf-8")
|
|
main_source = replace_once(main_source,
|
|
' const fallback = path5.join(import_electron3.app.getPath("userData"), "data");',
|
|
' const fallback = import_electron3.app.isPackaged ? path5.resolve(process.resourcesPath, "../../huobao-data") : path5.join(import_electron3.app.getPath("userData"), "data");')
|
|
main_bytes = main_source.encode("utf-8")
|
|
main_entry["offset"], main_entry["size"] = str(len(data) + len(encoded)), len(main_bytes)
|
|
main_block_size = main_entry["integrity"]["blockSize"]
|
|
main_entry["integrity"].update(hash=hashlib.sha256(main_bytes).hexdigest(), blocks=[hashlib.sha256(main_bytes[i:i + main_block_size]).hexdigest() for i in range(0, len(main_bytes), main_block_size)])
|
|
header = json.dumps(tree, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
|
|
pad = (-len(header)) % 4
|
|
header_size = 8 + len(header) + pad
|
|
packed = struct.pack("<4I", 4, header_size, header_size - 4, len(header)) + header + bytes(pad) + data + encoded + main_bytes
|
|
(WORK / "app.multivideo.asar").write_bytes(packed)
|
|
(WORK / "backend.multivideo.mjs").write_bytes(encoded)
|
|
(WORK / "main.persistent.js").write_bytes(main_bytes)
|
|
(WORK / "local-video-adapter.js").write_text(adapter, encoding="utf-8")
|
|
ui = (BACKUP / frontend.name).read_text("utf-8")
|
|
ui = replace_once(ui, 'Ls=["gemini","openai","volcengine","minimax","aliyun"]', 'Ls=["gemini","openai","volcengine","minimax","aliyun","localvideo"]')
|
|
preset = json.dumps({"label": "本地视频任务池", "baseUrl": "http://192.168.110.111:18792", "models": MODELS}, ensure_ascii=False, separators=(",", ":"))
|
|
ui = replace_once(ui, 'video:{aliyun:{', 'video:{localvideo:' + preset + ',aliyun:{')
|
|
(WORK / frontend.name).write_text(ui, encoding="utf-8")
|
|
translations = (BACKUP / locale.name).read_text("utf-8")
|
|
translations = replace_once(translations, "镜头视频直出生成，默认 Seedance 2.0", "镜头视频生成，可选择多个模型并设置默认")
|
|
translations = replace_once(translations, "Direct video generation, Seedance 2.0 by default", "Video generation with selectable models and defaults")
|
|
(WORK / locale.name).write_text(translations, encoding="utf-8")
|
|
if "--install" in sys.argv or "--frontend-only" in sys.argv:
|
|
if "--frontend-only" not in sys.argv:
|
|
shutil.copy2(WORK / "app.multivideo.asar", archive)
|
|
shutil.copy2(WORK / frontend.name, frontend)
|
|
shutil.copy2(WORK / locale.name, locale)
|
|
print("Installed local-video provider; originals:", BACKUP)
|
|
else:
|
|
print("Prepared local-video provider for", len(MODELS), "models")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
prepare()
|