@peanut-admin/admin 0.1.0-alpha.2

package/notification-sms/src/runtime.ts

@@ -0,0 +1,143 @@
+import { defineAdminModule } from '@peanut-admin/admin/core'
+import { inject, reactive } from 'vue'
+import type { AdminModuleContribution } from '@peanut-admin/admin/core'
+import type { InjectionKey } from 'vue'
+
+import { parseBulkResult, parseNotificationList, parseNotificationResponse } from './contracts'
+import type {
+  NotificationBulkAction,
+  NotificationFilter,
+  NotificationMessage,
+  NotificationTransport,
+  NotificationTransportResult,
+} from './contracts'
+
+export const NOTIFICATION_SMS_MODULE_KEY = 'peanut.notification-sms' as const
+export const NOTIFICATION_SMS_ROUTE_NAME = 'peanut.notification-sms.inbox' as const
+export const NOTIFICATION_SMS_ROUTE_PATH = '/app/notifications' as const
+export const NOTIFICATION_SMS_READ_PERMISSION = 'peanut.notification-sms.read' as const
+export const NOTIFICATION_SMS_MANAGE_PERMISSION = 'peanut.notification-sms.manage' as const
+export const NOTIFICATION_SMS_STORE_KEY = 'peanut.notification-sms.runtime' as const
+
+export interface NotificationError { readonly message: string; readonly requestId: string | null; readonly status: number | null }
+export interface NotificationState {
+  items: NotificationMessage[]
+  status: NotificationFilter
+  page: number
+  pageSize: number
+  total: number
+  selected: Set<string>
+  loading: boolean
+  mutating: boolean
+  error: NotificationError | null
+}
+export interface NotificationRuntime {
+  readonly state: NotificationState
+  load: () => Promise<void>
+  setStatus: (status: NotificationFilter) => Promise<void>
+  toggle: (messageKey: string) => void
+  markRead: (message: NotificationMessage) => Promise<void>
+  bulk: (action: NotificationBulkAction) => Promise<void>
+  dispose: () => void
+}
+export interface NotificationRuntimeOptions {
+  readonly transport: NotificationTransport
+  readonly canRead: () => boolean
+}
+
+const failure = (result: NotificationTransportResult): NotificationError => {
+  const body = typeof result.body === 'object' && result.body !== null && !Array.isArray(result.body)
+    ? result.body as Record<string, unknown> : {}
+  const requestId = body.request_id ?? result.headers.get('X-Request-Id')
+  return {
+    message: typeof body.detail === 'string' && body.detail !== '' ? body.detail : `Notification request failed (${result.status}).`,
+    requestId: typeof requestId === 'string' && requestId !== '' ? requestId : null,
+    status: result.status,
+  }
+}
+
+export const createNotificationRuntime = (options: NotificationRuntimeOptions): NotificationRuntime => {
+  const state = reactive<NotificationState>({
+    items: [], status: 'all', page: 1, pageSize: 20, total: 0, selected: new Set(),
+    loading: false, mutating: false, error: null,
+  })
+  const controllers = new Set<AbortController>()
+  let generation = 0
+  const run = async <T>(operation: (signal: AbortSignal) => Promise<T>): Promise<T> => {
+    const controller = new AbortController(); controllers.add(controller)
+    try { return await operation(controller.signal) } finally { controllers.delete(controller) }
+  }
+  const load = async (): Promise<void> => {
+    const current = ++generation; state.loading = true; state.error = null
+    try {
+      if (!options.canRead()) throw new Error('NOTIFICATION_PERMISSION_DENIED')
+      const result = await run(signal => options.transport.list(state.status, state.page, state.pageSize, signal))
+      if (current !== generation) return
+      if (result.status !== 200) { state.error = failure(result); return }
+      const list = parseNotificationList(result.body)
+      state.items = [...list.items]; state.page = list.page; state.pageSize = list.pageSize; state.total = list.total
+      state.selected.clear()
+    } catch {
+      if (current === generation) state.error = { message: 'The notification service could not be reached.', requestId: null, status: null }
+    } finally { if (current === generation) state.loading = false }
+  }
+  const mutate = async (operation: (signal: AbortSignal) => Promise<NotificationTransportResult>, parser: (body: unknown) => unknown): Promise<void> => {
+    if (state.mutating || !options.canRead()) return
+    const current = generation
+    state.mutating = true; state.error = null
+    try {
+      const result = await run(operation)
+      if (current !== generation) return
+      if (result.status !== 200) { state.error = failure(result); return }
+      parser(result.body)
+      if (current !== generation) return
+      state.mutating = false
+      await load()
+    } catch {
+      if (current === generation) state.error = { message: 'The notification action could not be completed.', requestId: null, status: null }
+    } finally { if (current === generation) state.mutating = false }
+  }
+  return {
+    state,
+    load,
+    async setStatus(status) { state.status = status; state.page = 1; await load() },
+    toggle(messageKey) {
+      if (state.selected.has(messageKey)) state.selected.delete(messageKey)
+      else if (state.selected.size < 100) state.selected.add(messageKey)
+    },
+    markRead(message) {
+      if (message.status !== 'unread') return Promise.resolve()
+      return mutate(signal => options.transport.markRead(message.messageKey, message.revision, signal), parseNotificationResponse)
+    },
+    bulk(action) {
+      const keys = [...state.selected]
+      if (keys.length === 0) return Promise.resolve()
+      return mutate(signal => options.transport.bulk(keys, action, signal), parseBulkResult)
+    },
+    dispose() {
+      generation += 1
+      for (const controller of controllers) controller.abort()
+      controllers.clear()
+      state.items = []; state.status = 'all'; state.page = 1; state.pageSize = 20; state.total = 0
+      state.selected.clear(); state.loading = false; state.mutating = false; state.error = null
+    },
+  }
+}
+
+export const notificationRuntimeKey: InjectionKey<NotificationRuntime> = Symbol(NOTIFICATION_SMS_STORE_KEY)
+export const useNotificationRuntime = (): NotificationRuntime => {
+  const runtime = inject(notificationRuntimeKey)
+  if (runtime === undefined) throw new Error('NOTIFICATION_RUNTIME_MISSING')
+  return runtime
+}
+export const createNotificationModuleContribution = (runtime: NotificationRuntime): AdminModuleContribution => defineAdminModule({
+  key: NOTIFICATION_SMS_MODULE_KEY,
+  routes: [{
+    name: NOTIFICATION_SMS_ROUTE_NAME,
+    path: NOTIFICATION_SMS_ROUTE_PATH,
+    component: async () => ({ default: (await import('./NotificationInboxPage.vue')).default }),
+    access: { moduleKey: NOTIFICATION_SMS_MODULE_KEY, permissionKeys: [NOTIFICATION_SMS_READ_PERMISSION] },
+  }],
+  disposeOnTenantChange: true,
+  stores: [{ key: NOTIFICATION_SMS_STORE_KEY, dispose: runtime.dispose }],
+})

