@growth-labs/cms 0.8.8 → 0.8.15

package/dist/routes/content.js

@@ -21,6 +21,7 @@ import { ContentMetadataError, serializeContentMetadata, } from '../engine/conte
 import { listContributors, setContributors } from '../engine/contributors.js';
 import { applyFoundryCallback, dispatchToFoundry, FoundryDispatchPrerequisiteError, verifyHmac, } from '../engine/foundry-dispatch.js';
 import { parseFrontsChannelTargets, parseFrontsDefaultChannelTargets, setFrontsChannelTargets, } from '../engine/fronts-publish-intent.js';
+import { classifyGoogleDriveUrl } from '../engine/google-drive-source.js';
 import { evaluateArticleBody } from '../engine/publish-guard.js';
 import { createContent, createRevision, duplicateContentItem, evaluateContentBodyForPublish, getContentItem, getContentRelations, getContentTagPairs, publishContent, scheduleContent, unpublishContent, updateContentItem, VerifiedMediaDurationConflictError, } from '../engine/publisher.js';
 import { createRevisionWithDelta, getRevision, listRevisions, restoreRevision, } from '../engine/revisions.js';
@@ -250,7 +251,32 @@ export function normaliseNextcloudShareUrl(value) {
     }
     return url.toString();
 }
-const MediaSourceUrlSchema = z.string().url().transform(normaliseNextcloudShareUrl);
+// A Google Drive link is not run through the Nextcloud rewrite; it is kept as
+// the editor pasted it. The podcast schema accepts a valid Drive file link
+// (the Go plane fetches and measures it itself) and turns any other
+// drive.google.com / docs.google.com URL -- a Doc, a folder, a link with no
+// file id -- into a field-level issue, because stored as a plain https URL it
+// is an HTML page. The video schema refuses every Drive link: the video path
+// ingests over plain https and would fetch the viewer page.
+const PodcastSourceUrlSchema = z
+    .string()
+    .url()
+    .superRefine((value, ctx) => {
+    const link = classifyGoogleDriveUrl(value);
+    if (link.kind === 'drive_invalid')
+        ctx.addIssue({ code: 'custom', message: link.reason });
+})
+    .transform(normaliseNextcloudShareUrl);
+const VIDEO_DRIVE_SOURCE_UNSUPPORTED = 'Google Drive links are not yet supported for video; share a direct download link';
+const VideoSourceUrlSchema = z
+    .string()
+    .url()
+    .superRefine((value, ctx) => {
+    if (classifyGoogleDriveUrl(value).kind !== 'not_drive') {
+        ctx.addIssue({ code: 'custom', message: VIDEO_DRIVE_SOURCE_UNSUPPORTED });
+    }
+})
+    .transform(normaliseNextcloudShareUrl);
 function buildSchemas(resolved) {
     const category = slugEnum(resolved.primaryCategorySlugs);
     const topic = slugEnum(resolved.primaryTopicSlugs);
@@ -289,7 +315,7 @@ function buildSchemas(resolved) {
                 videoId: z.string().min(1),
                 durationSeconds: z.number().int().positive().optional().nullable(),
                 thumbnailImageId: z.string().optional().nullable(),
-                processingSourceUrl: MediaSourceUrlSchema.optional().nullable(),
+                processingSourceUrl: VideoSourceUrlSchema.optional().nullable(),
                 processingSourceKind: z.string().min(1).optional().nullable(),
             }),
         }),
@@ -309,7 +335,7 @@ function buildSchemas(resolved) {
                 // there because a video always has a slug-derived identity up front.
                 audioR2Key: z.string().default(''),
                 durationSeconds: z.number().int().positive().optional().nullable(),
-                processingSourceUrl: MediaSourceUrlSchema.optional().nullable(),
+                processingSourceUrl: PodcastSourceUrlSchema.optional().nullable(),
                 processingSourceKind: z.string().min(1).optional().nullable(),
             }),
         }),
