@growth-labs/cms 0.6.8 → 0.8.1

package/src/routes/calendar.ts

@@ -9,11 +9,19 @@
 //
 // No provider calls: the editorial calendar is fully first-party D1.
 
+import type { FoundryDispatch, FoundryJobStatus } from '../providers/types.js'
 import type { Authz, RouteContext } from './context.js'
 import { json } from './context.js'
 
 export interface CalendarRouteConfig {
 	authz: Authz
+	/**
+	 * W1-08b: when the host supplies its Foundry provider, every scheduled
+	 * video/podcast item in the range carries its Go publish state
+	 * (`goPublish`) read through `getJob(contentId)` -- the badge the
+	 * calendar chip renders. Absent provider → `goPublish` is omitted.
+	 */
+	foundryVideo?: Pick<FoundryDispatch, 'getJob'>
 }
 
 export interface CalendarRouteHandlers {
@@ -29,6 +37,60 @@ export interface CalendarRouteItem {
 	slug: string
 	/** ISO-8601 date string derived from publish_at (scheduled) or published_at (published). */
 	date: string
+	/**
+	 * Go publish state of a scheduled video/podcast item (W1-08b). `null`
+	 * when the host provider knows nothing about the item; a `state` of
+	 * `unavailable` with `blockedReason` when the provider itself failed --
+	 * the badge says so rather than rendering nothing.
+	 */
+	goPublish?: CalendarGoPublish | null
+}
+
+export interface CalendarGoPublish {
+	state: FoundryJobStatus['state'] | 'unavailable'
+	eventKind: string | null
+	receiptAt: number | null
+	correlationId: string | null
+	blockedReason: string | null
+	processingState: string | null
+	mediaReady: boolean
+}
+
+const GO_PUBLISH_TYPES = new Set(['video', 'podcast'])
+
+/** Fold a provider answer into the calendar's badge shape. */
+export function toCalendarGoPublish(status: FoundryJobStatus | null): CalendarGoPublish | null {
+	if (!status) return null
+	return {
+		state: status.state,
+		eventKind: status.eventKind ?? null,
+		receiptAt: status.receiptAt ?? null,
+		correlationId: status.correlationId ?? null,
+		blockedReason: status.blockedReason ?? null,
+		processingState: status.processingState ?? null,
+		mediaReady: status.mediaReady ?? false,
+	}
+}
+
+async function readGoPublish(
+	provider: Pick<FoundryDispatch, 'getJob'>,
+	contentId: string,
+): Promise<CalendarGoPublish | null> {
+	try {
+		return toCalendarGoPublish(await provider.getJob(contentId))
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error)
+		console.warn('calendar: Go publish state unavailable', { contentId, reason })
+		return {
+			state: 'unavailable',
+			eventKind: null,
+			receiptAt: null,
+			correlationId: null,
+			blockedReason: reason,
+			processingState: null,
+			mediaReady: false,
+		}
+	}
 }
 
 /**
@@ -121,6 +183,16 @@ export function createCalendarRoutes(config: CalendarRouteConfig): CalendarRoute
 				date: toIso(row.date_unix),
 			}))
 
+			const provider = config.foundryVideo
+			if (provider) {
+				await Promise.all(
+					items.map(async (item) => {
+						if (item.status !== 'scheduled' || !GO_PUBLISH_TYPES.has(item.type)) return
+						item.goPublish = await readGoPublish(provider, item.id)
+					}),
+				)
+			}
+
 			return json({ items })
 		},
 	}

package/src/routes/content.ts

@@ -199,6 +199,8 @@ export interface ContentRouteConfig extends CmsRouteConfig {
 	publishReadiness?: PublishReadinessHook
 	/** Host's existing production rollback control; omitted means enabled. */
 	podcastSourceProductionEnabled?: boolean