package/ops-console/src/OpsConsolePage.vue

@@ -0,0 +1,337 @@
+<script setup lang="ts">
+import { EmptyState, ForbiddenState, ModuleUnavailableState, PageContent, PageHeader, SessionExpiredState } from '@peanut-admin/admin/shell'
+import { ElButton, ElDatePicker, ElInput, ElTabPane, ElTabs } from 'element-plus'
+import { computed, onMounted, ref } from 'vue'
+import { LOG_SEVERITIES } from './contracts'
+import { useOpsConsoleRuntime } from './runtime'
+
+const runtime = useOpsConsoleRuntime(); const state = runtime.state
+const providerKey = ref(runtime.providers[0]?.key ?? '')
+const backupReferenceKey = ref(''); const restoreTargetKey = ref('')
+const reasonKey = ref(runtime.maintenanceReasons[0] ?? ''); const startsAt = ref(''); const endsAt = ref('')
+const draftLogSource = ref(state.logSource); const draftLogSeverity = ref(state.logSeverity)
+const targets = computed(() => runtime.providers.find(provider => provider.key === providerKey.value)?.restoreTargets ?? [])
+const activeMaintenance = computed(() => state.maintenance !== null && state.maintenance.state !== 'closed')
+const chooseProvider = (): void => { restoreTargetKey.value = targets.value[0] ?? '' }
+const schedule = (): Promise<void> => runtime.scheduleMaintenance({ reasonKey: reasonKey.value, startsAt: startsAt.value, endsAt: endsAt.value })
+const applyLogFilter = (): Promise<void> => runtime.setLogFilter(draftLogSource.value, draftLogSeverity.value)
+
+onMounted(async () => {
+  chooseProvider(); await runtime.load()
+  if (runtime.canReadLogs() && runtime.logSources.length > 0) await runtime.loadLogs()
+})
+</script>
+
+<template>
+  <PageContent class="ops-console-page">
+    <PageHeader>
+      Operations
+      <template #actions>
+        <ElButton
+          :loading="state.loading"
+          :disabled="state.mutating"
+          @click="runtime.load"
+        >
+          Reload
+        </ElButton>
+      </template>
+    </PageHeader>
+
+    <SessionExpiredState
+      v-if="state.error?.status === 401"
+      :message="state.error.message"
+    />
+    <ForbiddenState
+      v-else-if="state.error?.status === 403 && state.overview === null"
+      :message="state.error.message"
+    />
+    <ModuleUnavailableState
+      v-else-if="state.error?.status === 503 && state.overview === null"
+      :message="state.error.message"
+      @action="runtime.load"
+    />
+    <section
+      v-else-if="state.error && state.overview === null"
+      role="alert"
+      class="ops-state"
+    >
+      <h2>Unable to load operations</h2><p>{{ state.error.message }}</p><p v-if="state.error.requestId">
+        Request ID: {{ state.error.requestId }}
+      </p>
+    </section>
+    <div
+      v-else-if="state.loading && state.overview === null"
+      class="ops-state"
+      role="status"
+    >
+      Loading operations...
+    </div>
+
+    <ElTabs
+      v-else-if="state.overview !== null"
+      class="ops-tabs"
+    >
+      <ElTabPane label="Overview">
+        <section
+          class="ops-section"
+          aria-labelledby="ops-health-heading"
+        >
+          <h2 id="ops-health-heading">
+            Runtime evidence
+          </h2>
+          <dl class="ops-facts">
+            <div><dt>Health</dt><dd>{{ state.overview.health.status }}</dd></div>
+            <div>
+              <dt>Commit</dt><dd class="mono">
+                {{ state.overview.version.commit }}
+              </dd>
+            </div>
+            <div>
+              <dt>Tree</dt><dd class="mono">
+                {{ state.overview.version.tree }}
+              </dd>
+            </div>
+            <div><dt>Built</dt><dd>{{ state.overview.version.builtAt }}</dd></div>
+            <div><dt>Migrations</dt><dd>{{ state.overview.migrations.applied }} / {{ state.overview.migrations.target }}</dd></div>
+            <div><dt>Upgrade</dt><dd>{{ state.overview.upgrade.state }} ({{ state.overview.upgrade.code }})</dd></div>
+          </dl>
+          <div class="table-wrap">
+            <table>
+              <thead><tr><th>Check</th><th>Status</th><th>Critical</th><th>Latency</th></tr></thead>
+              <tbody>
+                <tr
+                  v-for="check in state.overview.health.checks"
+                  :key="check.key"
+                >
+                  <td>{{ check.key }}</td><td>{{ check.status }}</td><td>{{ check.critical ? 'yes' : 'no' }}</td><td>{{ check.latencyMs }} ms</td>
+                </tr>
+              </tbody>
+            </table>
+          </div>
+        </section>
+      </ElTabPane>
+
+      <ElTabPane label="Recovery">
+        <section
+          class="ops-section"
+          aria-labelledby="ops-backup-heading"
+        >
+          <h2 id="ops-backup-heading">
+            Backup and restore verification
+          </h2>
+          <div class="ops-controls">
+            <label>Provider<select
+              v-model="providerKey"
+              :disabled="state.mutating"
+              @change="chooseProvider"
+            ><option
+              v-for="provider in runtime.providers"
+              :key="provider.key"
+              :value="provider.key"
+            >{{ provider.key }}</option></select></label>
+            <ElButton
+              type="primary"
+              :disabled="!runtime.canBackup() || state.mutating || !runtime.providers.find(provider => provider.key === providerKey)?.backup"
+              @click="runtime.submitBackup(providerKey)"
+            >
+              Create backup
+            </ElButton>
+          </div>
+          <div class="ops-controls">
+            <label>Backup reference<ElInput
+              v-model="backupReferenceKey"
+              :disabled="state.mutating"
+            /></label>
+            <label>New target<select
+              v-model="restoreTargetKey"
+              :disabled="state.mutating"
+            ><option
+              v-for="target in targets"
+              :key="target"
+              :value="target"
+            >{{ target }}</option></select></label>
+            <ElButton
+              :disabled="!runtime.canRestore() || state.mutating || restoreTargetKey === ''"
+              @click="runtime.submitRestore(providerKey, backupReferenceKey, restoreTargetKey)"
+            >
+              Restore and verify
+            </ElButton>
+          </div>
+          <section
+            v-if="state.error"
+            role="alert"
+            class="inline-error"
+          >
+            <p>{{ state.error.message }}</p><p v-if="state.error.requestId">
+              Request ID: {{ state.error.requestId }}
+            </p>
+          </section>
+          <EmptyState
+            v-if="state.tasks.length === 0"
+            title="No operation tasks"
+            message="No backup or restore-verification tasks were submitted in this session."
+          />
+          <div
+            v-else
+            class="table-wrap"
+          >
+            <table>
+              <thead><tr><th>Type</th><th>Status</th><th>Attempts</th><th>Updated</th><th>Action</th></tr></thead>
+              <tbody>
+                <tr
+                  v-for="task in state.tasks"
+                  :key="task.taskKey"
+                >
+                  <td>{{ task.taskType }}</td><td>{{ task.status }}</td><td>{{ task.attemptCount }} / {{ task.maxAttempts }}</td><td>{{ task.updatedAt }}</td><td>
+                    <ElButton
+                      text
+                      @click="runtime.refreshTask(task)"
+                    >
+                      Refresh
+                    </ElButton>
+                  </td>
+                </tr>
+              </tbody>
+            </table>
+          </div>
+        </section>
+      </ElTabPane>
+
+      <ElTabPane label="Maintenance">
+        <section
+          class="ops-section"
+          aria-labelledby="ops-maintenance-heading"
+        >
+          <h2 id="ops-maintenance-heading">
+            Maintenance window
+          </h2>
+          <dl
+            v-if="state.maintenance"
+            class="ops-facts"
+          >
+            <div><dt>State</dt><dd>{{ state.maintenance.state }}</dd></div><div><dt>Reason</dt><dd>{{ state.maintenance.reasonKey }}</dd></div><div><dt>Starts</dt><dd>{{ state.maintenance.startsAt }}</dd></div><div><dt>Ends</dt><dd>{{ state.maintenance.endsAt }}</dd></div><div><dt>Revision</dt><dd>{{ state.maintenance.revision }}</dd></div>
+          </dl>
+          <div class="ops-controls">
+            <label>Reason<select
+              v-model="reasonKey"
+              :disabled="state.mutating"
+            ><option
+              v-for="reason in runtime.maintenanceReasons"
+              :key="reason"
+              :value="reason"
+            >{{ reason }}</option></select></label>
+            <label>Starts<ElDatePicker
+              v-model="startsAt"
+              type="datetime"
+              value-format="YYYY-MM-DDTHH:mm:ss.SSS[Z]"
+            /></label>
+            <label>Ends<ElDatePicker
+              v-model="endsAt"
+              type="datetime"
+              value-format="YYYY-MM-DDTHH:mm:ss.SSS[Z]"
+            /></label>
+            <ElButton
+              type="primary"
+              :disabled="!runtime.canMaintain() || state.mutating || reasonKey === '' || startsAt === '' || endsAt === ''"
+              @click="schedule"
+            >
+              {{ state.maintenance === null ? 'Schedule' : 'Replace' }}
+            </ElButton>
+            <ElButton
+              :disabled="!runtime.canMaintain() || state.mutating || !activeMaintenance"
+              @click="runtime.closeMaintenance"
+            >
+              Close
+            </ElButton>
+          </div>
+        </section>
+      </ElTabPane>
+
+      <ElTabPane label="Runtime events">
+        <section
+          class="ops-section"
+          aria-labelledby="ops-logs-heading"
+        >
+          <h2 id="ops-logs-heading">
+            Structured runtime events
+          </h2>
+          <ForbiddenState
+            v-if="!runtime.canReadLogs()"
+            message="You do not have permission to read runtime events."
+          />
+          <template v-else>
+            <div class="ops-controls">
+              <label>Source<select
+                v-model="draftLogSource"
+                aria-label="Source"
+              ><option
+                v-for="source in runtime.logSources"
+                :key="source"
+                :value="source"
+              >{{ source }}</option></select></label><label>Severity<select
+                v-model="draftLogSeverity"
+                aria-label="Severity"
+              ><option
+                v-for="severity in LOG_SEVERITIES"
+                :key="severity"
+                :value="severity"
+              >{{ severity }}</option></select></label><ElButton
+                :loading="state.logsLoading"
+                @click="applyLogFilter"
+              >
+                Apply
+              </ElButton>
+            </div>
+            <section
+              v-if="state.logsError"
+              role="alert"
+              class="inline-error"
+            >
+              <p>{{ state.logsError.message }}</p><p v-if="state.logsError.requestId">
+                Request ID: {{ state.logsError.requestId }}
+              </p>
+            </section>
+            <EmptyState
+              v-else-if="state.logs.length === 0 && !state.logsLoading"
+              title="No runtime events"
+              message="No structured events match this filter."
+            />
+            <div
+              v-else
+              class="table-wrap"
+            >
+              <table>
+                <thead><tr><th>Time</th><th>Severity</th><th>Component</th><th>Event</th><th>Occurrences</th></tr></thead><tbody>
+                  <tr
+                    v-for="entry in state.logs"
+                    :key="`${entry.eventKey}-${entry.occurredAt}`"
+                  >
+                    <td>{{ entry.occurredAt }}</td><td>{{ entry.severity }}</td><td>{{ entry.componentKey }}</td><td>{{ entry.message }}</td><td>{{ entry.occurrences }}</td>
+                  </tr>
+                </tbody>
+              </table>
+            </div>
+            <ElButton
+              v-if="state.logNextCursor"
+              :loading="state.logsLoading"
+              @click="runtime.loadLogs(false)"
+            >
+              Load more
+            </ElButton>
+          </template>
+        </section>
+      </ElTabPane>
+    </ElTabs>
+  </PageContent>
+</template>
+
+<style scoped>
+.ops-state, .ops-section { padding: 20px 0; }
+.ops-section h2 { margin: 0 0 16px; font-size: 20px; letter-spacing: 0; }
+.ops-facts { display: grid; grid-template-columns: repeat(auto-fit, minmax(180px, 1fr)); gap: 12px 24px; margin: 0 0 20px; }
+.ops-facts div { min-width: 0; }.ops-facts dt { color: var(--el-text-color-secondary); font-size: 13px; }.ops-facts dd { margin: 4px 0 0; overflow-wrap: anywhere; }
+.ops-controls { display: flex; align-items: end; flex-wrap: wrap; gap: 12px; margin-bottom: 20px; }.ops-controls label { display: grid; min-width: 180px; gap: 6px; font-size: 13px; color: var(--el-text-color-secondary); }.ops-controls select { height: 32px; padding: 0 28px 0 10px; border: 1px solid var(--el-border-color); border-radius: 4px; background: var(--el-bg-color); color: var(--el-text-color-primary); }
+.inline-error { padding: 12px 0; color: var(--el-color-danger); }.inline-error p { margin: 0 0 4px; }
+.table-wrap { width: 100%; overflow-x: auto; margin-bottom: 16px; }table { width: 100%; min-width: 680px; border-collapse: collapse; }th, td { padding: 10px 8px; border-bottom: 1px solid var(--el-border-color); text-align: left; }th { font-size: 13px; color: var(--el-text-color-secondary); }.mono { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; }
+@media (max-width: 640px) { .ops-controls { align-items: stretch; flex-direction: column; }.ops-controls label { width: 100%; }.ops-controls :deep(.el-button) { width: 100%; } }
+</style>

