@mevdragon/vidfarm-devcli 0.5.2 → 0.6.0

package/dist/src/frontend/debug.js

@@ -0,0 +1,71 @@
+const prefix = "[vidfarm]";
+const maxBufferedEntries = 1000;
+function shouldWriteToConsole(level) {
+    if (level !== "debug")
+        return true;
+    if (typeof window === "undefined")
+        return false;
+    try {
+        const params = new URLSearchParams(window.location.search);
+        return params.has("debug") || window.localStorage?.getItem("VIDFARM_DEBUG") === "1";
+    }
+    catch {
+        return false;
+    }
+}
+function write(level, event, detail) {
+    const entry = {
+        event,
+        detail,
+        timestamp: new Date().toISOString()
+    };
+    if (typeof window !== "undefined") {
+        window.__VIDFARM_DEBUG_LOGS__ = window.__VIDFARM_DEBUG_LOGS__ ?? [];
+        window.__VIDFARM_DEBUG_LOGS__.push(entry);
+        if (window.__VIDFARM_DEBUG_LOGS__.length > maxBufferedEntries) {
+            window.__VIDFARM_DEBUG_LOGS__.splice(0, window.__VIDFARM_DEBUG_LOGS__.length - maxBufferedEntries);
+        }
+    }
+    if (shouldWriteToConsole(level)) {
+        const method = level === "debug" ? "log" : level;
+        console[method](prefix, event, detail ?? "");
+    }
+}
+export function debugLog(event, detail) {
+    write("info", event, detail);
+}
+export function debugDebug(event, detail) {
+    write("debug", event, detail);
+}
+export function debugWarn(event, detail) {
+    write("warn", event, detail);
+}
+export function debugError(event, detail) {
+    write("error", event, detail);
+}
+export function installGlobalDebugHooks() {
+    if (typeof window === "undefined" || window.__VIDFARM_DEBUG_HOOKS__) {
+        return;
+    }
+    window.__VIDFARM_DEBUG_HOOKS__ = true;
+    debugLog("boot.hooks-installed", {
+        href: window.location.href,
+        readyState: document.readyState,
+        userAgent: navigator.userAgent
+    });
+    window.addEventListener("error", (event) => {
+        debugError("window.error", {
+            message: event.message,
+            filename: event.filename,
+            lineno: event.lineno,
+            colno: event.colno,
+            error: event.error instanceof Error ? event.error.stack : event.error
+        });
+    });
+    window.addEventListener("unhandledrejection", (event) => {
+        debugError("window.unhandledrejection", {
+            reason: event.reason instanceof Error ? event.reason.stack : event.reason
+        });
+    });
+}
+//# sourceMappingURL=debug.js.map

package/dist/src/frontend/flockposter-cache-store.js

