frontpage-host 0.1.7 → 0.1.9

package/dist/commands/wait-agent-idle.js

@@ -0,0 +1,181 @@
+/**
+ * §CLI Phase D — shared wait for agent-run busy states (queued/running/deploying).
+ * Used by `deploy wait` and `push --wait`. Not a Vercel deploy oracle.
+ */
+import { EXIT_OK, EXIT_USAGE, v1Get } from "../http/client.js";
+import { emitFail, emitOk, isJson, progress } from "../runtime.js";
+const BUSY = new Set(["queued", "running", "deploying"]);
+const FAIL_TERMINAL = new Set(["failed", "canceled"]);
+export function isBusyStatus(status) {
+    return BUSY.has(status);
+}
+export function isFailTerminal(status) {
+    return FAIL_TERMINAL.has(status);
+}
+/**
+ * Decide exit after idle. Pure — unit-tested.
+ * - If we watched a busy run end: succeeded → 0; failed/canceled → 2.
+ * - If never busy: optional fail-closed on latest terminal failure (deploy wait);
+ *   otherwise idle/succeeded → 0 (push --wait after a file-only push).
+ */
+export function decideIdleExit(args) {
+    if (args.observedBusy && args.watched) {
+        const status = args.watched.status;
+        // Stale snapshot still busy → not success (caller should keep polling).
+        if (isBusyStatus(status)) {
+            return { exitCode: EXIT_USAGE, run: args.watched, status: "still_busy" };
+        }
+        if (isFailTerminal(status)) {
+            return { exitCode: EXIT_USAGE, run: args.watched, status };
+        }
+        return { exitCode: EXIT_OK, run: args.watched, status: status || "succeeded" };
+    }
+    const latest = args.latest;
+    if (args.failClosedOnIdleTerminalFailure &&
+        latest &&
+        isFailTerminal(latest.status)) {
+        return { exitCode: EXIT_USAGE, run: latest, status: latest.status };
+    }
+    return {
+        exitCode: EXIT_OK,
+        run: latest,
+        status: latest?.status ?? "idle",
+    };
+}
+export async function waitForAgentIdle(args) {
+    const maxMs = args.maxMs ?? 30 * 60 * 1000;
+    const pollMs = args.pollMs ?? 2000;
+    const started = Date.now();
+    let observedBusy = false;
+    let watched = null;
+    while (Date.now() - started < maxMs) {
+        const data = await v1Get(`/api/v1/sites/${encodeURIComponent(args.slug)}/agent-runs`);
+        const busy = (data.active ?? []).filter((r) => isBusyStatus(r.status));
+        if (busy.length > 0) {
+            observedBusy = true;
+            // If we were watching a run that left the active set, resolve it before
+            // switching — otherwise a failed run can be skipped when the next starts.
+            if (watched && !busy.some((r) => r.id === watched.id)) {
+                try {
+                    const detail = await v1Get(`/api/v1/sites/${encodeURIComponent(args.slug)}/agent-runs/${encodeURIComponent(watched.id)}`);
+                    if (detail.run && isFailTerminal(detail.run.status)) {
+                        progress("\n");
+                        return {
+                            exitCode: EXIT_USAGE,
+                            run: detail.run,
+                            observedBusy: true,
+                            status: detail.run.status,
+                        };
+                    }
+                }
+                catch {
+                    // Fall through and follow the new busy head.
+                }
+            }
+            const prevId = watched?.id;
+            const still = prevId
+                ? busy.find((r) => r.id === prevId)
+                : undefined;
+            const next = still ?? busy.find((r) => r.status === "deploying") ?? busy[0];
+            watched = next;
+            progress(`\r${next.status}  ${next.statusMessage ?? ""}   `);
+            await new Promise((r) => setTimeout(r, pollMs));
+            continue;
+        }
+        // Idle — if we were watching a busy run, refresh it for terminal fields (error).
+        if (observedBusy && watched) {
+            const watching = watched;
+            let refreshed = watching;
+            try {
+                const detail = await v1Get(`/api/v1/sites/${encodeURIComponent(args.slug)}/agent-runs/${encodeURIComponent(watching.id)}`);
+                if (detail.run)
+                    refreshed = detail.run;
+            }
+            catch {
+                // Fall back to list `run` only when it is the same id.
+                if (data.run?.id === watching.id)
+                    refreshed = data.run;
+            }
+            watched = refreshed;
+            // Active list cleared but our snapshot is still busy → keep polling.
+            if (isBusyStatus(refreshed.status)) {
+                progress(`\r${refreshed.status}  ${refreshed.statusMessage ?? ""}   `);
+                await new Promise((r) => setTimeout(r, pollMs));
+                continue;
+            }
+        }
+        progress("\n");
+        const decided = decideIdleExit({
+            watched,
+            latest: data.run,
+            observedBusy,
+            failClosedOnIdleTerminalFailure: args.failClosedOnIdleTerminalFailure,
+        });
+        return {
+            exitCode: decided.exitCode,
+            run: decided.run,
+            observedBusy,
+            status: decided.status,
+        };
+    }
+    progress("\n");
+    return {
+        exitCode: EXIT_USAGE,
+        run: watched,
+        observedBusy,
+        status: "timed_out",
+    };
+}
+/** Emit deploy/push-wait JSON or text from a WaitIdleResult. */
+export function emitWaitOutcome(args) {
+    const { result } = args;
+    const message = result.status === "timed_out"
+        ? "Timed out waiting for deploy."
+        : result.status === "still_busy"
+            ? "Timed out waiting for deploy (run still busy)."
+            : result.run?.error ||
+                result.run?.statusMessage ||
+                (isFailTerminal(result.status)
+                    ? `Latest run ${result.status}`
+                    : result.status);
+    if (result.exitCode !== EXIT_OK) {
+        if (isJson()) {
+            return emitFail(args.command, {
+                message,
+                exitCode: result.exitCode,
+                data: {
+                    slug: args.slug,
+                    waited: true,
+                    observedBusy: result.observedBusy,
+                    status: result.status,
+                    run: result.run,
+                    ...args.extra,
+                },
+            });
+        }
+        if (result.run) {
+            console.error(`${result.run.id}  ${result.run.status}${result.run.error ? `  ${result.run.error}` : result.run.statusMessage ? `  ${result.run.statusMessage}` : ""}`);
+        }
+        else {
+            console.error(message);
+        }
+        return result.exitCode;
+    }
+    if (isJson()) {
+        emitOk(args.command, {
+            slug: args.slug,
+            waited: true,
+            observedBusy: result.observedBusy,
+            status: result.status,
+            run: result.run,
+            ...args.extra,
+        });
+    }
+    else if (result.run) {
+        console.log(`${result.run.id}  ${result.run.status}${result.run.statusMessage ? `  ${result.run.statusMessage}` : ""}`);
+    }
+    else {
+        console.log("No active deploy.");
+    }
+    return EXIT_OK;
+}

