frontpage-host 0.1.8 → 0.1.9

package/AGENTS.md

@@ -112,7 +112,7 @@ Sites are Astro 6 + Tailwind v4. More detail: `frontpage help site-building` or
 - Articles: `frontpage articles …` for lifecycle; bodies via sync under `content/` or `articles content get|set`. Section landing is an owned `src/pages/<section>/index.astro`.
 - Migrate a folder into Articles: prefer `frontpage prompt "migrate … into articles"` — do not invent a mass delete+write migration.
 - Extensions: `frontpage extensions`; if LOCKED on plan, do not fake charts/etc.
-- Media in markup: `/__media/uploads/<slug>/…` from `frontpage media` (not raw blob URLs).
+- Media: `frontpage media upload <file>` — images/PDF ≤25 MB, video (MP4/WebM/MOV) ≤50 MB, SVG/text ≤4 MB (sanitizing proxy). Use returned `sitePath` (`/__media/uploads/<slug>/…`) in markup — never raw blob hosts. Optional `?w=` on rasters only.
 - Analytics: bare `frontpage analytics` = dashboard; also `summary|query|funnel|timeseries|compare|sql` for structured reads (SQL is guard + RLS site-scoped).
 
 ## Agent prompt loop
@@ -122,13 +122,14 @@ frontpage prompt "make the hero shorter"
 frontpage prompt "Use this logo in the header" --attach ./logo.png
 frontpage prompt "Match this brand PDF" --attach ./guide.pdf --path /
 frontpage prompt "Reuse uploaded art" --attach /__media/uploads/<slug>/<file>
+frontpage media upload ./clip.mp4
 frontpage runs wait          # wait for the agent run to finish (failed/canceled → exit 2)
 # Review https://<subdomain>.frontpage.host — do not publish unless asked.
 ```
 
-- `--attach` accepts a local file (uploads via the same path as `frontpage media upload`), an existing `/__media/…` site path, or an `https://` Blob URL. Repeatable.
+- `--attach` accepts a local file (same transport as `frontpage media upload`), an existing `/__media/…` site path, or an `https://` Blob URL. Repeatable.
 - `--asset-url <https://…>` adds a legacy image URL. Repeatable.
-- Caps match the media proxy: images / PDF / text-code. CLI video and >4 MB binaries are not supported yet (editor attach / Phase E).
+- Caps: images/PDF ≤25 MB, video ≤50 MB, SVG/text via proxy ≤4 MB (large text/data Blob upload is editor-only).
 - Prompt text is still required (API). Attachments ride on the same enqueue as the editor.
 - `runs wait` with `--json`: failures use `ok: false` and include `data.run` (with `run.error` when present).
 - `deploy wait` is fail-closed: exit 2 if the waited run (or latest, when already idle) is `failed`/`canceled`.

package/dist/commands/media.js

@@ -1,13 +1,18 @@
-import { readFile } from "node:fs/promises";
-import { basename } from "node:path";
 import { resolveSlug } from "../site.js";