@@ -0,0 +1,124 @@
+import { createStore } from "zustand/vanilla";
+export const FLOCKPOSTER_CACHE_STORAGE_KEY = "vidfarm:flockposter-cache:v1";
+const PUBLIC_SCOPE = "public";
+const emptySnapshot = {
+    channels: [],
+    posts: [],
+    channelsUpdatedAt: null,
+    calendarUpdatedAt: null,
+    calendarRangeStart: null,
+    calendarRangeEnd: null
+};
+export function getFlockPosterCacheStorageKey(userId) {
+    return `${FLOCKPOSTER_CACHE_STORAGE_KEY}_${userId?.trim() || PUBLIC_SCOPE}`;
+}
+export function readFlockPosterCacheSnapshot(userId) {
+    if (typeof window === "undefined") {
+        return emptySnapshot;
+    }
+    try {
+        const raw = window.localStorage.getItem(getFlockPosterCacheStorageKey(userId));
+        if (!raw) {
+            return emptySnapshot;
+        }
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object") {
+            return emptySnapshot;
+        }
+        return {
+            channels: Array.isArray(parsed.channels) ? parsed.channels : [],
+            posts: Array.isArray(parsed.posts) ? parsed.posts : [],
+            channelsUpdatedAt: typeof parsed.channelsUpdatedAt === "string" ? parsed.channelsUpdatedAt : null,
+            calendarUpdatedAt: typeof parsed.calendarUpdatedAt === "string" ? parsed.calendarUpdatedAt : null,
+            calendarRangeStart: typeof parsed.calendarRangeStart === "string" ? parsed.calendarRangeStart : null,
+            calendarRangeEnd: typeof parsed.calendarRangeEnd === "string" ? parsed.calendarRangeEnd : null
+        };
+    }
+    catch {
+        return emptySnapshot;
+    }
+}
+function writeFlockPosterCacheSnapshot(snapshot, userId) {
+    if (typeof window === "undefined") {
+        return;
+    }
+    try {
+        window.localStorage.setItem(getFlockPosterCacheStorageKey(userId), JSON.stringify(snapshot));
+    }
+    catch {
+        // Ignore storage failures and keep in-memory state only.
+    }
+}
+export function createFlockPosterCacheStore(userId) {
+    const initial = readFlockPosterCacheSnapshot(userId);
+    return createStore((set, get) => ({
+        ...initial,
+        setChannelsData: (channels) => {
+            const current = get();
+            const next = {
+                ...current,
+                channels: [
+                    ...current.channels.filter(isEmailChannel),
+                    ...channels.filter((channel) => !isEmailChannel(channel))
+                ],
+                channelsUpdatedAt: new Date().toISOString()
+            };
+            writeFlockPosterCacheSnapshot(next, userId);
+            set(next);
+        },
+        setCalendarData: (input) => {
+            const current = get();
+            const mergedChannels = dedupeChannels([...current.channels, ...input.channels]);
+            const mergedPosts = input.replaceRange
+                ? mergePostsForRange(current.posts, input.posts, input.rangeStart, input.rangeEnd)
+                : dedupePosts([...current.posts, ...input.posts]);
+            const next = {
+                ...current,
+                channels: mergedChannels,
+                posts: mergedPosts,
+                channelsUpdatedAt: new Date().toISOString(),
+                calendarUpdatedAt: new Date().toISOString(),
+                calendarRangeStart: expandRangeStart(current.calendarRangeStart, input.rangeStart),
+                calendarRangeEnd: expandRangeEnd(current.calendarRangeEnd, input.rangeEnd)
+            };
+            writeFlockPosterCacheSnapshot(next, userId);
+            set(next);
+        }
+    }));
+}
+function dedupeChannels(channels) {
+    return [...new Map(channels.map((channel) => [channel.id, channel])).values()];
+}
+function isEmailChannel(channel) {
+    return channel.id.startsWith("email:") || channel.platform?.toLowerCase() === "email";
+}
+function dedupePosts(posts) {
+    return [...new Map(posts.map((post) => [post.id, post])).values()];
+}
+function mergePostsForRange(currentPosts, nextPosts, rangeStart, rangeEnd) {
+    const startTime = Date.parse(rangeStart);
+    const endTime = Date.parse(rangeEnd);
+    if (Number.isNaN(startTime) || Number.isNaN(endTime)) {
+        return dedupePosts([...currentPosts, ...nextPosts]);
+    }
+    return dedupePosts([
+        ...currentPosts.filter((post) => {
+            const scheduledTime = Date.parse(post.scheduledAt);
+            return Number.isNaN(scheduledTime) || scheduledTime < startTime || scheduledTime > endTime;
+        }),
+        ...nextPosts
+    ]);
+}
+function expandRangeStart(current, next) {
+    if (!current) {
+        return next;
+    }
+    return Date.parse(next) < Date.parse(current) ? next : current;
+}
+function expandRangeEnd(current, next) {
+    if (!current) {
+        return next;
+    }
+    return Date.parse(next) > Date.parse(current) ? next : current;
+}
+//# sourceMappingURL=flockposter-cache-store.js.map

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