package/dist/http/client.d.ts

@@ -3,13 +3,6 @@ export declare const EXIT_USAGE = 2;
 export declare const EXIT_CONFLICT = 3;
 export declare const EXIT_AUTH = 4;
 export declare const EXIT_UNEXPECTED = 5;
-export declare class CliHttpError extends Error {
-    readonly exitCode: number;
-    readonly status: number;
-    readonly code?: string;
-    constructor(message: string, exitCode: number, status: number, code?: string);
-}
-export declare function apiBase(): string;
 export type V1Envelope = {
     error?: {
         code?: string;
@@ -17,6 +10,19 @@ export type V1Envelope = {
         requestId?: string;
     };
 };
+export declare class CliHttpError extends Error {
+    readonly exitCode: number;
+    readonly status: number;
+    readonly code?: string;
+    /** v1 envelope requestId when the API returned one (§CLI Phase D). */
+    readonly requestId?: string;
+    constructor(message: string, exitCode: number, status: number, code?: string, requestId?: string);
+}
+/** 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

@@ -12,20 +12,63 @@ export class CliHttpError extends Error {
     exitCode;
     status;
     code;
-    constructor(message, exitCode, status, code) {
+    /** v1 envelope requestId when the API returned one (§CLI Phase D). */
+    requestId;
+    constructor(message, exitCode, status, code, requestId) {
         super(message);
         this.name = "CliHttpError";
         this.exitCode = exitCode;
         this.status = status;
         this.code = code;
+        this.requestId = requestId;
     }
 }
