@growth-labs/cms 0.7.0 → 0.8.2

package/src/engine/index.ts

@@ -409,6 +409,11 @@ export {
 	validateArticleBody,
 	warnErrors,
 } from './validator/index.js'
+export {
+	type FrontsVideoSourceSnapshot,
+	frontsVideoSourceGeneration,
+	videoSourceIngestableOverHttps,
+} from './video-source.js'
 // Webhook signer + default dispatch impl — HMAC-SHA256 via Web Crypto (P7 Task 9).
 export {
 	buildDefaultDispatchWebhook,

package/src/engine/video-source.ts

@@ -0,0 +1,45 @@
+/** Current CMS evidence used by the signed schedule and media callback guards. */
+export interface FrontsVideoSourceSnapshot {
+	content_id: string
+	slug: string
+	canonical_version: number
+	processing_source_url: string | null
+	processing_source_kind: string | null
+	processing_trigger_token: string | null
+}
+
+/**
+ * Stable over polling, machine media callbacks and rescheduling; canonical
+ * editor/source changes invalidate the old production. The raw trigger token
+ * and URL never need to appear in callback or notification identities. The
+ * Go consumer's contract is `fronts-video-source.v1` (foundry
+ * `publishplane/masthead/videosource.schema.json`, exported by
+ * `foundry-capability-probe --contract`).
+ */
+export async function frontsVideoSourceGeneration(
+	input: FrontsVideoSourceSnapshot,
+): Promise<string> {
+	const bytes = new TextEncoder().encode(
+		JSON.stringify([
+			'fronts-video-source.v1',
+			input.content_id,
+			input.slug,
+			input.canonical_version,
+			input.processing_source_url,
+			input.processing_source_kind,
+			input.processing_trigger_token,
+		]),
+	)
+	const digest = await crypto.subtle.digest('SHA-256', bytes)
+	return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, '0')).join('')
+}
+
+/**
+ * Source kinds the Go media.pipeline can ingest over plain HTTPS
+ * (`ingest.https.verified`): a direct URL and a Dropbox share link, both of
+ * which are fetched as-is. A Trello attachment needs the board credential
+ * and stays on the host's own dispatch path.
+ */
+export function videoSourceIngestableOverHttps(kind: string | null | undefined): boolean {
+	return kind === 'http_url' || kind === 'dropbox'
+}

package/src/integration/index.ts

@@ -111,6 +111,13 @@ export default function growthLabsCms(userOptions: CmsIntegrationOptions): Astro
 					pattern: `${base}/api/content/insights-ingest`,
 					entrypoint: resolveEntrypoint('../ui/api/content/insights-ingest'),
 				})