@@ -0,0 +1,182 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import "./sentry.js";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { hydrateRoot } from "react-dom/client";
+import * as Sentry from "@sentry/react";
+import { useStore } from "zustand";
+import { debugError, debugLog, installGlobalDebugHooks } from "./debug.js";
+import { HomepageShell } from "./homepage-view.js";
+import { createHomepageStore } from "./homepage-store.js";
+installGlobalDebugHooks();
+const bookmarkStorageKey = "vidfarm:discover-bookmarks:v1";
+const publicBookmarkScope = "public";
+function readBoot() {
+    const element = document.getElementById("homepage-boot");
+    if (!element?.textContent) {
+        return {
+            templates: [],
+            account: { isLoggedIn: false },
+            loadEndpoint: "/discover/feed",
+            skillEndpointPrefix: "/discover/skills/"
+        };
+    }
+    return JSON.parse(element.textContent);
+}
+function resolveBookmarkStorageKey(userId) {
+    return `${bookmarkStorageKey}_${userId?.trim() || publicBookmarkScope}`;
+}
+function readBookmarks(userId) {
+    try {
+        const raw = window.localStorage.getItem(resolveBookmarkStorageKey(userId));
+        if (!raw) {
+            return new Set();
+        }
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) {
+            return new Set();
+        }
+        return new Set(parsed.filter((value) => typeof value === "string"));
+    }
+    catch {
+        return new Set();
+    }
+}
+function writeBookmarks(bookmarks, userId) {
+    try {
+        window.localStorage.setItem(resolveBookmarkStorageKey(userId), JSON.stringify(Array.from(bookmarks)));
+    }
+    catch {
+        // Ignore storage failures and keep in-memory state.
+    }
+}
+function filterTemplates(input) {
+    const query = input.searchQuery.trim().toLowerCase();
+    return input.templates.filter((template) => {
+        const matchesSearch = !query || `${template.templateId} ${template.title} ${template.slugId} ${template.difficulty}`.toLowerCase().includes(query);
+        const matchesBookmarks = !input.bookmarksOnly || input.bookmarks.has(template.templateId);
+        return matchesSearch && matchesBookmarks;
+    });
+}
+function HomepageClientApp({ boot }) {
+    const store = useMemo(() => createHomepageStore(boot), [boot]);
+    const templates = useStore(store, (state) => state.templates);
+    const searchQuery = useStore(store, (state) => state.searchQuery);
+    const bookmarksOnly = useStore(store, (state) => state.bookmarksOnly);
+    const bookmarks = useStore(store, (state) => state.bookmarks);
+    const loading = useStore(store, (state) => state.loading);
+    const error = useStore(store, (state) => state.error);
+    const [bookmarksReady, setBookmarksReady] = useState(false);
+    const visibleTemplates = useMemo(() => filterTemplates({ templates, searchQuery, bookmarksOnly, bookmarks }), [templates, searchQuery, bookmarksOnly, bookmarks]);
+    useEffect(() => {
+        store.getState().setBookmarks(readBookmarks(boot.account.userId));
+        setBookmarksReady(true);
+    }, [boot.account.userId, store]);
+    useEffect(() => {
+        if (!bookmarksReady) {
+            return;
+        }
+        writeBookmarks(bookmarks, boot.account.userId);
+    }, [boot.account.userId, bookmarks, bookmarksReady]);
+    const refreshFeed = useCallback(async (options) => {
+        if (options?.showLoading) {
+            store.getState().setLoading(true);
+        }
+        try {
+            const response = await fetch(boot.loadEndpoint, {
+                credentials: "same-origin",
+                cache: "no-store",
+                headers: { Accept: "application/json" }
+            });
+            const payload = await response.json().catch(() => ({}));
+            if (!response.ok) {
+                throw new Error(typeof payload.error === "string" && payload.error ? payload.error : "Unable to load formats.");
+            }
+            store.getState().setTemplates(Array.isArray(payload.templates) ? payload.templates : []);
+        }
+        catch (fetchError) {
+            if (options?.showLoading) {
+                store.getState().setError(fetchError instanceof Error ? fetchError.message : "Unable to load formats.");
+            }
+            else {
+                // Background refresh failure keeps the current list on screen.
+                debugError("homepage.feed_refresh_failed", { message: fetchError instanceof Error ? fetchError.message : String(fetchError) });
+            }
+        }
+    }, [boot.loadEndpoint, store]);
+    useEffect(() => {
+        if (boot.templates.length > 0) {
+            return;
+        }
+        void refreshFeed({ showLoading: true });
+    }, [boot.templates.length, refreshFeed]);
+    // While one of the user's submissions is still downloading, poll the feed so
+    // the "Processing" card flips to an openable template without a manual reload.
+    const hasProcessingTemplates = templates.some((template) => template.status === "processing");
+    useEffect(() => {
+        if (!hasProcessingTemplates) {
+            return;
+        }
+        const timer = window.setInterval(() => {
+            void refreshFeed();
+        }, 8000);
+        return () => window.clearInterval(timer);
+    }, [hasProcessingTemplates, refreshFeed]);
+    const handleDeleteTemplate = useCallback(async (templateId) => {
+        try {
+            const response = await fetch(`/discover/templates/${encodeURIComponent(templateId)}`, {
+                method: "DELETE",
+                credentials: "same-origin",
+                headers: { Accept: "application/json" }
+            });
+            const payload = await response.json().catch(() => ({}));
+            if (!response.ok) {
+                return { ok: false, error: typeof payload.error === "string" && payload.error ? payload.error : "Unable to delete this template." };
+            }
+            debugLog("homepage.template_deleted", { template_id: templateId });
+            await refreshFeed();
+            return { ok: true };
+        }
+        catch (deleteError) {
+            return { ok: false, error: deleteError instanceof Error ? deleteError.message : "Unable to delete this template." };
+        }
+    }, [refreshFeed]);
+    const handleAddTemplate = useCallback(async (submission) => {
+        try {
+            const response = await fetch("/discover/templates", {
+                method: "POST",
+                credentials: "same-origin",
+                headers: { "content-type": "application/json", Accept: "application/json" },
+                body: JSON.stringify({
+                    source_url: submission.sourceUrl,
+                    tagline: submission.tagline || null,
+                    notes: submission.notes || null
+                })
+            });
+            const payload = await response.json().catch(() => ({}));
+            if (!response.ok) {
+                return { ok: false, error: typeof payload.error === "string" && payload.error ? payload.error : "Unable to add that video." };
+            }
+            debugLog("homepage.template_added", { source_url: submission.sourceUrl });
+            await refreshFeed();
+            return { ok: true };
+        }
+        catch (submitError) {
+            return { ok: false, error: submitError instanceof Error ? submitError.message : "Unable to add that video." };
+        }
+    }, [refreshFeed]);
+    return (_jsx(HomepageShell, { account: boot.account, templates: templates, visibleTemplates: visibleTemplates, searchQuery: searchQuery, bookmarksOnly: bookmarksOnly, bookmarks: bookmarks, loading: loading, error: error, skillEndpointPrefix: boot.skillEndpointPrefix, onSearchQueryChange: (value) => store.getState().setSearchQuery(value), onBookmarksOnlyChange: (value) => store.getState().setBookmarksOnly(value), onToggleBookmark: (templateId) => store.getState().toggleBookmark(templateId), onAddTemplate: handleAddTemplate, onDeleteTemplate: handleDeleteTemplate }));
+}
+const boot = readBoot();
+const root = document.getElementById("homepage-root");
+debugLog("homepage.boot", {
+    is_logged_in: boot.account?.isLoggedIn ?? false,
+    template_count: boot.templates?.length ?? 0,
+    load_endpoint: boot.loadEndpoint
+});
+if (root) {
+    hydrateRoot(root, (_jsx(Sentry.ErrorBoundary, { fallback: _jsx(_Fragment, {}), onError: (error) => debugError("homepage.render_error", { message: error instanceof Error ? error.message : String(error) }), children: _jsx(HomepageClientApp, { boot: boot }) })));
+}
+else {
+    debugError("homepage.no_root_element", {});
+}
+//# sourceMappingURL=homepage-client.js.map

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