+	/** The video twin (FRONTS_VIDEO_DISPATCH_TARGET on the host); omitted means enabled. */
+	videoSourceProductionEnabled?: boolean
 	/** Internal machine-route constraint: atomically update only in this status. */
 	updateStatusConstraint?: ContentStatus
 	/**

package/src/routes/fronts-publish.ts

@@ -199,6 +199,7 @@ export function createFrontsPublishRoutes(config: ContentRouteConfig): FrontsPub
 					nowSeconds: now,
 					mediaPublicDomain: resolved.mediaPublicDomain,
 					podcastSourceProductionEnabled: config.podcastSourceProductionEnabled,
+					videoSourceProductionEnabled: config.videoSourceProductionEnabled,
 					// Site-RELATIVE paths: the CMS does not know the site origin, and the
 					// consumer joins its own trusted configured origin. A host-supplied
 					// origin is deliberately deferred (packages-docs/cms.md).

package/src/ui/api/_content-config.ts

@@ -26,6 +26,7 @@ type CmsHooksLocals = ContentRouteConfig['hooks'] & {
 	dispatchWebhook?: DispatchWebhookHook
 	publishReadiness?: PublishReadinessHook
 	podcastSourceProductionEnabled?: boolean
+	videoSourceProductionEnabled?: boolean
 }
 
 /**
@@ -84,5 +85,6 @@ export function toContentConfig(c: APIContext): ContentRouteConfig {
 		dispatchWebhook: hooks.dispatchWebhook,
 		publishReadiness: hooks.publishReadiness,
 		podcastSourceProductionEnabled: hooks.podcastSourceProductionEnabled,
+		videoSourceProductionEnabled: hooks.videoSourceProductionEnabled,
 	}
 }

package/src/ui/api/calendar.ts

@@ -1,6 +1,7 @@
 // src/ui/api/calendar.ts — Astro endpoint adapter for GET /admin/api/calendar.
 // Maps the APIContext onto a RouteContext and delegates to createCalendarRoutes().month.
-// The calendar is first-party D1 (no provider injection needed).
+// The calendar is first-party D1; the host's Foundry provider (locals.cmsHooks.foundryVideo)
+// adds the Go publish badge state to scheduled media items when present (W1-08b).
 
 import type { APIContext } from 'astro'
 import { type CalendarRouteConfig, createCalendarRoutes } from '../../routes/calendar.js'
@@ -13,8 +14,11 @@ function toCtx(c: APIContext): RouteContext {
 }
 
 function calendarConfig(c: APIContext): CalendarRouteConfig {
+	const hooks = (c.locals as { cmsHooks?: { foundryVideo?: CalendarRouteConfig['foundryVideo'] } })
+		.cmsHooks
 	return {
 		authz: buildSiteAuthz(c),
+		foundryVideo: hooks?.foundryVideo,
 	}
 }
 

package/src/ui/screens/CalendarScreen.tsx

@@ -18,6 +18,7 @@
 import { useCallback, useEffect, useReducer, useState } from 'react'
 import { Icon } from '../icons.js'
 import { buildCalendarMonth, type CalendarCell, type CalendarItem } from './calendar-data.js'
+import { goPublishBadge } from './go-publish-badge.js'
 
 // ---------------------------------------------------------------------------
 // Props
@@ -483,6 +484,10 @@ function CalendarItemChip({
 	const border = TYPE_COLOR[item.type] ?? 'var(--accent)'
 	const statusIcon = STATUS_ICON[item.status]
 	const statusColor = STATUS_ICON_COLOR[item.status] ?? 'var(--ink-faint)'
+	// W1-08b: the Go publish state of a scheduled media item, from the
+	// host's receipts (route: goPublish). Hover shows the receipt and the
+	// correlation id; the pill vocabulary is the Foundry tab's.
+	const badge = goPublishBadge(item.goPublish)
 
 	return (
 		<div
@@ -520,6 +525,23 @@ function CalendarItemChip({
 			>
 				{item.title || '(Untitled)'}
 			</button>
+			{badge && (
+				<span
+					className={
+						badge.pill === 'ready'
+							? 'pill published'
+							: badge.pill === 'failed'
+								? 'pill review'
+								: 'pill processing'
+					}
+					title={badge.tooltip}
+					data-go-publish={item.goPublish?.state}
+					style={{ flex: 'none', fontSize: 9, padding: '1px 5px', whiteSpace: 'nowrap' }}
+				>
+					<span className="pdot" />
+					{badge.label}
+				</span>
+			)}
 			{statusIcon &&
 				(item.status === 'scheduled' ? (
 					<button

package/src/ui/screens/calendar-data.ts

@@ -13,6 +13,8 @@
 // Types
 // ---------------------------------------------------------------------------
 
+import type { CalendarGoPublish } from '../../routes/calendar.js'
+
 /**
  * A dated content item as returned by the `/admin/api/calendar?from=&to=` route.
  * `date` is an ISO-8601 string (date-only or with time component, UTC-assumed).
@@ -24,6 +26,8 @@ export interface CalendarItem {
 	slug: string
 	title: string
 	date: string
+	/** Go publish state of a scheduled video/podcast item (W1-08b); see go-publish-badge.ts. */
+	goPublish?: CalendarGoPublish | null
 }
 
 /** A leading blank cell before the first day of the month. */

