@prenta/admin 1.14.0 → 1.15.0

package/src/lib/seo-service.ts

@@ -828,6 +828,295 @@ export async function sendTestDigest(): Promise<{ ok: boolean; to?: string; erro
   return { ok: true, to: res.data?.to }
 }
 
+// ─── SEO Autopilot ───────────────────────────────────────────────────
+// Mirrors `packages/cms-core/src/seo/autopilot-policy.ts` (`SeoAutopilotPolicy`,
+// `AutopilotRunSummary`) and the `/seo/autopilot/*` routes. The server is the
+// contract; keep these shapes in lock-step with it.
+
+export type SeoAutopilotIssueType =
+  | 'missing-meta-title'
+  | 'meta-title-length'
+  | 'duplicate-meta-title'
+  | 'missing-meta-description'
+  | 'meta-description-length'
+  | 'duplicate-meta-description'
+  | 'missing-canonical'
+  | 'accidental-noindex'
+  | 'missing-structured-data'
+  | 'redirect'
+
+export const SEO_AUTOPILOT_ISSUE_TYPES: readonly SeoAutopilotIssueType[] = [
+  'missing-meta-title',
+  'meta-title-length',
+  'duplicate-meta-title',
+  'missing-meta-description',
+  'meta-description-length',
+  'duplicate-meta-description',
+  'missing-canonical',
+  'accidental-noindex',
+  'missing-structured-data',
+  'redirect',
+]
+
+export type SeoAutopilotPauseReason = 'outcome_regression' | 'owner_unavailable' | 'manual'
+
+/**
+ * Run-level stop reasons the engine reports. `already_running` is
+ * informational (another tick held the run lease; nothing was written); the
+ * rest are warnings. The engine never stores raw error messages; a throwing
+ * phase is reported as the coded `apply_failed` / `run_failed`.
+ */
+export type SeoAutopilotHaltReason =
+  | 'disabled'
+  | 'paused'
+  | 'owner_unavailable'
+  | 'already_running'
+  | 'verify_failures'
+  | 'budget_exhausted'
+  | 'ledger_write_failed'
+  | 'apply_failed'
+  | 'run_failed'
+
+export interface SeoAutopilotRunSummary {
+  startedAt: string
+  durationMs: number
+  applied: number
+  verifyFailed: number
+  /** Outcome-watch reverts this tick. */
+  reverted: number
+  /** Gate reason → count (`policy_disabled`, `cap_per_run`, `brand_below_threshold`, …). */
+  gated: Record<string, number>
+  /**
+   * Non-applied apply statuses plus run-level counters: `error`,
+   * `gate_mismatch`, `after_unreadable`, `outcome_watch_error`,
+   * `outcome_revert_error`, `budget_exhausted`.
+   */
+  applyOutcomes: Record<string, number>
+  generated: { generated: number; skipped: number; failed: number; haltedReason: string | null }
+  halted: boolean
+  /** A {@link SeoAutopilotHaltReason}; unknown strings come from a newer core and are shown verbatim. */
+  haltedReason: string | null
+}
+
+export interface SeoAutopilotOutcomeWatch {
+  enabled: boolean
+  days: number
+  dropRatio: number
+  minPriorClicks: number
+}
+
+export interface SeoAutopilotGovernance {
+  /** Settings → AI "Requires approval" on the issue-fix feature vetoes every metadata type. */
+  issueFixApprovalRequired: boolean
+  /** Same veto for 404-recovery redirects. */
+  redirectApprovalRequired: boolean
+}
+
+export interface SeoAutopilotSettings {
+  enabled: boolean
+  enabledById: string | null
+  pausedAt: string | null
+  pausedReason: SeoAutopilotPauseReason | null
+  types: Partial<Record<SeoAutopilotIssueType, boolean>>
+  pausedTypes: Partial<Record<SeoAutopilotIssueType, string>>
+  minBrandAlignment: number
+  redirectMinConfidence: number
+  maxPerRun: number
+  maxPerDay: number
+  verifyFailuresPerRun: number
+  outcomeWatch: SeoAutopilotOutcomeWatch
+  lastRunAt: string | null
+  lastRun: SeoAutopilotRunSummary | null
+  governance: SeoAutopilotGovernance
+}
+
+/** Server-side ranges (`AUTOPILOT_LIMITS`) — mirrored so the card clamps before it PUTs. */
+export const SEO_AUTOPILOT_LIMITS = {
+  maxPerRun: { min: 1, max: 25 },
+  maxPerDay: { min: 1, max: 100 },
+  verifyFailuresPerRun: { min: 1, max: 10 },
+  minBrandAlignment: { min: 0, max: 100 },
+  redirectMinConfidence: { min: 50, max: 100 },
+  outcomeDays: { min: 7, max: 28 },
+  /** Whole percentages; the API takes a 0.2–0.8 ratio. */
+  dropPercent: { min: 20, max: 80 },
+  minPriorClicks: { min: 0, max: 100_000 },
+} as const
+
+/**
+ * A sparse PUT body: only the keys sent are written. `outcomeWatch` is itself
+ * partial. `resume` clears the engine-level pause; `resumeTypes` clears
+ * per-type pauses. Owner and pause state are never accepted from the client.
+ */
+export type SeoAutopilotSettingsPatch = Partial<
+  Pick<
+    SeoAutopilotSettings,
+    | 'enabled'
+    | 'types'
+    | 'minBrandAlignment'
+    | 'redirectMinConfidence'
+    | 'maxPerRun'
+    | 'maxPerDay'
+    | 'verifyFailuresPerRun'
+  >
+> & {
+  outcomeWatch?: Partial<SeoAutopilotOutcomeWatch>
+  resume?: boolean
+  resumeTypes?: SeoAutopilotIssueType[]
+}
+
+function isRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === 'object' && v !== null && !Array.isArray(v)
+}
+
+/**
+ * Validate the settings payload before handing it to the card: an unexpected
+ * body must render the error state, not crash on `settings.types[...]`.
+ * `governance` is normalised defensively (missing → no veto).
+ */
+function normalizeAutopilotSettings(raw: unknown): SeoAutopilotSettings | null {
+  if (!isRecord(raw)) return null
+  if (typeof raw.enabled !== 'boolean' || !isRecord(raw.types) || !isRecord(raw.outcomeWatch)) {
+    return null
+  }
+  const d = raw as unknown as SeoAutopilotSettings
+  const gov = isRecord(raw.governance) ? raw.governance : {}
+  return {
+    ...d,
+    pausedTypes: isRecord(raw.pausedTypes) ? d.pausedTypes : {},
+    lastRunAt: typeof raw.lastRunAt === 'string' ? raw.lastRunAt : null,
+    lastRun: isRecord(raw.lastRun) ? d.lastRun : null,
+    governance: {
+      issueFixApprovalRequired: gov.issueFixApprovalRequired === true,
+      redirectApprovalRequired: gov.redirectApprovalRequired === true,
+    },
+  }
+}
+
+export async function fetchAutopilotSettings(): Promise<
+  { settings: SeoAutopilotSettings } | { settings: null; error: string }
+> {
+  const res = await cmsApi<unknown>('/seo/autopilot/settings')
+  if (res.error) return { settings: null, error: res.error }
+  const settings = normalizeAutopilotSettings(res.data)
+  if (!settings) return { settings: null, error: 'Unexpected autopilot settings response' }
+  return { settings }
+}
+
+export async function updateAutopilotSettings(
+  patch: SeoAutopilotSettingsPatch,
+): Promise<{ ok: boolean; error?: string; settings?: SeoAutopilotSettings }> {
+  const res = await cmsApi<unknown>('/seo/autopilot/settings', {
+    method: 'PUT',
+    body: JSON.stringify(patch),
+  })
+  if (res.error) return { ok: false, error: res.error }
+  return { ok: true, settings: normalizeAutopilotSettings(res.data) ?? undefined }
+}
+
+export async function runAutopilotNow(): Promise<{
+  ok: boolean
+  error?: string
+  summary?: SeoAutopilotRunSummary
+}> {
+  const res = await cmsApi<SeoAutopilotRunSummary>('/seo/autopilot/run', {
+    method: 'POST',
+    body: '{}',
+  })
+  if (res.error) return { ok: false, error: res.error }
+  return { ok: true, summary: res.data }
+}
+
+export type SeoAutoApplyStatus = 'applied' | 'verify_failed' | 'reverted' | 'outcome_reverted'
+export type SeoAutoApplyOutcome = 'pending' | 'held' | 'regressed' | 'insufficient_data' | 'skipped'
+
+export interface SeoAutoApplyRow {
+  id: string
+  kind: 'issue-fix' | 'redirect'
+  issueType: string
+  entityId: string | null
+  /** Collection slug of the touched document; `null` for redirects. */
+  collection: string | null
+  entityTitle: string | null
+  entityUrl: string | null
+  path: string | null
+  before: Record<string, unknown> | null
+  after: Record<string, unknown>
+  gate: {
+    source: string
+    brandAlignment: number | null
+    confidence: number | null
+    checks: Record<string, boolean>
+  }
+  status: SeoAutoApplyStatus
+  outcome: SeoAutoApplyOutcome
+  outcomeMetrics: Record<string, unknown> | null
+  appliedAt: string
+  revertedAt: string | null
+  revertReason: string | null
+}
+
+export interface SeoAutoApplyList {
+  docs: SeoAutoApplyRow[]
+  total: number
+  page: number
+  pageSize: number
+  /** True for ADMIN callers — the only role the revert route accepts. */
+  canRevert: boolean
+}
+
+export async function fetchAutopilotApplied(params: {
+  page: number
+  pageSize: number
+  status?: SeoAutoApplyStatus
+  outcome?: SeoAutoApplyOutcome
+}): Promise<SeoAutoApplyList> {
+  const search = new URLSearchParams({
+    page: String(params.page),
+    pageSize: String(params.pageSize),
+  })
+  if (params.status) search.set('status', params.status)
+  if (params.outcome) search.set('outcome', params.outcome)
+  const res = await cmsApi<SeoAutoApplyList>(`/seo/autopilot/applied?${search.toString()}`)
+  throwIfError(res)
+  return (
+    res.data ?? {
+      docs: [],
+      total: 0,
+      page: params.page,
+      pageSize: params.pageSize,
+      canRevert: false,
+    }
+  )
+}
+
+/**
+ * Revert one ledgered change. A 409 (`code: 'conflict'`) means a human edited
+ * the same fields since autopilot wrote them; the server lists them in
+ * `fields` and `force: true` overrides.
+ */
+export async function revertAutopilotChange(
+  id: string,
+  force = false,
+): Promise<{ ok: true } | { ok: false; error: string; conflictFields?: string[] }> {
+  const res = await cmsApi<unknown>(`/seo/autopilot/applied/${encodeURIComponent(id)}/revert`, {
+    method: 'POST',
+    body: JSON.stringify({ force }),
+  })
+  if (res.error) {
+    if (res.code !== 'conflict') return { ok: false, error: res.error }
+    const fields = isRecord(res.errorBody) ? res.errorBody.fields : undefined
+    return {
+      ok: false,
+      error: res.error,
+      conflictFields: Array.isArray(fields)
+        ? fields.filter((f): f is string => typeof f === 'string')
+        : [],
+    }
+  }
+  return { ok: true }
+}
+
 // ─── AI crawler activity ─────────────────────────────────────────────
 
 export interface AiCrawlerRow {
@@ -1057,7 +1346,17 @@ export async function fetchRedirectSuggestions(): Promise<RedirectSuggestion[]>
 
 export interface RedirectRecoverySettings {
   aiRerank: boolean
+  /**
+   * @deprecated Auto-apply moved to the SEO Autopilot engine (`types.redirect`
+   * on `SeoAutopilotSettings`, managed from the Settings → SEO "SEO Autopilot"
+   * card). The server still emits this for one release; nothing in the admin
+   * reads it. Remove together with the server field.
+   */
   autoApply: boolean
+  /**
+   * @deprecated Superseded by `SeoAutopilotSettings.redirectMinConfidence`,
+   * managed from the "SEO Autopilot" card. Server-emitted for one release only.
+   */
   autoApplyMinConfidence: number
 }
 
@@ -1079,10 +1378,16 @@ export async function saveRedirectRecoverySettings(
 
 export async function generate404RecoverySuggestions(): Promise<{
   error?: string
+  /**
+   * @deprecated Always `0`: generation no longer applies redirects. Auto-apply
+   * is the SEO Autopilot engine's job (Settings → SEO "SEO Autopilot" card);
+   * the server keeps the field for one release. Drop with the server field.
+   */
   autoApplied?: number
   /**
-   * Set when AI governance vetoed a requested auto-apply (eligible plans were
-   * stored as pending suggestions instead). Human-readable reason to surface.
+   * @deprecated Always `undefined` (server sends `null`): the governance veto
+   * now happens inside the autopilot gate, not at generation time. Kept for
+   * one release alongside `autoApplied`.
    */
   governanceBlocked?: string
 }> {
@@ -1367,6 +1672,15 @@ export interface SeoProposalsPayload {
   counts: { issueFixes: number; redirects: number; stale: number; eligibleForGeneration: number }
   /** `allowBulkApply` per feature, so the UI can disable batch approve up front. */
   governance: { issueFixBulk: boolean; redirectBulk: boolean }
+  /** Autopilot status strip for the proposals inbox (mirror of core's payload). */
+  autopilot: {
+    enabled: boolean
+    /** Set only while the engine is actually paused. */
+    pausedReason: string | null
+    lastRunAt: string | null
+    /** Live autopilot changes (`status = applied`) from the last 7 days. */
+    appliedLast7d: number
+  }
 }
 
 export interface SeoProposalGenerateResult {
@@ -1410,16 +1724,30 @@ export interface SeoProposalBulkApplyResult {
   pending: number
 }
 
+/** What the chip shows when the server says nothing about autopilot. */
+const AUTOPILOT_OFF: SeoProposalsPayload['autopilot'] = {
+  enabled: false,
+  pausedReason: null,
+  lastRunAt: null,
+  appliedLast7d: 0,
+}
+
 export async function fetchSeoProposals(): Promise<SeoProposalsPayload> {
-  const res = await cmsApi<SeoProposalsPayload>('/seo/proposals')
+  // `autopilot` is optional on the wire: a `@prenta/core` deployed before
+  // autopilot shipped omits it, and the tab must still render.
+  const res = await cmsApi<Omit<SeoProposalsPayload, 'autopilot'> & Partial<SeoProposalsPayload>>(
+    '/seo/proposals',
+  )
   throwIfError(res)
-  return (
-    res.data ?? {
+  if (!res.data) {
+    return {
       proposals: [],
       counts: { issueFixes: 0, redirects: 0, stale: 0, eligibleForGeneration: 0 },
       governance: { issueFixBulk: false, redirectBulk: false },
+      autopilot: AUTOPILOT_OFF,
     }
-  )
+  }
+  return { ...res.data, autopilot: res.data.autopilot ?? AUTOPILOT_OFF }
 }
 
 export async function generateSeoProposals(): Promise<{

package/src/views/SEO.tsx

@@ -284,7 +284,7 @@ export function SEO({ onNavigate, initialTab = 'overview' }: SEOProps) {
               {activeTab === 'technical' && <TechnicalTab />}
             </Tabs.Content>
             <Tabs.Content value="redirects" tabIndex={-1}>
-              {activeTab === 'redirects' && <RedirectsTab />}
+              {activeTab === 'redirects' && <RedirectsTab onNavigate={onNavigate} />}
             </Tabs.Content>
             <Tabs.Content value="audit" tabIndex={-1}>
               {activeTab === 'audit' && (