@@ -0,0 +1,4 @@
+export function isVideoPreview(url) {
+    return Boolean(url && /\.(mp4|webm|ogg|mov)(\?|#|$)/i.test(url));
+}
+//# sourceMappingURL=homepage-shared.js.map

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

@@ -0,0 +1,28 @@
+import { createStore } from "zustand/vanilla";
+export function createHomepageStore(boot) {
+    return createStore((set) => ({
+        templates: boot.templates,
+        searchQuery: "",
+        bookmarksOnly: false,
+        bookmarks: new Set(),
+        loading: boot.templates.length === 0,
+        error: null,
+        setTemplates: (templates) => set({ templates, loading: false, error: null }),
+        setSearchQuery: (searchQuery) => set({ searchQuery }),
+        setBookmarksOnly: (bookmarksOnly) => set({ bookmarksOnly }),
+        setBookmarks: (bookmarks) => set({ bookmarks: new Set(bookmarks) }),
+        toggleBookmark: (templateId) => set((state) => {
+            const next = new Set(state.bookmarks);
+            if (next.has(templateId)) {
+                next.delete(templateId);
+            }
+            else {
+                next.add(templateId);
+            }
+            return { bookmarks: next };
+        }),
+        setLoading: (loading) => set({ loading }),
+        setError: (error) => set({ error, loading: false })
+    }));
+}
+//# sourceMappingURL=homepage-store.js.map