-import { EXIT_OK, EXIT_USAGE, exitCodeForError, v1Get, v1PostMultipart } from "../http/client.js";
+import { EXIT_OK, EXIT_USAGE, exitCodeForError } from "../http/client.js";
+import { emitErr, emitOk, isJson } from "../runtime.js";
+import { uploadLocalMedia } from "../media/upload.js";
+import { v1Get } from "../http/client.js";
 export async function runMedia(args) {
     try {
         const { slug, rest } = await resolveSlug(args);
         const sub = rest[0] ?? "list";
         if (sub === "list" || sub === "ls") {
             const data = await v1Get(`/api/v1/sites/${encodeURIComponent(slug)}/media`);
+            if (isJson()) {
+                emitOk("media", { slug, ...data });
+                return EXIT_OK;
+            }
             for (const a of data.assets) {
                 console.log(`${a.sitePath.padEnd(48)}  ${String(a.sizeBytes).padStart(8)}  ${a.name}`);
             }
@@ -17,27 +22,32 @@ export async function runMedia(args) {
         if (sub === "upload") {
             const filePath = rest[1];
             if (!filePath) {
-                console.error("Usage: frontpage media upload <file> [--site <slug>]");
+                console.error("Usage: frontpage media upload <file> [--site <slug>] [--json]");
                 return EXIT_USAGE;
             }
-            const bytes = await readFile(filePath);
-            const form = new FormData();
-            form.append("file", new Blob([Uint8Array.from(bytes)]), basename(filePath));
-            const data = await v1PostMultipart(`/api/v1/sites/${encodeURIComponent(slug)}/media`, form);
+            const data = await uploadLocalMedia({ slug, filePath });
+            if (isJson()) {
+                emitOk("media", { slug, ...data });
+                return EXIT_OK;
+            }
             if (data.kind === "text") {
                 console.log(`Inline text (${data.filename}): ${data.sizeBytes ?? 0} bytes — not stored.`);
+                return EXIT_OK;
             }
-            else {
-                console.log(data.url ?? data.key ?? JSON.stringify(data));
-                if (data.key)
-                    console.log(`sitePath: /__media/${data.key}`);
-            }
+            if (data.url)
+                console.log(data.url);
+            if (data.sitePath)
+                console.log(`sitePath: ${data.sitePath}`);
+            else if (data.key)
+                console.log(`sitePath: /__media/${data.key}`);
             return EXIT_OK;
         }
-        console.error("Usage: frontpage media list|upload <file> [--site <slug>]");
+        console.error("Usage: frontpage media list|upload <file> [--site <slug>] [--json]");
         return EXIT_USAGE;
     }
     catch (err) {
+        if (isJson())
+            return emitErr("media", err);
         console.error(err instanceof Error ? err.message : String(err));
         return exitCodeForError(err);
     }

package/dist/commands/prompt-attach.d.ts

@@ -1,8 +1,10 @@
-/** Mirror ATTACH_LIMITS in src/lib/agent/attachments.ts (images/docs/text only via proxy media). */
+import { type UploadedMedia } from "../media/upload.js";
+/** Mirror ATTACH_LIMITS in src/lib/agent/attachments.ts. */
 export declare const CLI_ATTACH_LIMITS: {
     readonly maxImages: 6;
     readonly maxDocuments: 4;
     readonly maxTextFiles: 6;
+    readonly maxVideos: 3;
 };
 export type PromptAttachmentsPayload = {
     images: Array<{
@@ -17,19 +19,19 @@ export type PromptAttachmentsPayload = {
         name: string;
         content: string;
     }>;
+    videos: Array<{
+        url: string;
+        name?: string;
+        sizeBytes?: number;
+    }>;
 };
-export type MediaUploadResult = {
-    kind: string;
-    url?: string;
-    key?: string;
-    filename?: string;
-    sizeBytes?: number;
-    content?: string;
-};
+export type MediaUploadResult = UploadedMedia;
 export declare function emptyAttachments(): PromptAttachmentsPayload;
 export declare function isHttpsUrl(s: string): boolean;
 export declare function isMediaSitePath(s: string): boolean;
-export declare function classifyRemoteByName(nameOrUrl: string): "image" | "document";
+export declare function classifyRemoteByName(nameOrUrl: string): "image" | "document" | "video";
+/** Agent normalizeAttachments only keeps videos on our Blob host under uploads/. */
+export declare function isFrontpageBlobUploadUrl(url: string): boolean;
 export declare function addHttpsRef(out: PromptAttachmentsPayload, url: string, opts?: {
     name?: string;
     asImageOnly?: boolean;

package/dist/commands/prompt-attach.js

@@ -1,19 +1,21 @@
 /**
- * §CLI Phase C — resolve --attach / --asset-url into the agent attachments payload.
- * Local files upload via the same multipart media endpoint as `frontpage media upload`.
+ * §CLI Phase C (+ E) — resolve --attach / --asset-url into the agent attachments payload.
+ * Local files use the same transport matrix as `frontpage media upload`.
  */
-import { access, readFile } from "node:fs/promises";
-import { basename } from "node:path";
+import { access } from "node:fs/promises";
 import { constants as fsConstants } from "node:fs";
-import { v1Get, v1PostMultipart, CliHttpError, EXIT_USAGE, EXIT_UNEXPECTED } from "../http/client.js";
-/** Mirror ATTACH_LIMITS in src/lib/agent/attachments.ts (images/docs/text only via proxy media). */
+import { v1Get, CliHttpError, EXIT_USAGE, EXIT_UNEXPECTED } from "../http/client.js";
+import { uploadLocalMedia } from "../media/upload.js";
+import { VIDEO_UPLOAD_EXT, extOf } from "../media/limits.js";
+/** Mirror ATTACH_LIMITS in src/lib/agent/attachments.ts. */
 export const CLI_ATTACH_LIMITS = {
     maxImages: 6,
     maxDocuments: 4,
     maxTextFiles: 6,
+    maxVideos: 3,
 };
 export function emptyAttachments() {
-    return { images: [], documents: [], textFiles: [] };
+    return { images: [], documents: [], textFiles: [], videos: [] };
 }
 export function isHttpsUrl(s) {
     return /^https:\/\/[^\s]+$/i.test(s) && s.length <= 2048;
@@ -23,7 +25,9 @@ export function isMediaSitePath(s) {
 }
 export function classifyRemoteByName(nameOrUrl) {
     const base = nameOrUrl.split(/[?#]/)[0] ?? nameOrUrl;
-    const ext = base.includes(".") ? (base.split(".").pop() ?? "").toLowerCase() : "";
+    const ext = extOf(base);
+    if (VIDEO_UPLOAD_EXT.has(ext))
+        return "video";
     if (ext === "pdf")
         return "document";
     return "image";
@@ -42,6 +46,19 @@ function pushText(list, name, content) {
     }
     list.push({ name, content });
 }
+/** Agent normalizeAttachments only keeps videos on our Blob host under uploads/. */
+export function isFrontpageBlobUploadUrl(url) {
+    try {
+        const u = new URL(url);
+        if (!u.hostname.endsWith(".blob.vercel-storage.com"))
+            return false;
+        const pathname = u.pathname.replace(/^\/+/, "");
+        return pathname.startsWith("uploads/");
+    }
+    catch {
+        return false;
+    }
+}
 export function addHttpsRef(out, url, opts) {
     if (!isHttpsUrl(url)) {
         throw new CliHttpError(`Not an https URL: ${url}`, EXIT_USAGE, 400, "bad_request");
@@ -49,10 +66,16 @@ export function addHttpsRef(out, url, opts) {
     const kind = opts?.asImageOnly ? "image" : classifyRemoteByName(opts?.name ?? url);
     if (kind === "document") {
         pushUniqueUrl(out.documents, CLI_ATTACH_LIMITS.maxDocuments, url, opts?.name, "document");
+        return;
     }
-    else {
-        pushUniqueUrl(out.images, CLI_ATTACH_LIMITS.maxImages, url, opts?.name, "image");
+    if (kind === "video") {
+        if (!isFrontpageBlobUploadUrl(url)) {
+            throw new CliHttpError("Video --attach URLs must be Frontpage Blob uploads (…blob.vercel-storage.com/uploads/…). Upload with frontpage media upload first, or pass a local .mp4/.webm/.mov file.", EXIT_USAGE, 400, "bad_request");
+        }
+        pushUniqueUrl(out.videos, CLI_ATTACH_LIMITS.maxVideos, url, opts?.name, "video");
+        return;
     }
+    pushUniqueUrl(out.images, CLI_ATTACH_LIMITS.maxImages, url, opts?.name, "image");
 }
 export function addUploadResult(out, data) {
     const name = data.filename?.trim() || undefined;
@@ -63,19 +86,31 @@ export function addUploadResult(out, data) {
         pushText(out.textFiles, name ?? "snippet.txt", data.content);
         return;
     }
-    if (data.kind === "image" || data.kind === "document") {
+    if (data.kind === "image" || data.kind === "document" || data.kind === "video") {
         if (!data.url || !isHttpsUrl(data.url)) {
             throw new CliHttpError(`Upload of ${name ?? "file"} did not return a Blob URL.`, EXIT_UNEXPECTED, 500, "internal");
         }
         if (data.kind === "document") {
             pushUniqueUrl(out.documents, CLI_ATTACH_LIMITS.maxDocuments, data.url, name, "document");
+            return;
         }
-        else {
-            pushUniqueUrl(out.images, CLI_ATTACH_LIMITS.maxImages, data.url, name, "image");
+        if (data.kind === "video") {
+            if (out.videos.length >= CLI_ATTACH_LIMITS.maxVideos) {
+                throw new CliHttpError(`Too many video attachments (max ${CLI_ATTACH_LIMITS.maxVideos}).`, EXIT_USAGE, 400, "bad_request");
+            }
+            if (!out.videos.some((x) => x.url === data.url)) {
+                out.videos.push({
+                    url: data.url,
+                    name,
+                    sizeBytes: data.sizeBytes,
+                });
+            }
+            return;
         }
+        pushUniqueUrl(out.images, CLI_ATTACH_LIMITS.maxImages, data.url, name, "image");
         return;
     }
-    throw new CliHttpError(`Unsupported upload kind "${data.kind}" for prompt attach. Use images, PDFs, or text/code files (video/large files need the editor path until Phase E).`, EXIT_USAGE, 400, "bad_request");
+    throw new CliHttpError(`Unsupported upload kind "${data.kind}" for prompt attach. Use images, PDFs, videos, or text/code files.`, EXIT_USAGE, 400, "bad_request");
 }
 export async function uploadLocalForAttach(slug, filePath) {
     try {
@@ -84,13 +119,7 @@ export async function uploadLocalForAttach(slug, filePath) {
     catch {
         throw new CliHttpError(`Cannot read file for --attach: ${filePath}`, EXIT_USAGE, 400, "bad_request");
     }
-    const bytes = await readFile(filePath);
-    if (bytes.length === 0) {
-        throw new CliHttpError(`File is empty: ${filePath}`, EXIT_USAGE, 400, "bad_request");
-    }
-    const form = new FormData();
-    form.append("file", new Blob([Uint8Array.from(bytes)]), basename(filePath));
-    return v1PostMultipart(`/api/v1/sites/${encodeURIComponent(slug)}/media`, form);
+    return uploadLocalMedia({ slug, filePath });
 }
 export async function resolveSitePathUrl(slug, sitePath) {
     const data = await v1Get(`/api/v1/sites/${encodeURIComponent(slug)}/media`);
@@ -123,6 +152,9 @@ export async function resolveAttachRef(slug, ref, out) {
         if (kind === "document") {
             pushUniqueUrl(out.documents, CLI_ATTACH_LIMITS.maxDocuments, asset.url, asset.name, "document");
         }
+        else if (kind === "video") {
+            pushUniqueUrl(out.videos, CLI_ATTACH_LIMITS.maxVideos, asset.url, asset.name, "video");
+        }
         else {
             pushUniqueUrl(out.images, CLI_ATTACH_LIMITS.maxImages, asset.url, asset.name, "image");
         }
@@ -143,7 +175,8 @@ export async function buildPromptAttachments(args) {
     }
     if (out.images.length === 0 &&
         out.documents.length === 0 &&
-        out.textFiles.length === 0) {
+        out.textFiles.length === 0 &&
+        out.videos.length === 0) {
         throw new CliHttpError("No attachments could be resolved from --attach / --asset-url.", EXIT_USAGE, 400, "bad_request");
     }
     return out;

package/dist/commands/prompt.js

@@ -29,6 +29,7 @@ export async function runPrompt(args) {
                         images: attachments.images.length,
                         documents: attachments.documents.length,
                         textFiles: attachments.textFiles.length,
+                        videos: attachments.videos.length,
                     }
                     : undefined,
             });
@@ -40,7 +41,8 @@ export async function runPrompt(args) {
             if (attachments) {
                 const n = attachments.images.length +
                     attachments.documents.length +
-                    attachments.textFiles.length;
+                    attachments.textFiles.length +
+                    attachments.videos.length;
                 console.error(`(attached ${n} file${n === 1 ? "" : "s"})`);
             }
         }

package/dist/http/client.d.ts

@@ -21,6 +21,8 @@ export declare class CliHttpError extends Error {
 /** Map a non-OK v1 response into CliHttpError (shared by JSON + multipart clients). */
 export declare function httpErrorFromV1(status: number, parsed: V1Envelope, fallbackMessage?: string): CliHttpError;
 export declare function apiBase(): string;
+/** Bearer header for raw fetch (e.g. Blob client-token exchange). */
+export declare function getBearerAuthHeader(): Promise<Record<string, string>>;
 export declare function v1Get<T>(path: string): Promise<T>;
 export declare function v1Post<T>(path: string, body?: unknown): Promise<T>;
 export declare function v1Put<T>(path: string, body?: unknown): Promise<T>;

package/dist/http/client.js

@@ -61,6 +61,14 @@ export function apiBase() {
         return fromEnv;
     return "https://app.frontpage.host";
 }
+/** Bearer header for raw fetch (e.g. Blob client-token exchange). */
+export async function getBearerAuthHeader() {
+    const key = await getApiKey();
+    if (!key) {
+        throw new CliHttpError("Not logged in. Run: frontpage login", EXIT_AUTH, 401);
+    }
+    return { Authorization: `Bearer ${key}` };
+}
 async function v1Request(method, path, body) {
     const key = await getApiKey();
     if (!key) {

package/dist/media/limits.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Mirror of app `src/lib/upload/limits.ts` + video ext set (CLI cannot import app code).
+ * Keep values in lockstep with the platform.
+ */
+export declare const MAX_UPLOAD_BYTES: number;
+export declare const MAX_VIDEO_UPLOAD_BYTES: number;
+export declare const MAX_PROXY_UPLOAD_BYTES: number;
+export declare const MAX_INLINE_TEXT_BYTES: number;
+export declare const VIDEO_UPLOAD_EXT: Set<string>;
+export declare const RASTER_EXT: Set<string>;
+export declare const PDF_EXT: Set<string>;
+export declare const SVG_EXT: Set<string>;
+/** Common text/code extensions (proxy/inline only via CLI — no FU.9 client path). */
+export declare const TEXT_EXT: Set<string>;
+export declare function formatBytes(n: number): string;
+export declare function extOf(filename: string): string;
+export declare function contentTypeForExt(ext: string): string | undefined;
+export declare function sitePathFromKey(key: string): string;

package/dist/media/limits.js

@@ -0,0 +1,101 @@
+/**
+ * Mirror of app `src/lib/upload/limits.ts` + video ext set (CLI cannot import app code).
+ * Keep values in lockstep with the platform.
+ */
+export const MAX_UPLOAD_BYTES = 25 * 1024 * 1024;
+export const MAX_VIDEO_UPLOAD_BYTES = 50 * 1024 * 1024;
+export const MAX_PROXY_UPLOAD_BYTES = 4 * 1024 * 1024;
+export const MAX_INLINE_TEXT_BYTES = 256 * 1024;
+export const VIDEO_UPLOAD_EXT = new Set(["mp4", "webm", "mov", "m4v"]);
+export const RASTER_EXT = new Set(["png", "jpg", "jpeg", "gif", "webp", "avif"]);
+export const PDF_EXT = new Set(["pdf"]);
+export const SVG_EXT = new Set(["svg"]);
+/** Common text/code extensions (proxy/inline only via CLI — no FU.9 client path). */
+export const TEXT_EXT = new Set([
+    "txt",
+    "md",
+    "markdown",
+    "csv",
+    "tsv",
+    "json",
+    "json5",
+    "jsonc",
+    "html",
+    "htm",
+    "css",
+    "scss",
+    "sass",
+    "less",
+    "js",
+    "mjs",
+    "cjs",
+    "jsx",
+    "ts",
+    "tsx",
+    "py",
+    "rb",
+    "php",
+    "go",
+    "rs",
+    "java",
+    "kt",
+    "swift",
+    "c",
+    "h",
+    "cpp",
+    "cc",
+    "yaml",
+    "yml",
+    "toml",
+    "ini",
+    "env",
+    "xml",
+    "sql",
+    "sh",
+    "graphql",
+    "gql",
+]);
+export function formatBytes(n) {
+    if (!Number.isFinite(n) || n < 0)
+        return "0 bytes";
+    if (n < 1024)
+        return `${Math.round(n)} bytes`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(0)} KB`;
+    return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+}
+export function extOf(filename) {
+    const base = (filename || "").split(/[/\\]/).pop() ?? "";
+    return base.includes(".") ? (base.split(".").pop() ?? "").toLowerCase() : "";
+}
+export function contentTypeForExt(ext) {
+    switch (ext) {
+        case "png":
+            return "image/png";
+        case "jpg":
+        case "jpeg":
+            return "image/jpeg";
+        case "gif":
+            return "image/gif";
+        case "webp":
+            return "image/webp";
+        case "avif":
+            return "image/avif";
+        case "pdf":
+            return "application/pdf";
+        case "mp4":
+            return "video/mp4";
+        case "webm":
+            return "video/webm";
+        case "mov":
+            return "video/quicktime";
+        case "m4v":
+            return "video/x-m4v";
+        default:
+            return undefined;
+    }
+}
+export function sitePathFromKey(key) {
+    const k = key.replace(/^\//, "");
+    return k.startsWith("__media/") ? `/${k}` : `/__media/${k}`;
+}

package/dist/media/select-transport.d.ts

@@ -0,0 +1,27 @@
+export type MediaKind = "image" | "document" | "video" | "text";
+export type TransportDecision = {
+    transport: "proxy";
+    kind: MediaKind;
+} | {
+    transport: "client";
+    kind: Exclude<MediaKind, "text">;
+    ext: string;
+    contentType: string;
+} | {
+    transport: "reject";
+    message: string;
+};
+/**
+ * Minimal video sniff for files without a recognized extension.
+ * Mirrors server `sniffType` enough to avoid classifying AVIF/HEIC as video.
+ */
+export declare function sniffVideoExt(head: Uint8Array): "mp4" | "webm" | null;
+/**
+ * Decide proxy vs direct-to-Blob vs reject for a local file.
+ * `headBytes` (optional) enables video detection when the extension is missing/wrong.
+ */
+export declare function selectMediaTransport(input: {
+    filename: string;
+    sizeBytes: number;
+    headBytes?: Uint8Array;
+}): TransportDecision;

package/dist/media/select-transport.js

@@ -0,0 +1,134 @@
+/**
+ * Phase E — pure transport matrix for `frontpage media upload`.
+ */
+import { extOf, formatBytes, MAX_PROXY_UPLOAD_BYTES, MAX_UPLOAD_BYTES, MAX_VIDEO_UPLOAD_BYTES, PDF_EXT, RASTER_EXT, SVG_EXT, TEXT_EXT, VIDEO_UPLOAD_EXT, } from "./limits.js";
+function asciiAt(bytes, offset, s) {
+    if (bytes.length < offset + s.length)
+        return false;
+    for (let i = 0; i < s.length; i++)
+        if (bytes[offset + i] !== s.charCodeAt(i))
+            return false;
+    return true;
+}
+/** Brands that share ISOBMFF/`ftyp` but are NOT video (must not route to client-as-mp4). */
+const NON_VIDEO_FTYP_BRANDS = new Set(["avif", "avis", "heic", "heif", "mif1", "msf1"]);
+function ftypBrand(head) {
+    if (!asciiAt(head, 4, "ftyp") || head.length < 12)
+        return null;
+    return String.fromCharCode(head[8], head[9], head[10], head[11]).toLowerCase();
+}
+/**
+ * Minimal video sniff for files without a recognized extension.
+ * Mirrors server `sniffType` enough to avoid classifying AVIF/HEIC as video.
+ */
+export function sniffVideoExt(head) {
+    const brand = ftypBrand(head);
+    if (brand && NON_VIDEO_FTYP_BRANDS.has(brand))
+        return null;
+    if (asciiAt(head, 4, "ftyp") ||
+        asciiAt(head, 4, "moov") ||
+        asciiAt(head, 4, "mdat") ||
+        asciiAt(head, 4, "wide") ||
+        asciiAt(head, 4, "free") ||
+        asciiAt(head, 4, "skip")) {
+        return "mp4";
+    }
+    if (head.length >= 4 && head[0] === 0x1a && head[1] === 0x45 && head[2] === 0xdf && head[3] === 0xa3) {
+        return "webm";
+    }
+    return null;
+}
+function clientDecision(kind, ext, contentType) {
+    return { transport: "client", kind, ext, contentType };
+}
+/**
+ * Decide proxy vs direct-to-Blob vs reject for a local file.
+ * `headBytes` (optional) enables video detection when the extension is missing/wrong.
+ */
+export function selectMediaTransport(input) {
+    const { filename, sizeBytes } = input;
+    if (!Number.isFinite(sizeBytes) || sizeBytes <= 0) {
+        return { transport: "reject", message: "That file is empty — nothing to upload." };
+    }
+    let ext = extOf(filename);
+    const hasKnownNonVideoExt = RASTER_EXT.has(ext) || PDF_EXT.has(ext) || SVG_EXT.has(ext) || TEXT_EXT.has(ext);
+    // Only sniff for video when the extension isn't already a known non-video kind
+    // (AVIF is ISOBMFF/`ftyp` — sniffing before the raster branch would mis-route it).
+    const sniffedVideo = !hasKnownNonVideoExt && input.headBytes ? sniffVideoExt(input.headBytes) : null;
+    const isVideo = VIDEO_UPLOAD_EXT.has(ext) || sniffedVideo !== null;
+    if (isVideo && !VIDEO_UPLOAD_EXT.has(ext) && sniffedVideo) {
+        ext = sniffedVideo;
+    }
+    if (isVideo) {
+        if (sizeBytes > MAX_VIDEO_UPLOAD_BYTES) {
+            return {
+                transport: "reject",
+                message: `This video is ${formatBytes(sizeBytes)}, over the ${MAX_VIDEO_UPLOAD_BYTES / (1024 * 1024)} MB video limit. Please compress it (a web-ready MP4 around 1080p) and try again.`,
+            };
+        }
+        const useExt = VIDEO_UPLOAD_EXT.has(ext) ? ext : sniffedVideo ?? "mp4";
+        const contentType = useExt === "webm"
+            ? "video/webm"
+            : useExt === "mov"
+                ? "video/quicktime"
+                : useExt === "m4v"
+                    ? "video/x-m4v"
+                    : "video/mp4";
+        return clientDecision("video", useExt, contentType);
+    }
+    if (SVG_EXT.has(ext)) {
+        if (sizeBytes > MAX_PROXY_UPLOAD_BYTES) {
+            return {
+                transport: "reject",
+                message: `This SVG is ${formatBytes(sizeBytes)} — SVGs must be under ${MAX_PROXY_UPLOAD_BYTES / (1024 * 1024)} MB.`,
+            };
+        }
+        return { transport: "proxy", kind: "image" };
+    }
+    if (RASTER_EXT.has(ext)) {
+        if (sizeBytes > MAX_UPLOAD_BYTES) {
+            return {
+                transport: "reject",
+                message: `This image is ${formatBytes(sizeBytes)}, over the ${MAX_UPLOAD_BYTES / (1024 * 1024)} MB upload limit. Please use a smaller or lower-resolution image.`,
+            };
+        }
+        if (sizeBytes > MAX_PROXY_UPLOAD_BYTES) {
+            const contentType = ext === "jpg" || ext === "jpeg"
+                ? "image/jpeg"
+                : ext === "png"
+                    ? "image/png"
+                    : ext === "gif"
+                        ? "image/gif"
+                        : ext === "webp"
+                            ? "image/webp"
+                            : "image/avif";
+            return clientDecision("image", ext === "jpeg" ? "jpg" : ext, contentType);
+        }
+        return { transport: "proxy", kind: "image" };
+    }
+    if (PDF_EXT.has(ext)) {
+        if (sizeBytes > MAX_UPLOAD_BYTES) {
+            return {
+                transport: "reject",
+                message: `This PDF is ${formatBytes(sizeBytes)}, over the ${MAX_UPLOAD_BYTES / (1024 * 1024)} MB upload limit. Please attach a smaller file.`,
+            };
+        }
+        if (sizeBytes > MAX_PROXY_UPLOAD_BYTES) {
+            return clientDecision("document", "pdf", "application/pdf");
+        }
+        return { transport: "proxy", kind: "document" };
+    }
+    if (TEXT_EXT.has(ext)) {
+        if (sizeBytes > MAX_PROXY_UPLOAD_BYTES) {
+            return {
+                transport: "reject",
+                message: `This text/data file is ${formatBytes(sizeBytes)}. Large text/data Blob uploads aren't supported via the CLI yet — keep files under ${MAX_PROXY_UPLOAD_BYTES / (1024 * 1024)} MB or use the editor.`,
+            };
+        }
+        return { transport: "proxy", kind: "text" };
+    }
+    return {
+        transport: "reject",
+        message: "That file type isn't supported. Use an image (PNG, JPG, GIF, WebP, AVIF, SVG), a PDF, a video (MP4, WebM, MOV), or a text/code file.",
+    };
+}

package/dist/media/upload.d.ts

@@ -0,0 +1,16 @@
+export type UploadedMedia = {
+    kind: string;
+    url?: string;
+    key?: string;
+    sitePath?: string;
+    filename?: string;
+    sizeBytes?: number;
+    contentType?: string;
+    content?: string;
+    transport?: "proxy" | "client";
+};
+/** Upload a local file using the Phase E transport matrix. */
+export declare function uploadLocalMedia(args: {
+    slug: string;
+    filePath: string;
+}): Promise<UploadedMedia>;

package/dist/media/upload.js

@@ -0,0 +1,140 @@
+/**
+ * Shared local-file upload used by `frontpage media upload` and `prompt --attach`.
+ */
+import { randomUUID } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+import { put } from "@vercel/blob/client";
+import { apiBase, CliHttpError, EXIT_AUTH, EXIT_UNEXPECTED, EXIT_USAGE, getBearerAuthHeader, httpErrorFromV1, v1PostMultipart, } from "../http/client.js";
+import { contentTypeForExt, sitePathFromKey } from "./limits.js";
+import { selectMediaTransport } from "./select-transport.js";
+async function requestClientToken(args) {
+    const auth = await getBearerAuthHeader();
+    const url = `${apiBase()}/api/v1/sites/${encodeURIComponent(args.slug)}/media/client`;
+    let res;
+    try {
+        res = await fetch(url, {
+            method: "POST",
+            headers: {
+                ...auth,
+                Accept: "application/json",
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                type: "blob.generate-client-token",
+                payload: {
+                    pathname: args.pathname,
+                    clientPayload: JSON.stringify({ declaredSize: args.declaredSize }),
+                    multipart: args.multipart,
+                },
+            }),
+        });
+    }
+    catch (err) {
+        throw new CliHttpError(`Network error: ${err instanceof Error ? err.message : String(err)}`, EXIT_UNEXPECTED, 0);
+    }
+    const text = await res.text();
+    let parsed = {};
+    try {
+        parsed = text ? JSON.parse(text) : {};
+    }
+    catch {
+        parsed = {};
+    }
+    if (!res.ok) {
+        const msg = typeof parsed.error === "string"
+            ? parsed.error
+            : typeof parsed.error === "object" && parsed.error?.message
+                ? parsed.error.message
+                : `Upload authorization failed (${res.status})`;
+        // Auth / rate-limit use v1 envelopes; policy denials use { error: string }.
+        if (typeof parsed.error === "object" && parsed.error) {
+            throw httpErrorFromV1(res.status, parsed, msg);
+        }
+        if (res.status === 401 || res.status === 403) {
+            throw new CliHttpError(msg, EXIT_AUTH, res.status);
+        }
+        if (res.status === 402 || res.status === 413 || res.status === 429 || res.status === 400) {
+            throw new CliHttpError(msg, EXIT_USAGE, res.status);
+        }
+        throw new CliHttpError(msg, EXIT_UNEXPECTED, res.status);
+    }
+    if (typeof parsed.clientToken !== "string" || !parsed.clientToken) {
+        throw new CliHttpError("Upload authorization failed (no client token).", EXIT_UNEXPECTED, res.status);
+    }
+    return parsed.clientToken;
+}
+async function uploadViaClient(args) {
+    const pathname = `uploads/${args.slug}/${randomUUID()}.${args.ext}`;
+    const multipart = args.bytes.length > 8 * 1024 * 1024;
+    const clientToken = await requestClientToken({
+        slug: args.slug,
+        pathname,
+        declaredSize: args.bytes.length,
+        multipart,
+    });
+    try {
+        const blob = await put(pathname, args.bytes, {
+            access: "public",
+            token: clientToken,
+            contentType: args.contentType,
+            multipart,
+        });
+        const key = blob.pathname.replace(/^\//, "");
+        return {
+            kind: args.kind,
+            url: blob.url,
+            key,
+            sitePath: sitePathFromKey(key),
+            filename: args.filename,
+            sizeBytes: args.bytes.length,
+            contentType: args.contentType || contentTypeForExt(args.ext),
+            transport: "client",
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new CliHttpError(`Upload failed: ${msg}`, EXIT_UNEXPECTED, 500);
+    }
+}
+async function uploadViaProxy(args) {
+    const form = new FormData();
+    form.append("file", new Blob([Uint8Array.from(args.bytes)]), args.filename);
+    const data = await v1PostMultipart(`/api/v1/sites/${encodeURIComponent(args.slug)}/media`, form);
+    const key = data.key?.replace(/^\//, "");
+    return {
+        kind: data.kind,
+        url: data.url,
+        key,
+        sitePath: data.sitePath ?? (key ? sitePathFromKey(key) : undefined),
+        filename: data.filename ?? args.filename,
+        sizeBytes: data.sizeBytes ?? args.bytes.length,
+        contentType: data.contentType,
+        content: data.content,
+        transport: "proxy",
+    };
+}
+/** Upload a local file using the Phase E transport matrix. */
+export async function uploadLocalMedia(args) {
+    const bytes = await readFile(args.filePath);
+    const filename = basename(args.filePath);
+    const decision = selectMediaTransport({
+        filename,
+        sizeBytes: bytes.length,
+        headBytes: bytes.subarray(0, 4096),
+    });
+    if (decision.transport === "reject") {
+        throw new CliHttpError(decision.message, EXIT_USAGE, 400, "bad_request");
+    }
+    if (decision.transport === "client") {
+        return uploadViaClient({
+            slug: args.slug,
+            bytes,
+            filename,
+            ext: decision.ext,
+            contentType: decision.contentType,
+            kind: decision.kind,
+        });
+    }
+    return uploadViaProxy({ slug: args.slug, bytes, filename });
+}

package/dist/registry.js

@@ -204,7 +204,7 @@ export const COMMANDS = [
             "--path must start with /",
             "--attach: local file (uploads via media), /__media/… site path, or https Blob URL; repeatable",
             "--asset-url: https image URL (legacy); repeatable",
-            "Local attach uses the same caps as frontpage media upload (images/PDF/text; no CLI video yet)",
+            "Local attach uses frontpage media upload (images/PDF ≤25 MB, video ≤50 MB, SVG/text ≤4 MB proxy)",
             "stdout is bare runId (or JSON with --json)",
         ],
         seeAlso: ["runs", "deploy", "media"],
@@ -316,9 +316,20 @@ export const COMMANDS = [
     },
     {
         name: "media",
-        summary: "List or upload site media assets",
-        usage: "frontpage media list|upload <file> [--site <slug>]",
+        summary: "List or upload site media (images/PDF ≤25 MB, video ≤50 MB)",
+        usage: "frontpage media list|upload <file> [--site <slug>] [--json]",
         topics: ["content"],
+        examples: [
+            "frontpage media list",
+            "frontpage media upload ./hero.webp",
+            "frontpage media upload ./clip.mp4",
+        ],
+        flags: [
+            "Auto-selects proxy (≤4 MB) vs direct-to-Blob for large rasters/PDFs and all video",
+            "Prints sitePath (/__media/uploads/<slug>/…) for markup — never raw blob hosts in pages",
+            "SVG stays on the sanitizing proxy path (≤4 MB)",
+        ],
+        seeAlso: ["prompt", "help content", "help site-building"],
     },
     {
         name: "inbox",
@@ -485,7 +496,7 @@ export const TOPICS = {
   Modules & articles (short):
   - Forms: <form data-fp-form="slug"> with named inputs; no action/onsubmit/honeypot.
   - Articles: frontpage articles …; migrate folders via frontpage prompt (don't invent mass delete+write).
-  - Media in markup: /__media/uploads/<slug>/… from frontpage media (not raw blob URLs).
+  - Media: frontpage media upload (images/PDF ≤25 MB, video ≤50 MB). Use sitePath /__media/uploads/<slug>/… in markup (not raw blob URLs). Optional ?w= on rasters only.
 
   Full guide: https://frontpage.host/developers/site-building
   See also: frontpage help sync | content | AGENTS.md`,
@@ -508,13 +519,13 @@ export const TOPICS = {
   frontpage modules request-setup <key> --reason "…"
   frontpage extensions
 
-  --attach uploads local files via media (images/PDF/text) or accepts /__media/… / https URLs.
+  --attach uploads via media (images/PDF/video/text) or accepts /__media/… / https URLs.
   API errors include requestId in --json error envelopes (and stderr when not --json).
   Mid-task continuation is automatic — there is no runs continue.
   Do not file-sync while an agent run is active (see help sync for push --wait).
   Default after work: review https://<subdomain>.frontpage.host; do not publish.`,
     content: `Content
-  frontpage media list|upload <file>
+  frontpage media list|upload <file>   # images/PDF ≤25 MB, video ≤50 MB; sitePath for markup
   frontpage inbox [leads|subscribers|orders|…] [--mark-read] [--csv]
   frontpage seo get|set --path /
   frontpage articles list|content|create-section|create-article|set-draft|…

package/llms.txt

@@ -10,7 +10,8 @@
 - Search flags: --regex --case-sensitive --whole-word --files-only --context-lines --max-results
 - Modules setup: frontpage modules request-setup <key> --reason "…" (owner status bar; CLI cannot show it)
 - Analytics ops: frontpage analytics summary|query|funnel|timeseries|compare|sql (bare analytics = dashboard)
-- Prompt attachments: frontpage prompt "…" --attach <file|/__media/…|https://…> [--asset-url https://…] (media upload for locals; images/PDF/text)
+- Media: frontpage media upload <file> (images/PDF ≤25 MB, video ≤50 MB, SVG/text ≤4 MB); use sitePath /__media/uploads/<slug>/… in markup
+- Prompt attachments: frontpage prompt "…" --attach <file|/__media/…|https://…> [--asset-url https://…] (same media caps as media upload)
 - Errors: --json error envelopes include requestId; runs wait failed/canceled → ok:false + run.error (exit 2); deploy wait fail-closed; push --wait
 - Auth: mint fp_live_ key in Frontpage UI (Developers); frontpage login KEY or FRONTPAGE_API_KEY
 - Site id: subdomain only (frontpage use <subdomain>). Not custom domains.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "frontpage-host",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Frontpage CLI — manage your site from the terminal",
   "type": "module",
   "bin": {
@@ -34,6 +34,9 @@
     "cli",
     "landing-page"
   ],
+  "dependencies": {
+    "@vercel/blob": "^2.4.0"
+  },
   "devDependencies": {
     "@types/node": "^22.13.10",
     "tsx": "^4.19.3",