package/ops-console/src/contracts.ts

@@ -0,0 +1,169 @@
+export type HealthStatus = 'healthy' | 'degraded' | 'unhealthy'
+export type UpgradeState = 'configuration_required' | 'blocked' | 'ready' | 'running' | 'succeeded' | 'failed'
+export type OpsTaskStatus = 'queued' | 'running' | 'succeeded' | 'dead' | 'cancelled'
+export type MaintenanceState = 'scheduled' | 'active' | 'closed'
+export const LOG_SEVERITIES = ['info', 'warning', 'error', 'critical'] as const
+export type LogSeverity = typeof LOG_SEVERITIES[number]
+
+export interface HealthCheck { readonly key: string; readonly status: 'up' | 'down'; readonly critical: boolean; readonly latencyMs: number }
+export interface OpsStatus {
+  readonly health: { readonly status: HealthStatus; readonly checks: readonly HealthCheck[] }
+  readonly version: { readonly commit: string; readonly tree: string; readonly releaseKey: string | null; readonly builtAt: string }
+  readonly migrations: { readonly applied: number; readonly target: number; readonly pending: number; readonly inventoryDigest: string; readonly drift: boolean }
+  readonly upgrade: {
+    readonly state: UpgradeState; readonly code: string; readonly sourceCommit: string | null; readonly targetCommit: string | null
+    readonly repositoryClean: boolean; readonly backupVerified: boolean; readonly sourceEvidenceMatches: boolean
+  }
+}
+export interface OpsTask {
+  readonly taskKey: string; readonly taskType: 'ops.backup.create' | 'ops.restore.verify'; readonly status: OpsTaskStatus
+  readonly attemptCount: number; readonly maxAttempts: number; readonly revision: number; readonly lastErrorCode: string | null
+  readonly availableAt: string; readonly createdAt: string; readonly updatedAt: string; readonly completedAt: string | null
+}
+export interface MaintenanceWindow {
+  readonly maintenanceKey: string; readonly state: MaintenanceState; readonly reasonKey: string
+  readonly startsAt: string; readonly endsAt: string; readonly revision: number
+}
+export interface RuntimeLogEntry {
+  readonly eventKey: string; readonly severity: LogSeverity; readonly componentKey: string; readonly message: string
+  readonly occurredAt: string; readonly requestId: string | null; readonly occurrences: number
+}
+export interface RuntimeLogPage { readonly items: readonly RuntimeLogEntry[]; readonly nextCursor: string | null }
+export interface OpsTransportResult { readonly body: unknown; readonly headers: Headers; readonly status: number }
+export interface MaintenanceScheduleInput { readonly reasonKey: string; readonly startsAt: string; readonly endsAt: string }
+export interface OpsConsoleTransport {
+  overview: (signal: AbortSignal) => Promise<OpsTransportResult>
+  submitBackup: (providerKey: string, idempotencyKey: string, signal: AbortSignal) => Promise<OpsTransportResult>
+  submitRestore: (providerKey: string, backupReferenceKey: string, targetKey: string, idempotencyKey: string, signal: AbortSignal) => Promise<OpsTransportResult>
+  task: (taskKey: string, signal: AbortSignal) => Promise<OpsTransportResult>
+  maintenance: (signal: AbortSignal) => Promise<OpsTransportResult>
+  scheduleMaintenance: (input: MaintenanceScheduleInput, expectedRevision: number, idempotencyKey: string, signal: AbortSignal) => Promise<OpsTransportResult>
+  closeMaintenance: (maintenanceKey: string, expectedRevision: number, idempotencyKey: string, signal: AbortSignal) => Promise<OpsTransportResult>
+  logs: (sourceKey: string, severity: LogSeverity, cursor: string | null, pageSize: number, signal: AbortSignal) => Promise<OpsTransportResult>
+}
+
+const invalid = (): never => { throw new Error('OPS_RESPONSE_INVALID') }
+const record = (value: unknown): Record<string, unknown> => {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return invalid()
+  return value as Record<string, unknown>
+}
+const exact = (value: Record<string, unknown>, keys: readonly string[]): void => {
+  const actual = Object.keys(value).sort(); const expected = [...keys].sort()
+  if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) invalid()
+}
+const integer = (value: unknown, minimum = 0): value is number => typeof value === 'number' && Number.isSafeInteger(value) && value >= minimum
+const instant = (value: unknown): value is string => typeof value === 'string'
+  && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(value) && Number.isFinite(Date.parse(value))
+const qualifiedKey = (value: unknown, maximum = 128): value is string => typeof value === 'string' && value.length <= maximum
+  && /^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/.test(value)
+const stableCode = (value: unknown): value is string => typeof value === 'string' && /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/.test(value) && value.length <= 128
+const commit = (value: unknown): value is string => typeof value === 'string' && /^[0-9a-f]{40}$/.test(value)
+const opaque = (value: unknown, prefix: string): value is string => typeof value === 'string'
+  && new RegExp(`^${prefix}[0-9a-f]{32}$`).test(value)
+const safePublicText = (value: unknown): value is string => typeof value === 'string' && value.length >= 1 && value.length <= 240
+  && !/[\u0000-\u001f\u007f]/.test(value)
+  && !/(?:password|passwd|secret|token|credential|authorization)\s*[:=]|(?:mysql|postgres(?:ql)?|redis):\/\/|\b(?:select|insert|update|delete|drop|alter)\s+|(?:^|\s)(?:\/[A-Za-z0-9._-]+){2,}|(?:^|\s)[A-Za-z]:\\|\bstack\s+trace\b|https?:\/\/[^\s/@]+:[^\s/@]+@/i.test(value)
+const envelope = (value: unknown): { data: unknown; requestId: string } => {
+  const body = record(value); exact(body, ['data', 'meta'])
+  const meta = record(body.meta); exact(meta, ['request_id'])
+  if (typeof meta.request_id !== 'string' || meta.request_id.length < 1 || meta.request_id.length > 128) return invalid()
+  return { data: body.data, requestId: meta.request_id }
+}
+
+export const parseOpsStatus = (value: unknown): OpsStatus => {
+  const data = record(envelope(value).data); exact(data, ['health', 'version', 'migrations', 'upgrade'])
+  const health = record(data.health); exact(health, ['status', 'checks'])
+  const version = record(data.version); exact(version, ['commit', 'tree', 'release_key', 'built_at'])
+  const migrations = record(data.migrations); exact(migrations, ['applied', 'target', 'pending', 'inventory_digest', 'drift'])
+  const upgrade = record(data.upgrade); exact(upgrade, ['state', 'code', 'source_commit', 'target_commit', 'repository_clean', 'backup_verified', 'source_evidence_matches'])
+  if (!['healthy', 'degraded', 'unhealthy'].includes(String(health.status)) || !Array.isArray(health.checks) || health.checks.length > 32
+    || !commit(version.commit) || !commit(version.tree) || (version.release_key !== null && !qualifiedKey(version.release_key)) || !instant(version.built_at)
+    || !integer(migrations.applied) || !integer(migrations.target) || !integer(migrations.pending)
+    || migrations.applied + migrations.pending !== migrations.target || typeof migrations.inventory_digest !== 'string' || !/^[0-9a-f]{64}$/.test(migrations.inventory_digest) || typeof migrations.drift !== 'boolean'
+    || !['configuration_required', 'blocked', 'ready', 'running', 'succeeded', 'failed'].includes(String(upgrade.state)) || !stableCode(upgrade.code)
+    || (upgrade.source_commit !== null && !commit(upgrade.source_commit)) || (upgrade.target_commit !== null && !commit(upgrade.target_commit))
+    || typeof upgrade.repository_clean !== 'boolean' || typeof upgrade.backup_verified !== 'boolean' || typeof upgrade.source_evidence_matches !== 'boolean') return invalid()
+  const checks = health.checks.map(item => {
+    const check = record(item); exact(check, ['key', 'status', 'critical', 'latency_ms'])
+    if (!qualifiedKey(check.key, 64) || !['up', 'down'].includes(String(check.status)) || typeof check.critical !== 'boolean'
+      || typeof check.latency_ms !== 'number' || !Number.isFinite(check.latency_ms) || check.latency_ms < 0 || check.latency_ms > 60000) return invalid()
+    return { key: check.key, status: check.status as 'up' | 'down', critical: check.critical, latencyMs: check.latency_ms }
+  })
+  const criticalCheckDown = checks.some(check => check.critical && check.status === 'down')
+  if ((health.status === 'healthy' && (criticalCheckDown || migrations.drift || migrations.pending > 0))
+    || (upgrade.state === 'succeeded' && (!upgrade.repository_clean || !upgrade.backup_verified || !upgrade.source_evidence_matches))) return invalid()
+  return {
+    health: { status: health.status as HealthStatus, checks },
+    version: { commit: version.commit, tree: version.tree, releaseKey: version.release_key as string | null, builtAt: version.built_at },
+    migrations: { applied: migrations.applied, target: migrations.target, pending: migrations.pending, inventoryDigest: migrations.inventory_digest, drift: migrations.drift },
+    upgrade: { state: upgrade.state as UpgradeState, code: upgrade.code, sourceCommit: upgrade.source_commit as string | null, targetCommit: upgrade.target_commit as string | null, repositoryClean: upgrade.repository_clean, backupVerified: upgrade.backup_verified, sourceEvidenceMatches: upgrade.source_evidence_matches },
+  }
+}
+
+export const parseOpsTask = (value: unknown): OpsTask => {
+  const item = record(envelope(value).data)
+  exact(item, ['task_key', 'task_type', 'status', 'attempt_count', 'max_attempts', 'revision', 'last_error_code', 'available_at', 'created_at', 'updated_at', 'completed_at'])
+  const terminal = ['succeeded', 'dead', 'cancelled'].includes(String(item.status))
+  if (!opaque(item.task_key, 'job_') || !['ops.backup.create', 'ops.restore.verify'].includes(String(item.task_type))
+    || !['queued', 'running', 'succeeded', 'dead', 'cancelled'].includes(String(item.status))
+    || !integer(item.attempt_count) || !integer(item.max_attempts, 1) || item.max_attempts > 10 || item.attempt_count > item.max_attempts
+    || !integer(item.revision, 1) || (item.last_error_code !== null && !stableCode(item.last_error_code))
+    || !instant(item.available_at) || !instant(item.created_at) || !instant(item.updated_at)
+    || (item.completed_at !== null && !instant(item.completed_at)) || terminal !== (item.completed_at !== null)) return invalid()
+  return { taskKey: item.task_key, taskType: item.task_type as OpsTask['taskType'], status: item.status as OpsTaskStatus,
+    attemptCount: item.attempt_count, maxAttempts: item.max_attempts, revision: item.revision, lastErrorCode: item.last_error_code as string | null,
+    availableAt: item.available_at, createdAt: item.created_at, updatedAt: item.updated_at, completedAt: item.completed_at as string | null }
+}
+
+const parseMaintenanceData = (value: unknown): MaintenanceWindow | null => {
+  if (value === null) return null
+  const item = record(value); exact(item, ['maintenance_key', 'state', 'reason_key', 'starts_at', 'ends_at', 'revision'])
+  if (!opaque(item.maintenance_key, 'maintenance_') || !['scheduled', 'active', 'closed'].includes(String(item.state))
+    || !qualifiedKey(item.reason_key, 64) || !instant(item.starts_at) || !instant(item.ends_at)
+    || Date.parse(item.ends_at) <= Date.parse(item.starts_at) || Date.parse(item.ends_at) - Date.parse(item.starts_at) > 86_400_000
+    || !integer(item.revision, 1)) return invalid()
+  return { maintenanceKey: item.maintenance_key, state: item.state as MaintenanceState, reasonKey: item.reason_key,
+    startsAt: item.starts_at, endsAt: item.ends_at, revision: item.revision }
+}
+export const parseMaintenance = (value: unknown): MaintenanceWindow | null => parseMaintenanceData(envelope(value).data)
+
+export const parseRuntimeLogs = (value: unknown): RuntimeLogPage => {
+  const data = record(envelope(value).data); exact(data, ['items', 'next_cursor'])
+  if (!Array.isArray(data.items) || data.items.length > 100 || (data.next_cursor !== null && (typeof data.next_cursor !== 'string' || !/^cursor_[A-Za-z0-9_-]{8,200}$/.test(data.next_cursor)))) return invalid()
+  const items = data.items.map(value => {
+    const item = record(value); exact(item, ['event_key', 'severity', 'component_key', 'message', 'occurred_at', 'request_id', 'occurrences'])
+    if (!qualifiedKey(item.event_key) || !LOG_SEVERITIES.includes(item.severity as LogSeverity)
+      || !qualifiedKey(item.component_key) || !safePublicText(item.message) || !instant(item.occurred_at)
+      || (item.request_id !== null && (typeof item.request_id !== 'string' || !/^[A-Za-z0-9._-]{1,128}$/.test(item.request_id)))
+      || !integer(item.occurrences, 1) || item.occurrences > 1_000_000) return invalid()
+    return { eventKey: item.event_key, severity: item.severity as LogSeverity, componentKey: item.component_key,
+      message: item.message, occurredAt: item.occurred_at, requestId: item.request_id as string | null, occurrences: item.occurrences }
+  })
+  return { items, nextCursor: data.next_cursor as string | null }
+}
+
+export const createOpsConsoleFetchTransport = (options: { readonly baseUrl: string; readonly fetch?: (request: Request) => Promise<Response> }): OpsConsoleTransport => {
+  const fetcher = options.fetch ?? fetch
+  const request = async (path: string, init: RequestInit): Promise<OpsTransportResult> => {
+    const headers = new Headers(init.headers); headers.set('Accept', 'application/json')
+    if (init.body !== undefined) headers.set('Content-Type', 'application/json')
+    const response = await fetcher(new Request(new URL(path, options.baseUrl), { credentials: 'include', ...init, headers }))
+    return { body: response.status === 204 ? null : await response.json(), headers: response.headers, status: response.status }
+  }
+  const writeHeaders = (idempotencyKey: string, revision?: number): HeadersInit => ({
+    'Idempotency-Key': idempotencyKey, ...(revision === undefined ? {} : { 'If-Match': `"rev-${revision}"` }),
+  })
+  return {
+    overview: signal => request('/api/platform/v1/ops/status', { method: 'GET', signal }),
+    submitBackup: (providerKey, idempotencyKey, signal) => request('/api/platform/v1/ops/tasks/backup', { method: 'POST', headers: writeHeaders(idempotencyKey), body: JSON.stringify({ provider_key: providerKey }), signal }),
+    submitRestore: (providerKey, backupReferenceKey, targetKey, idempotencyKey, signal) => request('/api/platform/v1/ops/tasks/restore', { method: 'POST', headers: writeHeaders(idempotencyKey), body: JSON.stringify({ provider_key: providerKey, backup_reference_key: backupReferenceKey, target_key: targetKey }), signal }),
+    task: (taskKey, signal) => request(`/api/platform/v1/ops/tasks/${encodeURIComponent(taskKey)}`, { method: 'GET', signal }),
+    maintenance: signal => request('/api/platform/v1/ops/maintenance', { method: 'GET', signal }),
+    scheduleMaintenance: (input, expectedRevision, idempotencyKey, signal) => request('/api/platform/v1/ops/maintenance', { method: 'PUT', headers: writeHeaders(idempotencyKey, expectedRevision), body: JSON.stringify({ reason_key: input.reasonKey, starts_at: input.startsAt, ends_at: input.endsAt }), signal }),
+    closeMaintenance: (maintenanceKey, expectedRevision, idempotencyKey, signal) => request(`/api/platform/v1/ops/maintenance/${encodeURIComponent(maintenanceKey)}/close`, { method: 'POST', headers: writeHeaders(idempotencyKey, expectedRevision), body: '{}', signal }),
+    logs: (sourceKey, severity, cursor, pageSize, signal) => {
+      const query = new URLSearchParams({ source: sourceKey, severity, page_size: String(pageSize) }); if (cursor !== null) query.set('cursor', cursor)
+      return request(`/api/platform/v1/ops/logs?${query}`, { method: 'GET', signal })
+    },
+  }
+}

package/ops-console/src/index.ts

@@ -0,0 +1,3 @@
+export { default as OpsConsolePage } from './OpsConsolePage.vue'
+export * from './contracts'
+export * from './runtime'