+/** Map a non-OK v1 response into CliHttpError (shared by JSON + multipart clients). */
+export function httpErrorFromV1(status, parsed, fallbackMessage) {
+    const message = parsed.error?.message ?? fallbackMessage ?? `Request failed (${status})`;
+    const code = parsed.error?.code;
+    const requestId = parsed.error?.requestId;
+    if (status === 401 || status === 403) {
+        return new CliHttpError(message, EXIT_AUTH, status, code, requestId);
+    }
+    if (status === 400 || code === "bad_request") {
+        return new CliHttpError(message, EXIT_USAGE, status, code, requestId);
+    }
+    if (status === 402 || status === 429 || code === "rate_limited" || code === "payment_required") {
+        return new CliHttpError(message, EXIT_USAGE, status, code, requestId);
+    }
+    if (status === 409 || code === "conflict") {
+        return new CliHttpError(message, EXIT_CONFLICT, status, code, requestId);
+    }
+    if (status === 413 || code === "payload_too_large") {
+        return new CliHttpError(message, EXIT_USAGE, status, code, requestId);
+    }
+    if (status === 503 || code === "unavailable") {
+        return new CliHttpError(message, EXIT_USAGE, status, code, requestId);
+    }
+    if (status === 404) {
+        const lower = message.toLowerCase();
+        if (lower === "not found." || lower === "not found") {
+            return new CliHttpError("API not available (is PUBLIC_CLI_ENABLED on for this environment?).", EXIT_UNEXPECTED, status, code, requestId);
+        }
+        return new CliHttpError(message, EXIT_AUTH, status, code, requestId);
+    }
+    return new CliHttpError(message, EXIT_UNEXPECTED, status, code, requestId);
+}
 export function apiBase() {
     const fromEnv = process.env.FRONTPAGE_API_BASE?.replace(/\/$/, "");
     if (fromEnv)
         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) {
@@ -58,31 +101,7 @@ async function v1Request(method, path, body) {
     }
     if (res.ok)
         return parsed;
-    const message = parsed.error?.message ?? `Request failed (${res.status})`;
-    const code = parsed.error?.code;
-    if (res.status === 401 || res.status === 403) {
-        throw new CliHttpError(message, EXIT_AUTH, res.status, code);
-    }
-    if (res.status === 402 || res.status === 429 || code === "rate_limited" || code === "payment_required") {
-        throw new CliHttpError(message, EXIT_USAGE, res.status, code);
-    }
-    if (res.status === 409 || code === "conflict") {
-        throw new CliHttpError(message, EXIT_CONFLICT, res.status, code);
-    }
-    if (res.status === 413 || code === "payload_too_large") {
-        throw new CliHttpError(message, EXIT_USAGE, res.status, code);
-    }
-    if (res.status === 503 || code === "unavailable") {
-        throw new CliHttpError(message, EXIT_USAGE, res.status, code);
-    }
-    if (res.status === 404) {
-        const lower = message.toLowerCase();
-        if (lower === "not found." || lower === "not found") {
-            throw new CliHttpError("API not available (is PUBLIC_CLI_ENABLED on for this environment?).", EXIT_UNEXPECTED, res.status, code);
-        }
-        throw new CliHttpError(message, EXIT_AUTH, res.status, code);
-    }
-    throw new CliHttpError(message, EXIT_UNEXPECTED, res.status, code);
+    throw httpErrorFromV1(res.status, parsed);
 }
 export async function v1Get(path) {
     return v1Request("GET", path);
@@ -130,31 +149,7 @@ export async function v1PostMultipart(path, form) {
     }
     if (res.ok)
         return parsed;
-    const message = parsed.error?.message ?? `Request failed (${res.status})`;
-    const code = parsed.error?.code;
-    if (res.status === 401 || res.status === 403) {
-        throw new CliHttpError(message, EXIT_AUTH, res.status, code);
-    }
-    if (res.status === 402 || res.status === 429 || code === "rate_limited" || code === "payment_required") {
-        throw new CliHttpError(message, EXIT_USAGE, res.status, code);
-    }
-    if (res.status === 409 || code === "conflict") {
-        throw new CliHttpError(message, EXIT_CONFLICT, res.status, code);
-    }
-    if (res.status === 413 || code === "payload_too_large") {
-        throw new CliHttpError(message, EXIT_USAGE, res.status, code);
-    }
-    if (res.status === 503 || code === "unavailable") {
-        throw new CliHttpError(message, EXIT_USAGE, res.status, code);
-    }
-    if (res.status === 404) {
-        const lower = message.toLowerCase();
-        if (lower === "not found." || lower === "not found") {
-            throw new CliHttpError("API not available (is PUBLIC_CLI_ENABLED on for this environment?).", EXIT_UNEXPECTED, res.status, code);
-        }
-        throw new CliHttpError(message, EXIT_AUTH, res.status, code);
-    }
-    throw new CliHttpError(message, EXIT_UNEXPECTED, res.status, code);
+    throw httpErrorFromV1(res.status, parsed);
 }
 export function exitCodeForError(err) {
     if (err instanceof CliHttpError)

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>;