@@ -369,14 +395,14 @@ const VideoContentUpdateSchema = z.object({
     videoId: z.string().optional(),
     durationSeconds: z.number().int().positive().optional().nullable(),
     thumbnailImageId: z.string().optional().nullable(),
-    processingSourceUrl: MediaSourceUrlSchema.optional().nullable(),
+    processingSourceUrl: VideoSourceUrlSchema.optional().nullable(),
     processingSourceKind: z.string().min(1).optional().nullable(),
 });
 const PodcastContentUpdateSchema = z.object({
     transcript: z.string().optional(),
     audioR2Key: z.string().optional(),
     durationSeconds: z.number().int().positive().optional().nullable(),
-    processingSourceUrl: MediaSourceUrlSchema.optional().nullable(),
+    processingSourceUrl: PodcastSourceUrlSchema.optional().nullable(),
     processingSourceKind: z.string().min(1).optional().nullable(),
 });
 function getContentUpdateSchema(type) {
@@ -672,6 +698,22 @@ export function createContentRoutes(config) {
             content.durationSeconds = null;
             return null;
         }
+        // A Drive podcast source is fetched and measured by the Go plane, not
+        // probed here: keep the editor's URL as pasted, store no duration and let
+        // the host's probe stay out of it (it would fetch the HTML viewer page).
+        if (type === 'podcast' && classifyGoogleDriveUrl(requestedUrl).kind === 'drive') {
+            content.processingSourceUrl = requestedUrl;
+            content.processingSourceKind = 'https';
+            content.durationSeconds = null;
+            return {
+                requestedUrl,
+                resolvedUrl: requestedUrl,
+                sourceKind: 'https',
+                durationSeconds: null,
+                ready: true,
+                blockers: [],
+            };
+        }
         const storedDuration = positiveIntegerDuration(stored?.durationSeconds);
         if (stored?.sourceUrl === requestedUrl && storedDuration !== null) {
             content.processingSourceUrl = stored.sourceUrl;
@@ -754,12 +796,22 @@ export function createContentRoutes(config) {
             blockers: durationSeconds === null && blockers.length === 0 ? ['duration_probe_failed'] : blockers,
         };
     }
-    function mediaSourceReadinessFromStored(stored) {
+    function mediaSourceReadinessFromStored(type, stored) {
         if (!stored)
             return null;
         const sourceUrl = stored.sourceUrl?.trim();
         if (!sourceUrl)
             return null;
+        if (type === 'podcast' && classifyGoogleDriveUrl(sourceUrl).kind === 'drive') {
+            return {
+                requestedUrl: sourceUrl,
+                resolvedUrl: sourceUrl,
+                sourceKind: 'https',
+                durationSeconds: null,
+                ready: true,
+                blockers: [],
+            };
+        }
         const durationSeconds = positiveIntegerDuration(stored.durationSeconds);
         return {
             requestedUrl: sourceUrl,
@@ -804,6 +856,64 @@ export function createContentRoutes(config) {
             return { result: null, reason: 'dispatch_failed' };
         }
     }
+    /**
+     * The video sibling of maybeDispatchPodcastToFoundry: capture a sourced video
+     * that holds no capture. A row with no trigger token is invisible to the
+     * producer whatever its state says (trash and restore clears the token and
+     * leaves `queued`), so only `ready` media and `failed` — the editor's Re-run
+     * decision — are left alone. An archived item is inactive to the dispatcher;
+     * it is captured once scheduling has made it active again.
+     * The editor form captures after a save too, but it de-dupes on local state; a
+     * later save that reset the capture left the video scheduled and never
+     * prepared, with nothing to notice (Fronts, 2026-09-15..17).
+     */
+    async function maybeCaptureVideoSource(ctx, contentId) {
+        const hook = resolved.hooks.foundryVideo;
+        if (!hook)
+            return null;
+        const readCapture = () => ctx.db
+            .prepare(`SELECT vc.processing_source_url, vc.processing_trigger_token, vc.processing_state,
+						vc.hls_ready, ci.status
+					FROM video_content vc JOIN content_items ci ON ci.id = vc.content_id
+					WHERE vc.content_id = ?
+					LIMIT 1`)
+            .bind(contentId)
+            .first();
+        const row = await readCapture();
+        if (!row?.processing_source_url?.trim())
+            return null;
+        if (row.processing_trigger_token?.trim())
+            return null;
+        if (row.status === 'archived')
+            return null;
+        if (row.hls_ready === 1)
+            return null;
+        if (row.processing_state === 'ready' || row.processing_state === 'failed')
+            return null;
+        try {
+            return await dispatchToFoundry(ctx.db, contentId, hook, { ifUncaptured: true });
+        }
+        catch (error) {
+            // The editor form fires its own capture after every save. Losing that
+            // race fails this call's compare-and-set, and the capture exists.
+            const raced = await readCapture();
+            if (raced?.processing_trigger_token?.trim())
+                return null;
+            throw error;
+        }
+    }
+    async function captureScheduledVideoAfterSave(ctx, contentId) {
+        try {
+            return { result: await maybeCaptureVideoSource(ctx, contentId), reason: null };
+        }
+        catch (error) {
+            if (error instanceof FoundryDispatchPrerequisiteError) {
+                return { result: null, reason: 'missing_duration' };
+            }
+            console.error('Scheduled video source capture failed after content save', error);
+            return { result: null, reason: 'dispatch_failed' };
+        }
+    }
     function missingDurationResponse() {
         return json({
             error: 'Content requires a positive finite duration before dispatch',
@@ -1027,6 +1137,31 @@ export function createContentRoutes(config) {
                 const publishAtSeconds = Math.floor(publishAtMs / 1000);
                 const expectedTargets = new Map();
                 for (const id of ids) {
+                    // Same gate as the single-item path: no item in a bulk schedule
+                    // may take a slot with a body publish will refuse.
+                    const bulkGuard = await evaluateContentBodyForPublish(ctx.db, id, 'cms.schedule', {
+                        requireBody: false,
+                    });
+                    if (bulkGuard && !bulkGuard.ok) {
+                        return json({
+                            error: 'Article body failed pre-publish validation',
+                            source: 'cms.schedule',
+                            contentId: id,
+                            errors: bulkGuard.errors,
+                        }, 422);
+                    }
+                    // And the same capture guarantee: no sourced video in a bulk
+                    // schedule may take a slot the producer cannot see.
+                    try {
+                        await maybeCaptureVideoSource(ctx, id);
+                    }
+                    catch (error) {
+                        if (error instanceof FoundryDispatchPrerequisiteError) {
+                            return missingDurationResponse();
+                        }
+                        console.error('Video source capture failed before bulk schedule', error);
+                        return json({ error: 'Foundry dispatch failed', contentId: id }, 502);
+                    }
                     const prepared = await prepareScheduleTargets(ctx, id);
                     if ('error' in prepared)
                         return prepared.error;
@@ -1039,6 +1174,8 @@ export function createContentRoutes(config) {
                     if (targets !== undefined && !changed) {
                         return json({ error: 'schedule_targets_changed', contentId: id, scheduled }, 409);
                     }
+                    // Covers an item that was archived above, now active again.
+                    await captureScheduledVideoAfterSave(ctx, id);
                     scheduled.push(id);
                 }
                 return json({ scheduled });
@@ -1162,7 +1299,7 @@ export function createContentRoutes(config) {
                 }
                 : content;
             const mediaSourceReadiness = item.type === 'video' || item.type === 'podcast'
-                ? mediaSourceReadinessFromStored(await loadStoredMediaSource(ctx.db, id, item.type))
+                ? mediaSourceReadinessFromStored(item.type, await loadStoredMediaSource(ctx.db, id, item.type))
                 : null;
             const aiLockedFields = (() => {
                 try {
@@ -1307,6 +1444,11 @@ export function createContentRoutes(config) {
             const podcastAttempt = existing.type === 'podcast'
                 ? await dispatchPodcastAfterSave(ctx, id)
                 : { result: null, reason: null };
+            // A scheduled video is committed to a slot: a save that reset its capture
+            // must not leave it unprepared until someone notices the missed publish.
+            const videoAttempt = existing.type === 'video' && existing.status === 'scheduled'
+                ? await captureScheduledVideoAfterSave(ctx, id)
+                : { result: null, reason: null };
             // If the slug changed, record the old slug as a redirect (spec §8)
             // and drop any stale redirect row for the now-live slug — atomically,
             // so a live slug is never also a redirect source (rename-back safety).
@@ -1319,6 +1461,8 @@ export function createContentRoutes(config) {
                 podcastFoundryQueued: Boolean(podcastAttempt.result),
                 podcastFoundryCorrelationId: podcastAttempt.result?.correlationId ?? null,
                 podcastFoundryReason: podcastAttempt.reason,
+                videoFoundryQueued: Boolean(videoAttempt.result && !videoAttempt.result.skipped),
+                videoFoundryReason: videoAttempt.reason,
                 ...(mediaSourceReadiness ? { mediaSourceReadiness } : {}),
                 // Present and empty when the body linted clean, so a client can
                 // distinguish "no warnings" from "this build does not report them".
@@ -1369,6 +1513,39 @@ export function createContentRoutes(config) {
                 if (!Number.isFinite(publishAtSeconds)) {
                     return json({ error: 'Missing publish time' }, 400);
                 }
+                // A body the publish guard will refuse must not be allowed to take a
+                // slot. Scheduling was the one write in this lane that never ran
+                // the guard, so a defect an editor could not see at save time
+                // surfaced only when foundryd tried to publish — at 16:30 on a
+                // Monday, as a missed premium article (2026-09-15).
+                const scheduleGuard = await evaluateContentBodyForPublish(ctx.db, id, 'cms.schedule', {
+                    // Claiming a slot before the piece is written stays allowed;
+                    // claiming one with an already-broken body does not.
+                    requireBody: false,
+                });
+                if (scheduleGuard && !scheduleGuard.ok) {
+                    return json({
+                        error: 'Article body failed pre-publish validation',
+                        source: 'cms.schedule',
+                        errors: scheduleGuard.errors,
+                    }, 422);
+                }
+                // A sourced video that holds no capture is invisible to the producer:
+                // it would take the slot and never publish. Capture it here, and refuse
+                // the slot if that cannot be done. A video with no source yet may still
+                // claim a slot early.
+                if (existing.type === 'video') {
+                    try {
+                        await maybeCaptureVideoSource(ctx, id);
+                    }
+                    catch (error) {
+                        if (error instanceof FoundryDispatchPrerequisiteError) {
+                            return missingDurationResponse();
+                        }
+                        console.error('Video source capture failed before schedule', error);
+                        return json({ error: 'Foundry dispatch failed' }, 502);
+                    }
+                }
                 const prepared = await prepareScheduleTargets(ctx, id);
                 if ('error' in prepared)
                     return prepared.error;
@@ -1376,6 +1553,9 @@ export function createContentRoutes(config) {
                 if (prepared.targets !== undefined && !changed) {
                     return json({ error: 'schedule_targets_changed', contentId: id }, 409);
                 }
+                // Covers an item that was archived above, now active again.
+                if (existing.type === 'video')
+                    await captureScheduledVideoAfterSave(ctx, id);
                 // Fire content.scheduled webhook.
                 await fireWebhook(ctx, 'content.scheduled', {
                     id,
@@ -1388,6 +1568,9 @@ export function createContentRoutes(config) {
             if (action === 'publish') {
                 const now = Math.floor(Date.now() / 1000);
                 const wasDraft = existing.status === 'draft';
+                const publishedAt = existing.status === 'published' && existing.published_at !== null
+                    ? existing.published_at
+                    : now;
                 let podcastDispatch = null;
                 if (existing.type === 'podcast') {
                     try {
@@ -1483,7 +1666,7 @@ export function createContentRoutes(config) {
                     throw error;
                 }
                 try {
-                    await publishContent(ctx.db, id, now);
+                    await publishContent(ctx.db, id, publishedAt, now);
                     await createRevision(ctx.db, id, ctx.userId || null);
                 }
                 catch (error) {