package/src/ui/screens/go-publish-badge.ts

@@ -0,0 +1,55 @@
+// src/ui/screens/go-publish-badge.ts — pure badge model for a scheduled media
+// item's Go publish state (W1-08b).
+//
+// goPublishBadge(goPublish) → { label, pill, tooltip } | null
+//   label   — the word the chip shows ("Captured", "Processing", …)
+//   pill    — the FoundryPillState bucket the broadsheet pill classes render
+//             (working / ready / failed), reused from foundry-stages
+//   tooltip — the hover text: label, the newest receipt and its time, the
+//             correlation id, and the blocked reason when there is one
+//
+// Pure — no DOM, no React, fully vitest-testable.
+
+import type { CalendarGoPublish } from '../../routes/calendar.js'
+import type { FoundryPillState } from '../inspector/foundry-stages.js'
+
+export interface GoPublishBadge {
+	label: string
+	pill: FoundryPillState
+	tooltip: string
+}
+
+const LABELS: Record<string, { label: string; pill: FoundryPillState }> = {
+	pending: { label: 'Not captured', pill: 'working' },
+	captured: { label: 'Captured', pill: 'working' },
+	processing: { label: 'Processing', pill: 'working' },
+	media_ready: { label: 'Media ready', pill: 'ready' },
+	publishing: { label: 'Publishing', pill: 'working' },
+	published: { label: 'Published', pill: 'ready' },
+	late: { label: 'Late', pill: 'failed' },
+	failed: { label: 'Blocked', pill: 'failed' },
+	unavailable: { label: 'State unavailable', pill: 'failed' },
+}
+
+/** Format a unix-second receipt time for the tooltip (UTC, to the minute). */
+export function formatReceiptTime(unixSeconds: number): string {
+	return `${new Date(unixSeconds * 1000).toISOString().slice(0, 16).replace('T', ' ')} UTC`
+}
+
+export function goPublishBadge(
+	goPublish: CalendarGoPublish | null | undefined,
+): GoPublishBadge | null {
+	if (!goPublish) return null
+	const entry = LABELS[goPublish.state] ?? { label: goPublish.state, pill: 'working' as const }
+	const lines = [`Go publish: ${entry.label}`]
+	if (goPublish.eventKind && goPublish.receiptAt !== null) {
+		lines.push(`Last receipt: ${goPublish.eventKind} at ${formatReceiptTime(goPublish.receiptAt)}`)
+	} else if (goPublish.eventKind) {
+		lines.push(`Last receipt: ${goPublish.eventKind}`)
+	} else {
+		lines.push('No receipt yet')
+	}
+	if (goPublish.correlationId) lines.push(`Correlation: ${goPublish.correlationId}`)
+	if (goPublish.blockedReason) lines.push(`Reason: ${goPublish.blockedReason}`)
+	return { label: entry.label, pill: entry.pill, tooltip: lines.join('\n') }
+}