@mevdragon/vidfarm-devcli 0.5.2 → 0.6.0

package/dist/src/services/composition-sanitize.js

@@ -0,0 +1,124 @@
+// Sanitizes composition.html before it is stored in a fork's S3 namespace.
+//
+// Fork content lives under a public-read S3 prefix and is rendered SAME-ORIGIN
+// inside the editor iframe (the editor needs same-origin DOM access to morph the
+// timeline). That means any <script> or inline handler an author embeds would
+// execute in a *viewer's* vidfarm.cc origin when a fork is shared — a stored-XSS
+// vector against other users. Compositions are declarative (data-* attributes
+// drive the injected runtime), so scripts are never needed in stored content:
+// the trusted runtime is (re)injected at serve time by
+// rewriteHyperframesDraftCompositionHtml. We therefore strip all author scripts,
+// inline on*= handlers, and javascript:/vbscript: URLs.
+//
+// This is a pragmatic regex sanitizer (the Lambda has no DOM). It errs toward
+// removing anything script-like; it is a hardening layer, not the only defense.
+const SCRIPT_TAG_RE = /<script\b[^>]*>[\s\S]*?<\/script\s*>/gi;
+// Void/self-closed or unterminated <script ...> with no closing tag.
+const LONE_SCRIPT_OPEN_RE = /<script\b[^>]*\/?>/gi;
+// Inline event handlers: on-word = "..." | '...' | bare token. Requires a
+// preceding whitespace so we don't match attributes like `data-on=""`.
+const INLINE_HANDLER_RE = /\son[a-z]+\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)/gi;
+// Dangerous URL schemes in a navigable attribute value. Matches the whole
+// value — quoted (single/double) or bare — so the closing quote is consumed and
+// the replacement stays well-formed.
+const DANGEROUS_SCHEME = String.raw `(?:javascript\s*:|vbscript\s*:|data\s*:\s*text\/html)`;
+const DANGEROUS_URL_RE = new RegExp(String.raw `((?:href|src|xlink:href|action|formaction)\s*=\s*)` +
+    String.raw `(?:"\s*${DANGEROUS_SCHEME}[^"]*"|'\s*${DANGEROUS_SCHEME}[^']*'|${DANGEROUS_SCHEME}[^\s>]*)`, "gi");
+export function sanitizeCompositionHtml(html) {
+    let scripts = 0;
+    let handlers = 0;
+    let urls = 0;
+    let out = html.replace(SCRIPT_TAG_RE, () => {
+        scripts += 1;
+        return "";
+    });
+    out = out.replace(LONE_SCRIPT_OPEN_RE, () => {
+        scripts += 1;
+        return "";
+    });
+    out = out.replace(INLINE_HANDLER_RE, () => {
+        handlers += 1;
+        return "";
+    });
+    out = out.replace(DANGEROUS_URL_RE, (_match, prefix) => {
+        urls += 1;
+        // Neutralize to a harmless anchor while preserving the attribute shape.
+        return `${prefix}"#"`;
+    });
+    const changed = scripts > 0 || handlers > 0 || urls > 0;
+    return { html: out, changed, removed: { scripts, handlers, urls } };
+}
+// Re-derives inline z-index from data-track-index on every open tag carrying
+// the attribute. The render pipeline (normalizePublishHtml) enforces
+// z-index = track — higher track draws in front — but the preview runtime
+// trusts whatever inline z is stored, so any stored html with stale or missing
+// z previews with the wrong stacking. Applying this at serve time keeps the
+// preview identical to the render for every composition, including ones never
+// touched by the current editor. String-only pass for the same reason as the
+// sanitizer above (no DOM in the Lambda; and DOM serialization re-quotes
+// font-family values, breaking the render's font resolver).
+const OPEN_TAG_RE = /<([a-zA-Z][a-zA-Z0-9-]*)((?:\s+[^\s"'>/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'`=<>]+))?)*)\s*(\/?)>/g;
+// Walks real attribute boundaries. A flat regex over the attr blob can match
+// `style=` or `data-track-index` text INSIDE another attribute's value
+// (e.g. a data-label containing markup), corrupting user content.
+const ATTR_RE = /\s+([^\s"'>/=]+)(?:\s*=\s*("[^"]*"|'[^']*'|[^\s"'`=<>]+))?/g;
+// KEEP IN SYNC with normalizeCompositionZIndex in
+// demo/src/HyperframesStudioEditor.tsx (client editor copy).
+export function normalizeCompositionZIndexHtml(html) {
+    if (!html || !html.includes("data-track-index"))
+        return html;
+    return html.replace(OPEN_TAG_RE, (match, tag, rawAttrs, selfClose) => {
+        let track = null;
+        let styleQuote = '"';
+        let styleValue = null;
+        let styleStart = -1;
+        let styleEnd = -1;
+        ATTR_RE.lastIndex = 0;
+        let attr;
+        while ((attr = ATTR_RE.exec(rawAttrs))) {
+            const name = attr[1].toLowerCase();
+            const rawValue = attr[2];
+            if (rawValue === undefined)
+                continue;
+            const quoted = rawValue.startsWith('"') || rawValue.startsWith("'");
+            const value = quoted ? rawValue.slice(1, -1) : rawValue;
+            if (name === "data-track-index") {
+                const parsed = Number.parseInt(value, 10);
+                if (Number.isFinite(parsed))
+                    track = parsed;
+            }
+            else if (name === "style") {
+                styleQuote = quoted ? rawValue[0] : '"';
+                styleValue = value;
+                styleStart = attr.index;
+                styleEnd = attr.index + attr[0].length;
+            }
+        }
+        if (track === null)
+            return match;
+        const desired = String(track);
+        if (styleValue !== null) {
+            let nextStyle;
+            if (/(^|;)\s*z-index\s*:/i.test(styleValue)) {
+                if (new RegExp(`(^|;)\\s*z-index\\s*:\\s*${desired}\\s*(;|$)`, "i").test(styleValue)) {
+                    return match;
+                }
+                // Replacer function: a plain replacement string would interpret $-
+                // sequences inside the surrounding style (e.g. content:'20$') as
+                // substitution metacharacters and corrupt the attribute.
+                nextStyle = styleValue.replace(/(^|;)\s*z-index\s*:\s*[^;]*/i, (_zMatch, lead) => `${lead}z-index:${desired}`);
+            }
+            else {
+                nextStyle = styleValue.endsWith(";") || styleValue.length === 0
+                    ? `${styleValue}z-index:${desired}`
+                    : `${styleValue};z-index:${desired}`;
+            }
+            // Rebuild by slicing around the style attribute — never String.replace
+            // with user-controlled content.
+            const rebuiltAttrs = `${rawAttrs.slice(0, styleStart)} style=${styleQuote}${nextStyle}${styleQuote}${rawAttrs.slice(styleEnd)}`;
+            return `<${tag}${rebuiltAttrs}${selfClose ? "/" : ""}>`;
+        }
+        return `<${tag}${rawAttrs} style="z-index:${desired}"${selfClose ? "/" : ""}>`;
+    });
+}
+//# sourceMappingURL=composition-sanitize.js.map

package/dist/src/services/composition-watch.js

@@ -0,0 +1,79 @@
+import { mkdirSync, watch } from "node:fs";
+import path from "node:path";
+import { config } from "../config.js";
+// fs.watch on macOS emits 1–3 events per save; coalesce a burst into one
+// broadcast. Also drop events for a fork the server itself just wrote (the
+// editor's own PUT) so a save doesn't echo back as a reload.
+const COALESCE_MS = 80;
+const SELF_WRITE_SUPPRESS_MS = 500;
+class CompositionWatch {
+    listeners = new Set();
+    suppressUntil = new Map();
+    started = false;
+    pending = null;
+    timer = null;
+    forksDir() {
+        return path.join(config.VIDFARM_DATA_DIR, "storage", "compositions", "forks");
+    }
+    start() {
+        if (this.started || config.STORAGE_DRIVER !== "local")
+            return;
+        this.started = true;
+        const dir = this.forksDir();
+        mkdirSync(dir, { recursive: true });
+        try {
+            watch(dir, { recursive: true }, (_event, filename) => {
+                if (filename)
+                    this.onFsEvent(String(filename));
+            });
+            console.log(`[vidfarm] live-reload watching ${dir}`);
+        }
+        catch (error) {
+            console.warn(`[vidfarm] live-reload watch failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // Call right before the server writes a working composition file so the
+    // editor's own save doesn't bounce back as an external reload.
+    suppressFork(forkId) {
+        this.suppressUntil.set(forkId, Date.now() + SELF_WRITE_SUPPRESS_MS);
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    onFsEvent(filename) {
+        // filename is relative to forksDir, e.g. "<forkId>/working/composition.html".
+        const parts = filename.split(/[\\/]/).filter(Boolean);
+        if (parts.length < 3 || parts[1] !== "working")
+            return;
+        const file = parts[2];
+        if (file !== "composition.html" && file !== "composition.json")
+            return;
+        const forkId = parts[0];
+        const until = this.suppressUntil.get(forkId);
+        if (until && Date.now() < until)
+            return;
+        this.pending = { forkId, file, at: Date.now() };
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            const change = this.pending;
+            this.pending = null;
+            if (change)
+                this.broadcast(change);
+        }, COALESCE_MS);
+    }
+    broadcast(change) {
+        for (const listener of [...this.listeners]) {
+            try {
+                listener(change);
+            }
+            catch {
+                // A dead SSE writer is dropped on its own onAbort; ignore here.
+            }
+        }
+    }
+}
+export const compositionWatch = new CompositionWatch();
+//# sourceMappingURL=composition-watch.js.map

package/dist/src/services/fork-access.js

@@ -0,0 +1,93 @@
+import { serverlessRecords } from "./serverless-records.js";
+export class ForkNotFoundError extends Error {
+    constructor() { super("Fork not found"); this.name = "ForkNotFoundError"; }
+}
+export class ForkAccessDeniedError extends Error {
+    needed;
+    constructor(needed) {
+        super(`Missing required capability: ${needed}`);
+        this.needed = needed;
+        this.name = "ForkAccessDeniedError";
+    }
+}
+const capabilitiesByRole = {
+    viewer: { canView: true, canEdit: false, canPublish: false },
+    editor: { canView: true, canEdit: true, canPublish: false },
+    publisher: { canView: true, canEdit: true, canPublish: true }
+};
+function ownerCaps() {
+    return { isOwner: true, canView: true, canEdit: true, canPublish: true, canShare: true, canDelete: true, role: "owner" };
+}
+function fromRole(role) {
+    return {
+        isOwner: false,
+        ...capabilitiesByRole[role],
+        canShare: false,
+        canDelete: false,
+        role
+    };
+}
+function mergeCaps(a, b) {
+    const stronger = roleStrength(a.role) >= roleStrength(b.role) ? a : b;
+    return {
+        isOwner: a.isOwner || b.isOwner,
+        canView: a.canView || b.canView,
+        canEdit: a.canEdit || b.canEdit,
+        canPublish: a.canPublish || b.canPublish,
+        canShare: a.canShare || b.canShare,
+        canDelete: a.canDelete || b.canDelete,
+        role: stronger.role
+    };
+}
+function roleStrength(role) {
+    switch (role) {
+        case "owner": return 4;
+        case "publisher": return 3;
+        case "editor": return 2;
+        case "viewer": return 1;
+        default: return 0;
+    }
+}
+function isExpired(expiresAt) {
+    if (!expiresAt)
+        return false;
+    return new Date(expiresAt).getTime() < Date.now();
+}
+export async function resolveForkAccess(input) {
+    const fork = await serverlessRecords.getCompositionFork(input.forkId);
+    if (!fork || fork.deletedAt) {
+        throw new ForkNotFoundError();
+    }
+    // Fork content lives under a public-read S3 prefix — any client with the
+    // fork_id can already fetch composition.html/json/manifest.json directly
+    // from S3. Reflect that reality in the API so read endpoints don't lie
+    // about protecting content that isn't actually protected. Edit/publish/
+    // share/delete stay gated below.
+    let caps = fromRole("viewer");
+    if (input.customerId && fork.customerId === input.customerId) {
+        caps = mergeCaps(caps, ownerCaps());
+    }
+    if (input.customerId) {
+        const allPerms = await serverlessRecords.listForkPermissions(fork.id);
+        const granted = allPerms.filter((perm) => perm.granteeType === "customer" && perm.granteeId === input.customerId && !isExpired(perm.expiresAt));
+        for (const perm of granted) {
+            caps = mergeCaps(caps, fromRole(perm.role));
+        }
+    }
+    if (input.shareToken) {
+        const link = await serverlessRecords.getForkShareLinkByToken(input.shareToken);
+        if (link && link.forkId === fork.id && !link.revokedAt && !isExpired(link.expiresAt)) {
+            caps = mergeCaps(caps, fromRole(link.role));
+        }
+    }
+    return { fork, capabilities: caps };
+}
+export async function assertForkAccess(input, required) {
+    const result = await resolveForkAccess(input);
+    const need = `can${required[0].toUpperCase()}${required.slice(1)}`;
+    if (!result.capabilities[need]) {
+        throw new ForkAccessDeniedError(need);
+    }
+    return result;
+}
+//# sourceMappingURL=fork-access.js.map

package/dist/src/services/fork-manifest.js

@@ -0,0 +1,42 @@
+function buildManifest(storage, fork, target) {
+    const isWorking = target.kind === "working";
+    const htmlKey = isWorking
+        ? storage.compositionForkWorkingKey(fork.id, "composition.html")
+        : storage.compositionForkVersionKey(fork.id, target.version, "composition.html");
+    const jsonKey = isWorking
+        ? storage.compositionForkWorkingKey(fork.id, "composition.json")
+        : storage.compositionForkVersionKey(fork.id, target.version, "composition.json");
+    const manifestKey = isWorking
+        ? storage.compositionForkWorkingKey(fork.id, "manifest.json")
+        : storage.compositionForkVersionKey(fork.id, target.version, "manifest.json");
+    const parentManifestKey = fork.parentForkId && fork.parentVersion
+        ? storage.compositionForkVersionKey(fork.parentForkId, fork.parentVersion, "manifest.json")
+        : null;
+    return {
+        fork_id: fork.id,
+        customer_id: fork.customerId,
+        is_working: isWorking,
+        version: isWorking ? null : target.version,
+        latest_version: fork.latestVersion,
+        parent_fork_id: fork.parentForkId,
+        parent_version: fork.parentVersion,
+        template_id: fork.templateId,
+        visibility: fork.visibility,
+        title: fork.title,
+        composition_url: storage.getPublicUrl(htmlKey),
+        composition_json_url: storage.getPublicUrl(jsonKey),
+        manifest_url: storage.getPublicUrl(manifestKey),
+        parent_manifest_url: parentManifestKey ? storage.getPublicUrl(parentManifestKey) : null,
+        created_at: !isWorking && target.kind === "version" && target.createdAt ? target.createdAt : fork.createdAt,
+        updated_at: fork.updatedAt
+    };
+}
+export async function writeForkManifest(storage, fork, target) {
+    const manifest = buildManifest(storage, fork, target);
+    const key = target.kind === "working"
+        ? storage.compositionForkWorkingKey(fork.id, "manifest.json")
+        : storage.compositionForkVersionKey(fork.id, target.version, "manifest.json");
+    await storage.putJson(key, manifest);
+    return manifest;
+}
+//# sourceMappingURL=fork-manifest.js.map

package/dist/src/services/ghostcut.js

@@ -0,0 +1,179 @@
+import { createHash } from "node:crypto";
+import { config } from "../config.js";
+const BASE_URL = "https://api.zhaoli.com";
+export function isGhostcutConfigured() {
+    return Boolean(config.GHOSTCUT_KEY && config.GHOSTCUT_SECRET);
+}
+// GhostCut bills per 30-second chunk with a 1-chunk minimum. A 45s clip is
+// 2 chunks, a 90s clip is 3. Rate defaults to $0.10 per chunk but can be
+// overridden via GHOSTCUT_USD_PER_30S.
+export function estimateGhostcutCostUsd(durationSeconds) {
+    const usdPerChunk = config.GHOSTCUT_USD_PER_30S;
+    const positiveSeconds = Number.isFinite(durationSeconds) && durationSeconds > 0 ? durationSeconds : 30;
+    const chunks = Math.max(1, Math.ceil(positiveSeconds / 30));
+    const usd = Number((chunks * usdPerChunk).toFixed(4));
+    return { chunks, usd, usdPerChunk };
+}
+function md5Hex(input) {
+    return createHash("md5").update(input).digest("hex");
+}
+async function ghostcutPost(path, payload, signal) {
+    if (!config.GHOSTCUT_KEY || !config.GHOSTCUT_SECRET) {
+        throw new Error("GhostCut credentials not configured");
+    }
+    const body = JSON.stringify(payload);
+    const sign = md5Hex(md5Hex(body) + config.GHOSTCUT_SECRET);
+    const response = await fetch(`${BASE_URL}${path}`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            AppKey: config.GHOSTCUT_KEY,
+            AppSign: sign
+        },
+        body,
+        signal
+    });
+    if (!response.ok) {
+        throw new Error(`GhostCut HTTP ${response.status} ${response.statusText}`);
+    }
+    return (await response.json());
+}
+// Submits a subtitle-removal task using GhostCut's Basic text-removal model.
+// We deliberately do NOT pass `extra_inpaint_config.model` — that would opt
+// into one of the Advanced tiers (Lite/Pro/Full), which are:
+//   1. More expensive per 30s chunk
+//   2. Require `videoInpaintMasks` to be supplied — advanced_lite in particular
+//      rejects with processStatus=26 / ValidationError
+//      ("video_inpaint_masks is not set") when no mask is passed
+// Basic is the cheapest tier and handles hardcoded TikTok-style captions fine
+// without requiring us to hand-crop a mask region for every video.
+//
+// needChineseOcclude=3 = "Automatically remove moving text". Per the docs this
+// is the smart mode that only touches AI-detected text and leaves backgrounds
+// alone — exactly what TikTok-style dynamic burned-in captions need. Mode 1
+// (full-screen inpainting) is more aggressive; mode 3 sidesteps that class of
+// failure while still catching the burned-in subtitles.
+// Returns quickly (<2s). Throws on non-1000 response codes (auth, credits, etc).
+export async function submitSubtitleRemoval(sourceUrl, signal) {
+    const payload = {
+        urls: [sourceUrl],
+        needChineseOcclude: 3,
+        videoInpaintLang: "all"
+    };
+    const res = await ghostcutPost("/v-w-c/gateway/ve/work/free", payload, signal);
+    if (res.code !== 1000) {
+        throw new Error(`GhostCut submit failed: code=${res.code} msg=${res.msg ?? "unknown"}`);
+    }
+    const taskId = res.body?.idProject ??
+        res.body?.dataList?.[0]?.idProject ??
+        res.body?.dataList?.[0]?.id;
+    if (typeof taskId !== "number") {
+        throw new Error(`GhostCut response missing task id: ${JSON.stringify(res)}`);
+    }
+    return { taskId };
+}
+export async function pollStatus(taskId, signal) {
+    const res = await ghostcutPost("/v-w-c/gateway/ve/work/status", { idProjects: [taskId] }, signal);
+    if (res.code !== 1000) {
+        return { state: "failed", reason: `status code=${res.code}` };
+    }
+    const entry = res.body?.content?.[0];
+    if (!entry) {
+        return { state: "queued", progress: 0 };
+    }
+    const processStatus = Number(entry.processStatus ?? 0);
+    const progress = Number(entry.processProgress ?? 0);
+    // GhostCut's canonical live states: 1 = done, 0 = processing, -2 = queued.
+    // Everything else is a terminal error condition. Notable codes we've hit
+    // in the wild: -1/2/3 (generic failure), 73 (insufficient points — account
+    // out of credits, task will NEVER progress). Treat all non-live codes as
+    // failed so we stop polling and fall back to the original video instead
+    // of spinning forever.
+    if (processStatus === 1) {
+        const rawUrl = entry.videoUrl ?? entry.videoUrls;
+        const videoUrl = Array.isArray(rawUrl) ? String(rawUrl[0] ?? "") : String(rawUrl ?? "");
+        if (!videoUrl)
+            return { state: "failed", reason: "processStatus=1 but no videoUrl" };
+        return { state: "done", videoUrl, progress: 100 };
+    }
+    if (processStatus === 0) {
+        return { state: "processing", progress };
+    }
+    if (processStatus === -2) {
+        return { state: "queued", progress };
+    }
+    // Any other code is terminal-failure. Assemble the most helpful reason
+    // string GhostCut gives us, in priority order:
+    //   1. processStatusEnum.descriptionEn — official English label for the code
+    //   2. errorDetail — long-form failure message ("Video too short", etc.)
+    //   3. errorMsg — short label
+    //   4. compact raw entry dump — fallback so unknown codes still capture
+    //      whatever fields GhostCut populated, letting us reverse-engineer
+    //      new failure modes without a second API round-trip.
+    // The Appendix A enum table (Feishu-only) isn't public, so relying on
+    // GhostCut's own free-text fields is the only way to name codes like 26.
+    const enumObj = entry.processStatusEnum;
+    const enumEn = typeof enumObj?.descriptionEn === "string" ? enumObj.descriptionEn.trim() : "";
+    const errorDetail = typeof entry.errorDetail === "string" ? entry.errorDetail.trim() : "";
+    const errorMsg = typeof entry.errorMsg === "string" ? entry.errorMsg.trim() : "";
+    const parts = [];
+    if (enumEn)
+        parts.push(enumEn);
+    if (errorDetail && errorDetail !== enumEn)
+        parts.push(`detail=${errorDetail}`);
+    if (errorMsg && errorMsg !== enumEn && errorMsg !== errorDetail)
+        parts.push(`msg=${errorMsg}`);
+    if (parts.length === 0) {
+        // Nothing human-readable — dump the raw payload so operators can still see
+        // whatever GhostCut *did* send back.
+        return { state: "failed", reason: `processStatus=${processStatus} raw=${safeCompactJson(entry, 500)}` };
+    }
+    return { state: "failed", reason: `processStatus=${processStatus} ${parts.join(" ")}` };
+}
+// Best-effort compact stringifier — clamps the output so a huge GhostCut
+// entry doesn't blow up the log line, and falls back to a marker string
+// when serialization itself fails (circular refs shouldn't happen but
+// defense-in-depth for JSON.stringify).
+function safeCompactJson(value, maxLen) {
+    try {
+        const raw = JSON.stringify(value);
+        if (raw.length <= maxLen)
+            return raw;
+        return `${raw.slice(0, maxLen)}…(+${raw.length - maxLen}b)`;
+    }
+    catch {
+        return "<unserializable>";
+    }
+}
+// Polls GhostCut until the task is done, fails, or the timeout expires.
+// Throws on failure/timeout — callers use that to fall back to the original video.
+export async function waitForCompletion(taskId, opts) {
+    const started = Date.now();
+    const pollIntervalMs = opts.pollIntervalMs ?? 5000;
+    while (true) {
+        if (opts.signal?.aborted)
+            throw new Error("GhostCut wait aborted");
+        const remaining = opts.timeoutMs - (Date.now() - started);
+        if (remaining <= 0)
+            throw new Error(`GhostCut task ${taskId} timed out`);
+        const status = await pollStatus(taskId, opts.signal);
+        if (status.state === "done")
+            return { videoUrl: status.videoUrl };
+        if (status.state === "failed")
+            throw new Error(`GhostCut task ${taskId} failed: ${status.reason}`);
+        await new Promise((resolve) => setTimeout(resolve, Math.min(pollIntervalMs, remaining)));
+    }
+}
+// Downloads the GhostCut-hosted result and mirrors it to our S3 bucket so
+// composition HTML can point at a stable URL under our control (rather than a
+// short-lived third-party CDN link).
+export async function mirrorGhostcutVideoToStorage(input) {
+    const response = await fetch(input.videoUrl, { signal: input.signal });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch GhostCut result: HTTP ${response.status}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const result = await input.storage.putBuffer(input.key, Buffer.from(arrayBuffer), "video/mp4");
+    return { key: result.key, publicUrl: result.url };
+}
+//# sourceMappingURL=ghostcut.js.map