@growth-labs/cms 0.8.14 → 0.8.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@growth-labs/cms",
-  "version": "0.8.14",
+  "version": "0.8.16",
   "type": "module",
   "bin": {
     "growth-labs-cms-migrations": "./dist/cli/migrations.js"

package/src/engine/foundry-dispatch.ts

@@ -11,6 +11,7 @@
 
 import type { FoundryDispatch } from '../providers/types.js'
 import type { D1Database, D1PreparedStatement, D1Result } from './d1.js'
+import { classifyGoogleDriveUrl } from './google-drive-source.js'
 import { validPodcastSourceUrl } from './podcast-source.js'
 import { mediaPublicationCaptureGuard } from './publication-current-guard.js'
 
@@ -181,6 +182,7 @@ export async function dispatchToFoundry(
 	let sourceKind: string | null = null
 	let videoId: string | null = null
 	let durationSeconds: number | null
+	let googleDriveSource = false
 	let podcastSnapshot: PodcastDispatchSnapshot | null = null
 
 	if (videoRow) {
@@ -239,15 +241,22 @@ export async function dispatchToFoundry(
 			)
 		}
 		kind = 'podcast'
-		sourceKind = selectedSource ? 'https' : 'r2_key'
+		// A Google Drive source is fetched and measured by the Go plane: there is
+		// no editor-typed duration to require, and the hook is told the kind so it
+		// does not mistake the viewer URL for media. The stored kind stays 'https'
+		// (the column's only permitted value); Drive-ness is derived from the URL.
+		googleDriveSource =
+			Boolean(selectedSource) && classifyGoogleDriveUrl(selectedSource ?? '').kind === 'drive'
+		sourceKind = googleDriveSource ? 'google_drive' : selectedSource ? 'https' : 'r2_key'
 		videoId = normalizeVideoId(content.slug, content.slug)
 		durationSeconds = podcastRow.duration_seconds
 	}
 
 	if (
-		typeof durationSeconds !== 'number' ||
-		!Number.isFinite(durationSeconds) ||
-		durationSeconds <= 0
+		!googleDriveSource &&
+		(typeof durationSeconds !== 'number' ||
+			!Number.isFinite(durationSeconds) ||
+			durationSeconds <= 0)
 	) {
 		throw new FoundryDispatchPrerequisiteError(contentId)
 	}

package/src/engine/fronts-publish-intent.ts

@@ -40,6 +40,7 @@
 //     other. Real audio HLS is a separate media-pipeline change.
 import type { ContentType, FrontsPublishStatus } from '../schema/types.js'
 import type { D1Database } from './d1.js'
+import { classifyGoogleDriveUrl } from './google-drive-source.js'
 import {
 	frontsPodcastSourceGeneration,
 	type PodcastPublishBlockerCode,
@@ -122,6 +123,19 @@ export interface FrontsPublishPodcastAudioRef {
 	kind: 'r2-object' | 'hls-manifest'
 	url: string
 	duration_seconds: number | null
+	/**
+	 * `content_items.visibility` when the intent is built. The Go publisher
+	 * places a free episode's audio on the public bucket at go-live (the
+	 * public RSS sizes enclosures from PUBLIC_MEDIA) and keeps a premium
+	 * episode's audio off it.
+	 */
+	visibility: 'free' | 'premium'
+	/**
+	 * The raw R2 key behind `url` (`podcast_content.audio_r2_key`, no leading
+	 * slash); null for a legacy row whose stored audio is a full URL rather
+	 * than a key, which the publisher cannot place.
+	 */
+	object_key: string | null
 }
 
 /**
@@ -130,12 +144,17 @@ export interface FrontsPublishPodcastAudioRef {
  * `podcast_audio_hls`. Populated from `podcast_content.processing_source_url`
  * / `processing_source_kind` (migration 0028) -- the same "captured at
  * dispatch time" pattern `video_content.processing_source_url` already uses.
- * `kind` is always `'https'` today: a single literal, not an open enum,
- * because there is exactly one supported source kind. Present only while the
+ * `kind` is `'https'` (a direct URL, duration verified by the CMS) or
+ * `'google_drive'` (a Drive file the Go plane fetches and measures itself; see
+ * `FrontsPublishGoogleDrivePodcastSourceRef`). Present only while the
  * podcast is incomplete. An existing audio object with a missing transcript
  * still needs production; it is not a publishable audio reference yet.
  */
-export interface FrontsPublishPodcastSourceRef {
+export type FrontsPublishPodcastSourceRef =
+	| FrontsPublishHttpsPodcastSourceRef
+	| FrontsPublishGoogleDrivePodcastSourceRef
+
+export interface FrontsPublishHttpsPodcastSourceRef {
 	kind: 'https'
 	url: string
 	/** Immutable media identity; rescheduling alone does not change it. */
@@ -144,6 +163,22 @@ export interface FrontsPublishPodcastSourceRef {
 	duration_seconds: number
 }
 
+/**
+ * A Google Drive file the editor pasted a share link for. The Go plane fetches
+ * it with the estate's Google identity and measures the duration itself, so
+ * this shape carries NO `url` and NO `duration_seconds` (Go's schema rejects
+ * either). `file_id` matches `^[A-Za-z0-9_-]{10,200}$`; `resource_key`, when the
+ * link carried one, matches `^[A-Za-z0-9_-]{1,200}$`. Derived from the stored
+ * source URL by `classifyGoogleDriveUrl`; nothing about it is stored.
+ */
+export interface FrontsPublishGoogleDrivePodcastSourceRef {
+	kind: 'google_drive'
+	file_id: string
+	resource_key?: string
+	/** Immutable media identity; rescheduling alone does not change it. */
+	generation: string
+}
+
 /**
  * The video twin of `FrontsPublishPodcastSourceRef` (W1-02): the captured
  * source of a scheduled video whose HLS is not ready, for the Go
@@ -783,10 +818,14 @@ async function podcastSourceRef(
 		found.processing_source_kind !== 'https'
 	)
 		return null
+	// Duration is measured by the Go plane for a Drive source; only a plain
+	// https source needs the editor-verified duration up front.
+	const drive = classifyGoogleDriveUrl(found.processing_source_url)
 	if (
-		typeof found.duration_seconds !== 'number' ||
-		!Number.isFinite(found.duration_seconds) ||
-		found.duration_seconds <= 0
+		drive.kind !== 'drive' &&
+		(typeof found.duration_seconds !== 'number' ||
+			!Number.isFinite(found.duration_seconds) ||
+			found.duration_seconds <= 0)
 	) {
 		throw new FrontsPublishIntentError(
 			'podcast_source_duration_unavailable',
@@ -795,18 +834,27 @@ async function podcastSourceRef(
 		)
 	}
 	if (found.processing_state !== 'queued' || !found.processing_trigger_token?.trim()) return null
+	const generation = await frontsPodcastSourceGeneration({
+		content_id: row.id,
+		slug: row.slug,
+		canonical_version: row.canonical_version as number,
+		processing_source_url: found.processing_source_url,
+		processing_source_kind: found.processing_source_kind,
+		processing_trigger_token: found.processing_trigger_token,
+	})
+	if (drive.kind === 'drive') {
+		return {
+			kind: 'google_drive',
+			file_id: drive.fileId,
+			...(drive.resourceKey !== undefined ? { resource_key: drive.resourceKey } : {}),
+			generation,
+		}
+	}
 	return {
 		kind: 'https',
 		url: found.processing_source_url,
-		duration_seconds: found.duration_seconds,
-		generation: await frontsPodcastSourceGeneration({
-			content_id: row.id,
-			slug: row.slug,
-			canonical_version: row.canonical_version as number,
-			processing_source_url: found.processing_source_url,
-			processing_source_kind: found.processing_source_kind,
-			processing_trigger_token: found.processing_trigger_token,
-		}),
+		duration_seconds: found.duration_seconds as number,
+		generation,
 	}
 }
 
@@ -1070,6 +1118,8 @@ async function buildContentRefs(
 				kind: 'r2-object',
 				url: objectKeyUrl(key, ctx.mediaPublicDomain),
 				duration_seconds: found.duration_seconds ?? null,
+				visibility: row.visibility === 'premium' ? 'premium' : 'free',
+				object_key: /^https?:\/\//i.test(key) ? null : key.replace(/^\/+/, ''),
 			}
 		} else {
 			const failure = blocker ?? {

package/src/engine/google-drive-source.ts

@@ -0,0 +1,99 @@
+// Google Drive share-link recognition for media sources.
+//
+// A Drive share link is an HTML viewer page, never media. The Go media plane
+// fetches a Drive file itself (with the estate's Google identity) and measures
+// its duration, so the CMS only has to recognise the link and hand over the
+// file id (and the resource key that older shared files require).
+//
+// The link stays in the editor's own column exactly as pasted: the
+// `processing_source_kind` column is CHECK-constrained to 'https', so Drive-ness
+// is DERIVED from the stored URL, here, at serve/dispatch time -- one function,
+// no second source of truth to drift.
+
+/** Google Drive file ids are URL-safe base64-ish; the Go side enforces the same. */
+const DRIVE_FILE_ID_RE = /^[A-Za-z0-9_-]{10,200}$/
+const DRIVE_RESOURCE_KEY_RE = /^[A-Za-z0-9_-]{1,200}$/
+
+const DRIVE_HOSTS = new Set(['drive.google.com', 'docs.google.com'])
+
+const NOT_A_FILE_REASON =
+	'That is a Google Doc/Sheet/Slides/folder link, not an audio file. Share the audio file itself from Google Drive.'
+const NO_FILE_ID_REASON =
+	'That Google Drive link has no valid file id. Copy the share link of the audio file itself from Google Drive.'
+
+export type GoogleDriveLink =
+	| { kind: 'drive'; fileId: string; resourceKey?: string }
+	| { kind: 'drive_invalid'; reason: string }
+	| { kind: 'not_drive' }
+
+/**
+ * Classify a pasted media-source URL.
+ *
+ * - `not_drive`: not on a Google Drive host (drive.google.com, docs.google.com,
+ *   host compared case-insensitively). The caller handles it as any other URL.
+ * - `drive`: a recognised file link carrying a valid file id.
+ * - `drive_invalid`: on a Drive host but not usable as an audio file -- a
+ *   Doc/Sheet/folder, a file link with no or a malformed id, a malformed
+ *   `resourcekey`, or a shape this function does not know. The caller must
+ *   refuse it: stored as a plain https URL it would be an HTML page.
+ *
+ * Recognised shapes (each optionally with `/u/<n>/` user segments):
+ *   /file/d/<id>[/view|/edit|/...]      /open?id=<id>
+ *   /uc?id=<id>[&export=download]       (docs.google.com/uc?id=<id> too)
+ */
+export function classifyGoogleDriveUrl(value: string): GoogleDriveLink {
+	let url: URL
+	try {
+		url = new URL(value.trim())
+	} catch {
+		return { kind: 'not_drive' }
+	}
+	if (url.protocol !== 'https:' && url.protocol !== 'http:') return { kind: 'not_drive' }
+	const host = url.hostname.toLowerCase().replace(/\.$/, '')
+	if (!DRIVE_HOSTS.has(host)) return { kind: 'not_drive' }
+
+	if (url.protocol !== 'https:') {
+		return { kind: 'drive_invalid', reason: 'Google Drive links must use https.' }
+	}
+	if (url.username || url.password || (url.port && url.port !== '443')) {
+		return { kind: 'drive_invalid', reason: 'That Google Drive link is malformed.' }
+	}
+
+	// `/u/<n>/` selects the signed-in Google account; it carries nothing else.
+	const path = url.pathname.replace(/\/u\/\d+(?=\/)/g, '').replace(/\/+$/, '')
+
+	if (
+		/^\/(?:document|spreadsheets|presentation|forms)\/d(?:\/|$)/.test(path) ||
+		/^\/(?:drive\/)?folders(?:\/|$)/.test(path) ||
+		/^\/(?:embedded)?folderview$/.test(path)
+	) {
+		return { kind: 'drive_invalid', reason: NOT_A_FILE_REASON }
+	}
+
+	let candidate: string | null = null
+	const filePath = /^\/file\/d(?:\/([^/]*))?(?:\/.*)?$/.exec(path)
+	if (filePath) {
+		candidate = filePath[1] ?? ''
+	} else if (path === '/uc' || (path === '/open' && host === 'drive.google.com')) {
+		candidate = url.searchParams.get('id') ?? ''
+	} else {
+		return {
+			kind: 'drive_invalid',
+			reason:
+				'That Google Drive link is not a file link. Copy the share link of the audio file itself from Google Drive.',
+		}
+	}
+	if (!DRIVE_FILE_ID_RE.test(candidate)) {
+		return { kind: 'drive_invalid', reason: NO_FILE_ID_REASON }
+	}
+
+	const resourceKey = url.searchParams.get('resourcekey')
+	if (resourceKey === null) return { kind: 'drive', fileId: candidate }
+	if (!DRIVE_RESOURCE_KEY_RE.test(resourceKey)) {
+		return {
+			kind: 'drive_invalid',
+			reason: 'That Google Drive link has a malformed resource key. Copy the share link again.',
+		}
+	}
+	return { kind: 'drive', fileId: candidate, resourceKey }
+}

package/src/engine/index.ts

@@ -111,6 +111,7 @@ export {
 	hydrateFrontsPublishIntents,
 	setFrontsChannelTargets,
 } from './fronts-publish-intent.js'
+export { classifyGoogleDriveUrl, type GoogleDriveLink } from './google-drive-source.js'
 // Import parsers — pure string→struct transforms for Markdown/Ghost/Substack.
 export {
 	htmlToMarkdown,

package/src/migration-vendor.ts

@@ -341,12 +341,22 @@ function assertManifestCanAdvance(
 	}
 }
 
+/**
+ * A sequence the plan is about to allocate must not already be owned by a
+ * consumer migration. A target that is already on disk -- recorded in the
+ * receipt or adopted by hash -- is a historical fact, not a reservation: it has
+ * usually been applied, D1's ledger keys off its exact filename, and the only
+ * "fix" for a consumer file sharing its number would be a rename that re-runs
+ * applied SQL. So the guard covers new targets only; pre-existing duplicates are
+ * the consumer's to live with and never block vendoring the next migration.
+ */
 async function assertNoSequenceCollisions(
 	migrationsDir: string,
 	plan: PlannedMigration[],
 ): Promise<void> {
 	const existing = await readdir(migrationsDir)
 	for (const migration of plan) {
+		if (existing.includes(migration.target)) continue
 		const prefix = `${sequencePrefix(migration.sequence)}_`
 		const collisions = existing.filter(
 			(name) => name.endsWith('.sql') && name.startsWith(prefix) && name !== migration.target,

package/src/providers/types.ts

@@ -391,7 +391,12 @@ export interface FoundryJobSpec {
 	sourceUrl: string
 	sourceKind?: string
 	kind: string
-	durationSeconds: number
+	/**
+	 * The authoritative media duration. `null` only for a Google Drive podcast
+	 * source (`sourceKind: 'google_drive'`): the Go plane fetches the file itself
+	 * and measures the duration, so the CMS has none to send.
+	 */
+	durationSeconds: number | null
 	videoId?: string
 	title?: string
 	description?: string | null

package/src/routes/content.ts

@@ -38,6 +38,7 @@ import {
 	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,
@@ -433,7 +434,34 @@ export function normaliseNextcloudShareUrl(value: string): string {
 	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: ReturnType<typeof resolveConfig>) {
 	const category = slugEnum(resolved.primaryCategorySlugs)
@@ -476,7 +504,7 @@ function buildSchemas(resolved: ReturnType<typeof resolveConfig>) {
 				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(),
 			}),
 		}),
@@ -496,7 +524,7 @@ function buildSchemas(resolved: ReturnType<typeof resolveConfig>) {
 				// 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(),
 			}),
 		}),
@@ -561,7 +589,7 @@ 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(),
 })
 
@@ -569,7 +597,7 @@ 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(),
 })
 
@@ -990,6 +1018,22 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 			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
@@ -1081,11 +1125,22 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 	}
 
 	function mediaSourceReadinessFromStored(
+		type: ContentType,
 		stored: StoredMediaSource | null,
 	): MediaSourceReadiness | null {
 		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,
@@ -1664,7 +1719,10 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 				: 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: string[] = (() => {

package/src/ui/editor/ContentForm.tsx

@@ -1540,6 +1540,10 @@ function AudioBlock({
 				transcodes it, and hydrates the Audio R2 Key and duration automatically. Skip this once the
 				audio file is uploaded below.
 			</div>
+			<div style={assetHelp}>
+				A Google Drive share link to the audio file works too, if the file is shared with the Fronts
+				Google account or with anyone who has the link. Google Docs and folders are not audio files.
+			</div>
 
 			<div
 				style={{