+				// Author denylist + existing-content coverage index for foundryd's
+				// weekly content-insights funnel (W1-07 PR 6) — M2M poll, HMAC-guarded
+				// same as fronts/schedule below, sibling of insights-ingest.
+				injectRoute({
+					pattern: `${base}/api/content/insights-inputs`,
+					entrypoint: resolveEntrypoint('../ui/api/content/insights-inputs'),
+				})
 				// Fronts publish path (additive, flag-gated) — M2M siblings of the
 				// foundry-callback / insights-ingest routes. HMAC-guarded.
 				injectRoute({

package/src/providers/types.ts

@@ -402,9 +402,59 @@ export interface FoundryDispatchResult {
 	/** Return source evidence; the CMS owns its atomic capture with the token. */
 	podcastSource?: { url: string; kind: 'https' }
 }
+/**
+ * The Go publish state of one media item as the host reads it from its own
+ * receipts (W1-08b): the state bucket the schedule badge renders plus what
+ * the badge shows on hover. Every field but `state` is optional so a host
+ * that still answers `{ state }` keeps working; `state` is one of
+ * `goPublishStateValues` for a Go-plane host and free text otherwise.
+ */
+export const goPublishStateValues = [
+	'pending',
+	'captured',
+	'processing',
+	'media_ready',
+	'publishing',
+	'published',
+	'late',
+	'failed',
+] as const
+export type GoPublishState = (typeof goPublishStateValues)[number]
+
+export interface FoundryJobStatus {
+	state: GoPublishState | (string & {})
+	kind?: 'video' | 'podcast'
+	contentId?: string
+	contentStatus?: string
+	/** The id callbacks arrive under; null before the source is captured. */
+	correlationId?: string | null
+	/** The host's raw processing state (video_content.processing_state), when it has one. */
+	processingState?: string | null
+	/** True when the media the site serves exists (HLS ready / audio present). */
+	mediaReady?: boolean
+	/** Latest production or publish receipt kind, e.g. `hls.ready`, `publish:live`. */
+	eventKind?: string | null
+	/** Unix seconds of that latest receipt. */
+	receiptAt?: number | null
+	publishStatus?: 'queued' | 'publishing' | 'live' | 'late' | 'failed' | null
+	/** Why the run is blocked (a production error, the last publish error). */
+	blockedReason?: string | null
+	placement?: {
+		storageClass: 'public' | 'private'
+		verified: boolean
+		verifiedAt: number
+	} | null
+}
+
 export interface FoundryDispatch {
 	dispatchVideo(jobSpec: FoundryJobSpec): Promise<FoundryDispatchResult>
-	getJob(correlationId: string): Promise<{ state: string } | null>
+	/**
+	 * Read a media item's processing / Go publish state. `reference` is the
+	 * production correlation id the host handed back from dispatchVideo, or
+	 * a content id (video or podcast) so the schedule views can ask per row.
+	 * Null when the host knows nothing about the reference.
+	 */
+	getJob(reference: string): Promise<FoundryJobStatus | null>
 }
 
 export type MediaSourceKind = 'video' | 'podcast'

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-insights.ts

@@ -13,6 +13,10 @@ import { InsightDismissalReasonCodeSchema } from '../schema/types.js'
 import type { CmsRouteConfig } from './config.js'
 import { resolveConfig } from './config.js'
 import { json, type RouteContext } from './context.js'
+import {
+	resolveFoundryHmacSecret as resolveFoundryHmacSecretForInputs,
+	verifyFoundrySignedRequest,
+} from './fronts-publish.js'
 
 const DismissSchema = z
 	.object({
@@ -72,8 +76,32 @@ export interface ContentInsightsRouteHandlers {
 	undismiss(ctx: RouteContext): Promise<Response>
 	/** POST /content/insights-ingest — HMAC machine ingest (replay-safe replace). */
 	ingest(ctx: RouteContext): Promise<Response>
+	/**
+	 * GET /content/insights-inputs?site=<id> — the funnel's author denylist +
+	 * existing-content coverage index for this site, read by foundryd's
+	 * sitebrain.insights.run schedule (W1-07 PR 6). Same M2M signing family as
+	 * fronts/schedule (X-Foundry-Timestamp + X-Foundry-Signature over the raw
+	 * query string, verified against FOUNDRY_HMAC_SECRET) -- a sibling poll,
+	 * not a new auth scheme.
+	 */
+	insightsInputs(ctx: RouteContext): Promise<Response>
 }
 
+/** authors row shape this route returns: just enough for the author denylist,
+ * never email/bio/social -- the funnel matches on name/slug only. */
+const AUTHORS_QUERY = 'SELECT name, slug FROM authors ORDER BY name LIMIT 1000'
+
+/**
+ * Existing-content index for lexical coverage: every content item an editor
+ * could currently be working on or has already shipped, so the funnel can
+ * skip a candidate that duplicates it. status/deleted_at match the-foundry's
+ * own SiteContentItemSchema (content-insights/ledger.ts, read-only) exactly,
+ * so this row shape ports verbatim.
+ */
+const EXISTING_CONTENT_QUERY = `SELECT title, slug FROM content_items
+	WHERE status IN ('published', 'draft', 'scheduled', 'review') AND deleted_at IS NULL
+	LIMIT 5000`
+
 export function createContentInsightsRoutes(
 	config: ContentInsightsRouteConfig,
 ): ContentInsightsRouteHandlers {
@@ -181,5 +209,38 @@ export function createContentInsightsRoutes(
 				throw error
 			}
 		},
+
+		// HMAC-guarded machine poll -- NOT behind requirePublisher, same M2M
+		// family as fronts/schedule (timestamp-bound signature over the query
+		// string; a GET has no body to bind freshness to instead).
+		async insightsInputs(ctx) {
+			const hmacSecret = await resolveFoundryHmacSecretForInputs(ctx.env)
+			if (!hmacSecret) return json({ error: 'FOUNDRY_HMAC_SECRET is not configured' }, 500)
+
+			const url = new URL(ctx.request.url)
+			const denied = await verifyFoundrySignedRequest(
+				ctx.request,
+				hmacSecret,
+				url.search,
+				'content/insights-inputs',
+			)
+			if (denied) return denied
+
+			const requestedSite = url.searchParams.get('site')
+			const authorsResult = await ctx.db.prepare(AUTHORS_QUERY).all<{
+				name: string
+				slug: string
+			}>()
+			const existingResult = await ctx.db.prepare(EXISTING_CONTENT_QUERY).all<{
+				title: string
+				slug: string
+			}>()
+			return json({
+				ok: true,
+				site: requestedSite ?? siteId,
+				authors: authorsResult.results ?? [],
+				existing: existingResult.results ?? [],
+			})
+		},
 	}
 }

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

@@ -44,7 +44,12 @@ import { json, type RouteContext } from './context.js'
  * (test injection / per-Worker secret) or a Secrets Store binding `{ get() }`.
  * Returns null → the route answers 500 "not configured".
  */
-async function resolveFoundryHmacSecret(
+// Exported (W1-07 PR: content/insights-inputs) so a sibling M2M route can
+// reuse the SAME timestamp+signature verification without duplicating it --
+// content-insights.ts's insightsInputs handler is a GET poll exactly like
+// `schedule` below, and belongs on the same FOUNDRY_HMAC_SECRET/verification
+// family rather than inventing a second one.
+export async function resolveFoundryHmacSecret(
 	env: Record<string, unknown> | undefined,
 ): Promise<string | null> {
 	const raw = env?.FOUNDRY_HMAC_SECRET
@@ -78,7 +83,7 @@ function parseTimestampSeconds(raw: string): number | null {
  * = HMAC over `${timestamp}\n${payload}`. Returns null when authentic, or a 401
  * Response (with a loud warn log) to short-circuit the handler.
  */
-async function verifyFoundrySignedRequest(
+export async function verifyFoundrySignedRequest(
 	request: Request,
 	secret: string,
 	payload: string,
@@ -199,6 +204,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/api/content/insights-inputs.ts

@@ -0,0 +1,26 @@
+// src/ui/api/content/insights-inputs.ts
+// GET /admin/api/content/insights-inputs?site=<id> — the funnel's author
+// denylist + existing-content coverage index. Machine-to-machine poll (same
+// X-Foundry-Timestamp + X-Foundry-Signature family as fronts/schedule) for
+// foundryd's sitebrain.insights.run schedule (W1-07 PR 6). NOT behind
+// requirePublisher. Sibling of insights-ingest under /content/.
+import type { APIContext } from 'astro'
+import { createContentInsightsRoutes } from '../../../routes/content-insights.js'
+import type { RouteContext } from '../../../routes/context.js'
+import { buildSiteAuthz } from '../_authz.js'
+
+function toCtx(c: APIContext): RouteContext {
+	const env = (c.locals as { cmsEnv?: Record<string, unknown> }).cmsEnv ?? {}
+	return { request: c.request, params: {}, db: env.SITE_DB as RouteContext['db'], env }
+}
+
+function siteId(c: APIContext): string {
+	const env = (c.locals as { cmsEnv?: Record<string, unknown> }).cmsEnv ?? {}
+	return (env.ACTIVE_WORKSPACE_ID as string | undefined) ?? 'default'
+}
+
+export const GET = (c: APIContext) =>
+	createContentInsightsRoutes({
+		authz: buildSiteAuthz(c),
+		activeWorkspaceId: siteId(c),
+	}).insightsInputs(toCtx(c))

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') }
+}