@mevdragon/vidfarm-devcli 0.8.0 → 0.10.0

package/dist/src/devcli/telemetry.js

@@ -0,0 +1,236 @@
+// Opt-out crash telemetry for the vidfarm devcli — the `vidfarm ...` commands
+// AND the local `serve` editor server. Unlike the backend/browser Sentry setups
+// (which run on OUR infrastructure), this runs on END USERS' machines, so it is
+// built defensively:
+//
+//   * DEDICATED DSN — never the backend or browser project. Ships EMPTY, i.e.
+//     fully DISABLED, until VIDFARM_DEVCLI_SENTRY_DSN (or the DEVCLI_SENTRY_DSN
+//     constant below) points at a Sentry project created specifically for the
+//     CLI. That keeps devcli crashes out of product error streams and means the
+//     published package never carries a DSN that could be abused for quota spam.
+//   * OPT-OUT — honors DO_NOT_TRACK (https://consoledonottrack.com) and
+//     VIDFARM_TELEMETRY=off|0|false|no|disabled.
+//   * CRASH-ONLY — deliberate `throw new Error("...")` user errors (bad args,
+//     HTTP 4xx, missing files) and transient network failures are NOT reported;
+//     only unexpected bugs (TypeError/RangeError/… and non-Error throws) are.
+//   * SCRUBBED — beforeSend strips home-dir paths, api keys, auth headers, and
+//     known env secrets before anything leaves the machine; PII is off; console
+//     breadcrumbs (which can carry prompts / composition text) are dropped.
+//   * FLUSHED — flushTelemetry() drains the queue before the short-lived CLI exits.
+//
+// Every entry point is wrapped so telemetry can NEVER break a user's command.
+import { readFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import * as Sentry from "@sentry/node";
+// Set this to a DSN for a Sentry project dedicated to the devcli (NOT the
+// backend or browser project). Left empty so the published package is silent
+// until such a project exists; VIDFARM_DEVCLI_SENTRY_DSN overrides it at runtime.
+const DEVCLI_SENTRY_DSN = "";
+let initialized = false;
+// Env vars whose values must never leave the machine, even if they surface in
+// an error message or stack. Values are collected at init and redacted verbatim.
+const SECRET_ENV_KEYS = [
+    "VIDFARM_API_KEY",
+    "VIDFARM_STAGING_BOOTSTRAP_API_KEY",
+    "OPENAI_API_KEY",
+    "OPENROUTER_API_KEY",
+    "GEMINI_API_KEY",
+    "PERPLEXITY_API_KEY",
+    "GHOSTCUT_KEY",
+    "GHOSTCUT_SECRET",
+    "ENCRYPTION_SECRET",
+    "API_KEY_SALT",
+    "WEBHOOK_SECRET",
+    "RESEND_API_KEY",
+    "AWS_ACCESS_KEY_ID",
+    "AWS_SECRET_ACCESS_KEY"
+];
+const HOME_DIR = safeHomedir();
+let secretValues = [];
+// Token-shaped strings redacted regardless of source (belt-and-suspenders on top
+// of the exact env-value match above).
+const TOKEN_PATTERNS = [
+    /\b(?:vf|sk|rk|pk|key)_[A-Za-z0-9_-]{8,}\b/g, // vidfarm / provider-style keys
+    /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g, // JWT
+    /\bAKIA[0-9A-Z]{16}\b/g, // AWS access key id
+    /\bBearer\s+[A-Za-z0-9._~+/=-]+/gi
+];
+// Transient / environmental failures we never want to page on — they are the
+// user's network, not our bug.
+const BENIGN_MESSAGE = /(fetch failed|ECONNREFUSED|ECONNRESET|ENOTFOUND|ETIMEDOUT|EAI_AGAIN|socket hang up|getaddrinfo|network|and requires a connection)/i;
+function safeHomedir() {
+    try {
+        return os.homedir() || "";
+    }
+    catch {
+        return "";
+    }
+}
+function isOptedOut() {
+    // DO_NOT_TRACK: any value other than unset / "0" / "false" means opt out.
+    const dnt = process.env.DO_NOT_TRACK?.trim();
+    if (dnt && dnt !== "0" && dnt.toLowerCase() !== "false")
+        return true;
+    const flag = process.env.VIDFARM_TELEMETRY?.trim().toLowerCase();
+    if (flag && ["0", "off", "false", "no", "disabled"].includes(flag))
+        return true;
+    return false;
+}
+function resolveDsn() {
+    return (process.env.VIDFARM_DEVCLI_SENTRY_DSN?.trim() || DEVCLI_SENTRY_DSN || "").trim();
+}
+function readPackageVersion() {
+    try {
+        let dir = path.dirname(fileURLToPath(import.meta.url));
+        for (let i = 0; i < 6; i++) {
+            try {
+                const parsed = JSON.parse(readFileSync(path.join(dir, "package.json"), "utf8"));
+                if (parsed.name === "@mevdragon/vidfarm-devcli" && parsed.version) {
+                    return `vidfarm-devcli@${parsed.version}`;
+                }
+            }
+            catch {
+                // keep walking up
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch {
+        // ignore — release tag is best-effort
+    }
+    return undefined;
+}
+function scrubString(input) {
+    let s = input;
+    if (HOME_DIR && s.includes(HOME_DIR))
+        s = s.split(HOME_DIR).join("~");
+    for (const secret of secretValues) {
+        if (secret && s.includes(secret))
+            s = s.split(secret).join("[REDACTED]");
+    }
+    for (const re of TOKEN_PATTERNS)
+        s = s.replace(re, "[REDACTED]");
+    // `--api-key <value>` on the command line and `header: value` shaped pairs.
+    s = s.replace(/(--api-key[=\s]+)\S+/gi, "$1[REDACTED]");
+    s = s.replace(/((?:vidfarm-api-key|authorization|x-api-key)["']?\s*[:=]\s*["']?)[^"'\s,}]+/gi, "$1[REDACTED]");
+    return s;
+}
+function scrubDeep(value, depth) {
+    if (value == null || depth > 8)
+        return value;
+    if (typeof value === "string")
+        return scrubString(value);
+    if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++)
+            value[i] = scrubDeep(value[i], depth + 1);
+        return value;
+    }
+    if (typeof value === "object") {
+        const record = value;
+        for (const key of Object.keys(record))
+            record[key] = scrubDeep(record[key], depth + 1);
+        return record;
+    }
+    return value;
+}
+/** Deliberate `throw new Error("...")` user errors have name "Error"; genuine
+ *  bugs surface as TypeError/RangeError/ReferenceError/… or as non-Error throws.
+ *  Transient network failures are treated as expected. */
+export function isUnexpectedCrash(error) {
+    if (!(error instanceof Error))
+        return true;
+    if (BENIGN_MESSAGE.test(error.message))
+        return false;
+    return error.name !== "Error";
+}
+export function isTelemetryEnabled() {
+    return initialized;
+}
+export function initTelemetry(commandName) {
+    try {
+        if (initialized)
+            return;
+        if (isOptedOut())
+            return;
+        const dsn = resolveDsn();
+        if (!dsn)
+            return;
+        secretValues = SECRET_ENV_KEYS.map((key) => process.env[key]?.trim() ?? "").filter((v) => v.length >= 8);
+        Sentry.init({
+            dsn,
+            environment: "devcli",
+            release: process.env.VIDFARM_DEVCLI_RELEASE?.trim() || readPackageVersion(),
+            // Short-lived CLI: no performance tracing, no log capture (logs can carry
+            // prompts / composition text), tiny breadcrumb budget.
+            tracesSampleRate: 0,
+            enableLogs: false,
+            sendDefaultPii: false,
+            maxBreadcrumbs: 20,
+            beforeBreadcrumb(breadcrumb) {
+                if (breadcrumb.category === "console")
+                    return null;
+                try {
+                    return scrubDeep(breadcrumb, 0);
+                }
+                catch {
+                    return null; // if scrubbing fails, drop rather than risk leaking
+                }
+            },
+            beforeSend(event) {
+                try {
+                    if (event.request) {
+                        delete event.request.data;
+                        delete event.request.cookies;
+                        delete event.request.headers;
+                    }
+                    return scrubDeep(event, 0);
+                }
+                catch {
+                    return null; // scrub failed → drop the event entirely, never leak raw
+                }
+            }
+        });
+        Sentry.setTags({
+            "vidfarm.surface": "devcli",
+            "vidfarm.node": process.version,
+            "vidfarm.platform": `${process.platform}-${process.arch}`,
+            ...(commandName ? { "vidfarm.command": commandName } : {})
+        });
+        initialized = true;
+    }
+    catch {
+        // Telemetry must never break the CLI.
+        initialized = false;
+    }
+}
+/** Report an unexpected top-level CLI crash (no-op for expected user errors,
+ *  transient network errors, or when telemetry is disabled), then flush. */
+export async function reportCliCrash(error) {
+    try {
+        if (!initialized)
+            return;
+        if (!isUnexpectedCrash(error))
+            return;
+        Sentry.captureException(error);
+        await flushTelemetry();
+    }
+    catch {
+        // swallow — never let telemetry change the exit path
+    }
+}
+export async function flushTelemetry(timeoutMs = 2000) {
+    try {
+        if (!initialized)
+            return;
+        await Sentry.flush(timeoutMs);
+    }
+    catch {
+        // swallow
+    }
+}
+//# sourceMappingURL=telemetry.js.map

package/dist/src/editor-chat.js

@@ -41,7 +41,7 @@ export function buildTemplateEditorChatSystemPrompt(input) {
         "Use POST /api/v1/primitives/images/edit only when the user wants to revise the attached/source image itself; its body is { tracer, payload: { source_image_url, instruction, reference_attachments? } }. Use POST /api/v1/primitives/images/generate when they want a new image inspired by or similar to the attachment.",
         "If the user asks to modify an attached image and the message includes an attachment URL, call POST /api/v1/primitives/images/edit with source_image_url inside payload set to that exact URL and instruction inside payload set to the requested edit.",
         "If the user asks to generate a new AI video from text or reference images, call POST /api/v1/primitives/videos/generate with body { tracer, payload: { prompt, input_references?, duration? } }. AI video duration is seconds; use duration: 4 for a 4-second video and never use duration_ms on /videos/generate. input_references must be direct image asset URLs, not webpage or social post URLs. Use frame_images for exact first/last-frame image-to-video.",
-        "If the user asks to render HTML/design into an image, call POST /api/v1/primitives/images/render-html. If the user asks to turn existing media URLs into a slideshow/video, call POST /api/v1/primitives/videos/render-slides. If the user asks to dedupe, camouflage, or apply small zoom/tilt/rotate/filter/tint transforms to an image or video for reuse, call POST /api/v1/primitives/media/dedupe with body { tracer, payload: { source_media_url, media_type?, effects?: { zoom?, tilt?, rotate?, saturation?, speed?, horizontal_flip?, contrast?, brightness?, hue_rotate?, blur? }, tint_color?, tint_opacity?, width?, height?, duration_ms?, object_fit?, background_color?, output_format? }, webhook_url? }. Primitive media utility routes are also allowed directly here, including /videos/trim, /videos/remove-captions, /videos/extract-audio, /videos/probe, /videos/extract-frame, /videos/mute, /videos/replace-audio, /videos/concat, /audio/trim, /audio/probe, /audio/concat, and /audio/normalize. If the user asks to remove burned-in captions, subtitles, or on-screen text from a video, call POST /api/v1/primitives/videos/remove-captions with body { tracer, payload: { source_video_url } } — an async job that returns a durable caption-free MP4 and bills about $0.10 per 30 seconds of source video.",
+        "If the user asks to render HTML/design into an image, call POST /api/v1/primitives/images/render-html. If the user asks to turn existing media URLs into a slideshow/video, call POST /api/v1/primitives/videos/render-slides. If the user asks to dedupe, camouflage, or apply small zoom/tilt/rotate/filter/tint transforms to an image or video for reuse, call POST /api/v1/primitives/media/dedupe with body { tracer, payload: { source_media_url, media_type?, effects?: { zoom?, tilt?, rotate?, saturation?, speed?, horizontal_flip?, contrast?, brightness?, hue_rotate?, blur? }, tint_color?, tint_opacity?, width?, height?, duration_ms?, object_fit?, background_color?, output_format? }, webhook_url? }. Primitive media utility routes are also allowed directly here, including /videos/trim, /videos/remove-captions, /videos/extract-audio, /videos/probe, /videos/extract-frame, /videos/mute, /videos/replace-audio, /videos/concat, /audio/trim, /audio/probe, /audio/concat, and /audio/normalize. If the user asks to remove burned-in captions, subtitles, or on-screen text from a video, call POST /api/v1/primitives/videos/remove-captions with body { tracer, payload: { source_video_url } } — an async job that returns a durable caption-free MP4 and bills about $0.10 per 30 seconds of source video. Caption removal is capped at ~15 minutes of source and must NEVER be used on long-form video: when the user wants short clips out of a long video (a podcast, stream VOD, webinar, or a YouTube/TikTok/IG/X URL), call POST /clips/scan instead with body { source_url | temp_file_id | s3_key, prompt, ranges?: [\"MM:SS-MM:SS\"], target_duration_sec?, aspect?: \"9:16\"|\"16:9\"|\"4:3\"|\"1:1\", avoid_text?, tracer? } — target_duration_sec is a SOFT range (30 → 20-40s), ranges restrict the hunt to those source windows (big cost saver), aspect crops every clip, and avoid_text prefers text-free scenes via scene SELECTION (never caption removal on the source). The hunt is async (202 + scan_id): poll GET /clips/scan/:scanId, then browse GET /clips/feed?source=<source_video_id> or POST /clips/search. Hunts bill AWS compute only — the AI tagging runs on the user's own saved provider keys. To erase captions from a finished HUNTED clip, pass that short mp4 to /videos/remove-captions afterwards.",
         "Brainstorm primitives are also available directly here. If the user explicitly asks for hooks, angles, awareness-stage advice, a cold-start strategy questionnaire, or product-placement opportunities in a video, call the matching brainstorm primitive immediately instead of brainstorming in chat from memory. Use POST /api/v1/primitives/brainstorm/coldstart with body { tracer, payload: { user_message }, webhook_url? } when the user is clueless and needs foundational strategy questions. Use /brainstorm/awareness_stages with body { tracer, payload: { offer_description }, webhook_url? } when they are unsure what type of ads to make. Use /brainstorm/angles with body { tracer, payload: { offer_description, problem_awareness, solution_awareness }, webhook_url? } when they want persuasive ad angles; problem_awareness must be problem_unaware or problem_aware, and solution_awareness must be solution_unaware or solution_aware. Use /brainstorm/hooks with body { tracer, payload: { offer_description }, webhook_url? } when they are stuck on openings and want many hooks.",
         "Product placement is a first-class brainstorm primitive, just like angles and hooks. When the user asks to identify product-placement opportunities in a video, or to repurpose a video into a native ad for their product, prefer POST /api/v1/primitives/brainstorm/product_placement with body { tracer, payload: { source_video_url, offer_description }, webhook_url? }. source_video_url is the exact video to analyze — for the current composition, first call GET /api/v1/compositions/:forkId/remove-video-captions to pick the correct source (the ORIGINAL uploaded video vs the DECOMPOSED, caption-free video), then pass that URL. offer_description is the user's product/offer. This primitive watches the video and returns timestamped, native placement opportunities. It prefers a Gemini key for video understanding.",
         "BEFORE calling /brainstorm/product_placement for the CURRENT composition, first call the product_placement_context tool (or GET /api/v1/compositions/:forkId/product-placement.json). Decompose already scouted product-AGNOSTIC placement surfaces for this fork — real, grounded moments (timestamp, surface_type, surface_note, best_for, why_it_works). Use those surfaces to ground your answer and to seed the primitive: fold the strongest surfaces into offer_description (for example append 'Known native placement surfaces: 0:04 empty desk prop; 0:12 phone screen swap') so the product-specific pass builds on grounded moments instead of re-watching blind. If the user just wants a quick conversational take on where their product could go, the surfaces from product_placement_context are often enough to answer directly without the billable primitive.",

package/dist/src/frontend/homepage-view.js

@@ -11,9 +11,6 @@ function LibraryIcon() {
 function CalendarIcon() {
     return _jsxs("svg", { viewBox: "0 0 20 20", fill: "none", stroke: "currentColor", strokeWidth: "1.7", strokeLinecap: "round", strokeLinejoin: "round", children: [_jsx("circle", { cx: "10", cy: "10", r: "7.2" }), _jsx("path", { d: "M10 6.3v4.1l2.8 1.7" })] });
 }
-function ClipsIcon() {
-    return _jsxs("svg", { viewBox: "0 0 20 20", fill: "none", stroke: "currentColor", strokeWidth: "1.7", strokeLinecap: "round", strokeLinejoin: "round", children: [_jsx("rect", { x: "3", y: "4.5", width: "14", height: "11", rx: "1.5" }), _jsx("path", { d: "M3 8h14" }), _jsx("path", { d: "M6.2 4.7 4.6 8" }), _jsx("path", { d: "M9.6 4.7 8 8" }), _jsx("path", { d: "M13 4.7 11.4 8" })] });
-}
 function ChatIcon() {
     return _jsxs("svg", { viewBox: "0 0 20 20", fill: "none", stroke: "currentColor", strokeWidth: "1.7", strokeLinecap: "round", strokeLinejoin: "round", children: [_jsx("path", { d: "M4.2 5.2a2 2 0 0 1 2-2h7.6a2 2 0 0 1 2 2v5.6a2 2 0 0 1-2 2H9.2l-4.1 3.1v-3.1a2 2 0 0 1-.9-1.7Z" }), _jsx("path", { d: "M7.3 7.1h5.4" }), _jsx("path", { d: "M7.3 9.6h3.7" })] });
 }
@@ -58,13 +55,11 @@ function PrimaryNav({ account }) {
         ? [
             { id: "discover", href: withAccountQuery("/discover", account.userId), label: "Discover", icon: _jsx(DiscoverIcon, {}) },
             { id: "library", href: withAccountQuery("/library", account.userId), label: "Library", icon: _jsx(LibraryIcon, {}) },
-            { id: "clips", href: "/clips", label: "Clips", icon: _jsx(ClipsIcon, {}) },
             { id: "calendar", href: withAccountQuery("/calendar", account.userId), label: "Calendar", icon: _jsx(CalendarIcon, {}) },
             { id: "settings", href: withAccountQuery("/settings", account.userId), label: "Settings", icon: _jsx(SettingsIcon, {}) }
         ]
         : [
             { id: "discover", href: "/discover", label: "Discover", icon: _jsx(DiscoverIcon, {}) },
-            { id: "clips", href: "/clips", label: "Clips", icon: _jsx(ClipsIcon, {}) },
             { id: "login", href: "/login", label: "Login", icon: _jsx(SettingsIcon, {}) }
         ];
     const menuItems = account.isLoggedIn

package/dist/src/frontend/template-editor-chat.js

@@ -3501,6 +3501,213 @@ export function TemplateEditorChat({ boot }) {
         }
         await appendFiles(files);
     }
+    // "create me a video of…" / "replicate this URL…" — the discover-chat-only
+    // create_video tool returns the user's intent; we run the SAME pipeline the
+    // devcli `create`/`replicate` commands run, here in the browser, updating this
+    // assistant message as it progresses and appending an "Open in editor" link
+    // when the new video is ready. Long-running but visible; all same-origin API
+    // calls (the source download happens server-side in the ingest primitive).
+    async function runCreateVideoFlow(threadId, messageId, intentRaw) {
+        const intent = intentRaw ?? {};
+        const apiKey = boot.vidfarmApiKey;
+        const origin = window.location.origin;
+        const jsonHeaders = buildAuthHeaders(apiKey, "application/json");
+        const getHeaders = buildAuthHeaders(apiKey);
+        const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+        const patch = (status, appendText) => {
+            updateThread(threadId, (thread) => ({
+                ...thread,
+                updatedAt: new Date().toISOString(),
+                messages: thread.messages.map((message) => (message.id === messageId
+                    ? {
+                        ...message,
+                        isPending: false,
+                        statusText: status ?? message.statusText,
+                        text: appendText ? appendDistinctMessageText(message.text, appendText) : message.text
+                    }
+                    : message))
+            }));
+        };
+        const readJson = async (res) => {
+            const text = await res.text();
+            try {
+                return text ? JSON.parse(text) : null;
+            }
+            catch {
+                return null;
+            }
+        };
+        const pollInspirationReady = async (inspirationId) => {
+            const deadline = Date.now() + 5 * 60 * 1000;
+            for (;;) {
+                const res = await fetch(new URL(`/api/v1/videos/${encodeURIComponent(inspirationId)}`, origin), { headers: getHeaders });
+                const json = await readJson(res);
+                const status = String(json?.status ?? "");
+                if (status === "ready")
+                    return json;
+                if (status === "failed")
+                    throw new Error(`source video download failed${json?.error ? `: ${json.error}` : ""}.`);
+                if (Date.now() > deadline)
+                    throw new Error("source video download timed out.");
+                await sleep(5000);
+            }
+        };
+        const resolveJobMediaUrl = (job) => {
+            const readStr = (value) => (typeof value === "string" && value.trim() ? value.trim() : null);
+            const result = (job?.result && typeof job.result === "object") ? job.result : {};
+            const output = (result.output && typeof result.output === "object") ? result.output : result;
+            const direct = readStr(output?.primary_file_url) ?? readStr(output?.video?.file_url) ?? readStr(output?.image?.file_url) ?? readStr(output?.render?.output_url);
+            if (direct)
+                return direct;
+            if (Array.isArray(output?.files)) {
+                for (const file of output.files) {
+                    const url = readStr(typeof file === "string" ? file : (file?.file_url ?? file?.url));
+                    if (url)
+                        return url;
+                }
+            }
+            if (Array.isArray(job?.artifacts)) {
+                for (const artifact of job.artifacts) {
+                    const url = readStr(artifact?.public_url);
+                    if (url)
+                        return url;
+                }
+            }
+            return null;
+        };
+        const pollJobMedia = async (jobId) => {
+            const deadline = Date.now() + 8 * 60 * 1000;
+            for (;;) {
+                await sleep(5000);
+                const res = await fetch(new URL(`/api/v1/user/me/jobs/${encodeURIComponent(jobId)}`, origin), { headers: getHeaders });
+                const json = await readJson(res);
+                const status = String(json?.status ?? "");
+                const url = resolveJobMediaUrl(json);
+                if (url)
+                    return url;
+                if (status === "failed" || status === "cancelled")
+                    throw new Error(`generation ${status}.`);
+                if (Date.now() > deadline)
+                    throw new Error("generation timed out.");
+            }
+        };
+        // Wrap a generated MP4 into a new template via the upload-ingest path (the
+        // same route `inspiration-add <file>` uses). The generated media lives on
+        // public-read storage (bucket CORS allows a browser GET), so we can pull the
+        // blob and re-upload it.
+        const ingestGeneratedVideo = async (mediaUrl, title) => {
+            const blob = await (await fetch(mediaUrl)).blob();
+            const presignRes = await fetch(new URL("/discover/templates/upload/presign", origin), {
+                method: "POST",
+                headers: jsonHeaders,
+                body: JSON.stringify({ file_name: "generated.mp4", content_type: "video/mp4", size_bytes: blob.size })
+            });
+            const presign = await readJson(presignRes);
+            if (!presignRes.ok)
+                throw new Error(presign?.error || `upload presign failed (${presignRes.status})`);
+            let storageKey = presign?.storage_key;
+            let uploadedName = presign?.file_name || "generated.mp4";
+            if (presign?.transport === "presigned" && presign?.upload?.url) {
+                const put = await fetch(presign.upload.url, { method: presign.upload.method || "PUT", headers: presign.upload.headers || {}, body: blob });
+                if (!put.ok)
+                    throw new Error(`upload failed (${put.status})`);
+            }
+            else {
+                const form = new FormData();
+                form.append("file", blob, "generated.mp4");
+                const up = await fetch(new URL(presign?.upload?.url || "/discover/templates/upload", origin), { method: "POST", headers: getHeaders, body: form });
+                const upJson = await readJson(up);
+                if (!up.ok || !upJson?.storage_key)
+                    throw new Error(upJson?.error || `upload failed (${up.status})`);
+                storageKey = upJson.storage_key;
+                uploadedName = upJson.file_name || "generated.mp4";
+            }
+            if (!storageKey)
+                throw new Error("upload did not return a storage key.");
+            const addRes = await fetch(new URL("/discover/templates", origin), {
+                method: "POST",
+                headers: jsonHeaders,
+                body: JSON.stringify({ upload: { storage_key: storageKey, file_name: uploadedName }, title })
+            });
+            const add = await readJson(addRes);
+            if (!addRes.ok)
+                throw new Error(add?.error || `ingest failed (${addRes.status})`);
+            return add;
+        };
+        try {
+            if (!apiKey) {
+                patch(null, "⚠️ You need to be logged in to create a video.");
+                return;
+            }
+            const mode = intent.mode === "replicate" ? "replicate" : intent.mode === "generate" ? "generate" : null;
+            let inspiration;
+            let userPrompt;
+            if (mode === "replicate") {
+                const sourceUrl = (intent.source_url ?? "").trim();
+                if (!/^https?:\/\//i.test(sourceUrl)) {
+                    patch(null, "⚠️ I need a video URL (TikTok/YouTube/Instagram/X) to replicate.");
+                    return;
+                }
+                userPrompt = (intent.instructions ?? "").trim() || null;
+                patch("Fetching the source video…");
+                const addRes = await fetch(new URL("/discover/templates", origin), { method: "POST", headers: jsonHeaders, body: JSON.stringify({ source_url: sourceUrl }) });
+                const add = await readJson(addRes);
+                if (!addRes.ok)
+                    throw new Error(add?.error || `couldn't fetch that URL (${addRes.status})`);
+                inspiration = add?.status === "ready" ? add : await pollInspirationReady(add?.inspiration_id);
+            }
+            else if (mode === "generate") {
+                const prompt = (intent.prompt ?? "").trim();
+                if (!prompt) {
+                    patch(null, "⚠️ Tell me what the video should be about and I'll create it.");
+                    return;
+                }
+                userPrompt = prompt;
+                patch("Generating your video… (this can take a couple of minutes)");
+                const genRes = await fetch(new URL("/api/v1/primitives/videos/generate", origin), {
+                    method: "POST",
+                    headers: jsonHeaders,
+                    body: JSON.stringify({ tracer: `chat-create-${Date.now().toString(36)}`, payload: { prompt } })
+                });
+                const gen = await readJson(genRes);
+                if (!genRes.ok)
+                    throw new Error(gen?.error || `couldn't start generation (${genRes.status})`);
+                const mediaUrl = await pollJobMedia(gen?.job_id);
+                patch("Building an editable template from the generated video…");
+                const add = await ingestGeneratedVideo(mediaUrl, prompt.slice(0, 80));
+                inspiration = add?.status === "ready" ? add : await pollInspirationReady(add?.inspiration_id);
+            }
+            else {
+                patch(null, "⚠️ I couldn't tell whether to generate a new video or replicate a URL — try rephrasing.");
+                return;
+            }
+            const templateId = inspiration?.template_id;
+            const inspirationId = inspiration?.inspiration_id;
+            if (!templateId || !inspirationId)
+                throw new Error("the template wasn't created from the video.");
+            patch(mode === "replicate" ? "Recreating the scenes… (about a minute)" : "Analyzing into an editable timeline…");
+            const decRes = await fetch(new URL(`/api/v1/inspirations/${encodeURIComponent(inspirationId)}/decompose`, origin), {
+                method: "POST",
+                headers: jsonHeaders,
+                body: JSON.stringify({ user_prompt: userPrompt })
+            });
+            if (!decRes.ok) {
+                const dec = await readJson(decRes);
+                throw new Error(dec?.error || `scene analysis failed (${decRes.status})`);
+            }
+            patch("Finalizing your editable copy…");
+            const forkRes = await fetch(new URL("/api/v1/compositions", origin), { method: "POST", headers: jsonHeaders, body: JSON.stringify({ template_id: templateId }) });
+            const fork = await readJson(forkRes);
+            if (!forkRes.ok)
+                throw new Error(fork?.error || `couldn't create an editable copy (${forkRes.status})`);
+            const forkId = fork?.fork_id;
+            const editorUrl = `${origin}/editor/${encodeURIComponent(templateId)}${forkId ? `?fork=${encodeURIComponent(forkId)}` : ""}`;
+            patch("Your video is ready.", `✅ Your video is ready — [Open it in the editor](${editorUrl}).`);
+        }
+        catch (error) {
+            patch(null, `⚠️ I couldn't finish creating the video: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     async function handleSend() {
         if (!canSend) {
             return;
@@ -3661,6 +3868,11 @@ export function TemplateEditorChat({ boot }) {
                 onToolResult: (toolResult) => {
                     const sanitizedToolResult = sanitizeToolResult(toolResult.result);
                     const pendingCall = pendingToolCalls.get(toolResult.toolCallId);
+                    if (toolResult.toolName === "create_video") {
+                        // Fire-and-forget: run the ingest→decompose→fork pipeline in the
+                        // browser, streaming progress into this assistant message.
+                        void runCreateVideoFlow(threadId, assistantMessage.id, toolResult.result);
+                    }
                     if (toolResult.toolName === "frontend_action") {
                         const actionResult = toolResult.result;
                         if (actionResult?.action === "add_tracer") {

package/dist/src/page-shell.js

@@ -756,6 +756,53 @@ export function renderPageShell(input) {
         color: var(--muted);
       }
 
+      .view-toggle {
+        display: inline-flex;
+        flex: 0 0 auto;
+        gap: 4px;
+        padding: 3px;
+        border: 1px solid rgba(191, 164, 109, 0.28);
+        border-radius: 999px;
+        background: linear-gradient(180deg, rgba(247, 241, 230, 0.94), rgba(244, 236, 223, 0.96));
+        box-shadow:
+          inset 0 1px 0 rgba(255, 255, 255, 0.88),
+          0 8px 18px rgba(138, 102, 32, 0.08);
+      }
+
+      .view-toggle-tab {
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        min-height: 38px;
+        padding: 0 18px;
+        border: 1px solid transparent;
+        border-radius: 999px;
+        background: transparent;
+        color: #6f6451;
+        text-decoration: none;
+        font-size: 0.9rem;
+        font-weight: 700;
+        font-family: inherit;
+        white-space: nowrap;
+        cursor: pointer;
+        box-shadow: none;
+        transition: background 160ms ease, color 160ms ease, border-color 160ms ease, box-shadow 160ms ease;
+      }
+
+      @media (hover: hover) {
+        .view-toggle-tab:hover {
+          transform: none;
+          color: var(--ink);
+        }
+      }
+
+      .view-toggle-tab.is-active {
+        border-color: rgba(232, 223, 204, 0.9);
+        background: rgba(255, 252, 247, 0.96);
+        color: var(--ink);
+        box-shadow: 0 8px 20px rgba(101, 73, 18, 0.08);
+      }
+
       .button,
       button,
       .link-button,

package/dist/src/primitive-registry.js

@@ -1403,6 +1403,13 @@ const videoRemoveCaptionsPrimitive = definePrimitive({
             }
             const probedDurationSeconds = Number(probeMetadata.durationSeconds ?? 0);
             const durationSeconds = Number.isFinite(probedDurationSeconds) && probedDurationSeconds > 0 ? probedDurationSeconds : 30;
+            // GhostCut is a per-FINISHED-CLIP tool, never a long-form pass. Clip
+            // hunting handles "no captions" as a scene-selection filter (avoid_text);
+            // after the hunt, apply caption removal to individual finished clips.
+            if (config.GHOSTCUT_MAX_DURATION_SEC > 0 && durationSeconds > config.GHOSTCUT_MAX_DURATION_SEC) {
+                throw new Error(`Caption removal is limited to videos up to ${Math.round(config.GHOSTCUT_MAX_DURATION_SEC / 60)} minutes (this source is ${Math.round(durationSeconds / 60)} min). ` +
+                    `For long-form video, hunt clips first (POST /clips/scan with avoid_text/no-captions guidance selects text-free scenes), then remove captions from the finished clips you keep.`);
+            }
             const cost = estimateGhostcutCostUsd(durationSeconds);
             ctx.logger.progress(0.12, "Submitting caption-removal task", {
                 durationSeconds: Number(durationSeconds.toFixed(3)),

package/dist/src/services/billing.js

@@ -167,6 +167,9 @@ function resolveCostCenterSlug(input) {
             || explicitSlug === "primitive_media_lambda"
             || explicitSlug === "job_runner_lambda"
             || explicitSlug === "step_functions_standard"
+            // Clip hunting (long-form → short-form): AWS compute only — the AI
+            // tagging/embedding spend is BYOK and deliberately NOT wallet-billed.
+            || explicitSlug === "clip_scan_lambda"
             ? explicitSlug
             : null;
     }