@stacksjs/defaults 0.70.365 → 0.70.367

package/app/Actions/Dashboard/Operations/recovery-input.ts

@@ -0,0 +1,33 @@
+import type { BackupResourceKind, JsonValue } from '@stacksjs/ts-cloud'
+
+export const RECOVERY_KINDS: BackupResourceKind[] = [
+  'managed_database',
+  'logical_database',
+  'volume',
+  'files',
+  'control_plane',
+  'infrastructure',
+]
+
+export function stringValue(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+export function stringList(value: unknown): string[] {
+  return Array.isArray(value)
+    ? value.map(stringValue).filter(Boolean)
+    : typeof value === 'string'
+      ? value.split(',').map(entry => entry.trim()).filter(Boolean)
+      : []
+}
+
+export function positiveNumber(value: unknown, fallback: number, maximum = Number.MAX_SAFE_INTEGER): number {
+  const number = Number(value)
+  return Number.isFinite(number) && number > 0 ? Math.min(maximum, number) : fallback
+}
+
+export function jsonObject(value: unknown): Record<string, JsonValue> {
+  if (!value || typeof value !== 'object' || Array.isArray(value))
+    return {}
+  return value as Record<string, JsonValue>
+}

package/app/Actions/Dashboard/Operations/recovery-runtime.ts

@@ -0,0 +1,99 @@
+import type {
+  BackupDestination,
+  BackupPolicy,
+  BackupSourceAdapter,
+  JsonValue,
+} from '@stacksjs/ts-cloud'
+import { join } from 'node:path'
+import process from 'node:process'
+import {
+  AwsDatabaseBackupSource,
+  AwsInfrastructureBackupSource,
+  BackupCoordinator,
+  BackupStore,
+  ControlPlaneBackupSource,
+  createBackupQueueHandlers,
+  DataServiceStore,
+  DockerVolumeBackupSource,
+  DurableOperationQueue,
+  DurableQueueWorker,
+  EncryptedDataSecretStore,
+  FilesystemBackupSource,
+  LogicalDatabaseBackupSource,
+  resolveAuthEncryptionKey,
+  S3BackupDestinationAdapter,
+} from '@stacksjs/ts-cloud'
+import { operationsControlPlane, operationsEnvironment } from './control-plane'
+
+export interface RecoveryRuntime {
+  store: BackupStore
+  coordinator: BackupCoordinator
+  queue: DurableOperationQueue
+  worker: DurableQueueWorker
+  dataServices: DataServiceStore
+  secrets: EncryptedDataSecretStore
+}
+
+let runtime: RecoveryRuntime | undefined
+
+export function recoveryRuntime(): RecoveryRuntime {
+  if (runtime)
+    return runtime
+
+  const controlPlane = operationsControlPlane()
+  const store = new BackupStore(controlPlane.store)
+  const queue = new DurableOperationQueue(controlPlane.store, { workerId: `stacks-dashboard:${process.pid}` })
+  const coordinator = new BackupCoordinator(store, queue)
+  const dataServices = new DataServiceStore(controlPlane.store)
+  const secrets = new EncryptedDataSecretStore(controlPlane.store, resolveAuthEncryptionKey(process.cwd()))
+  const destination = new S3BackupDestinationAdapter(secrets)
+
+  const resolveSource = (policy: BackupPolicy): BackupSourceAdapter | undefined => {
+    if (policy.resourceKind === 'managed_database')
+      return new AwsDatabaseBackupSource(dataServices)
+    if (policy.resourceKind === 'logical_database')
+      return new LogicalDatabaseBackupSource(dataServices, secrets)
+    if (policy.resourceKind === 'volume')
+      return new DockerVolumeBackupSource()
+    if (policy.resourceKind === 'files')
+      return new FilesystemBackupSource(process.cwd(), undefined, join(process.cwd(), 'storage', 'cloud', 'restores'))
+    if (policy.resourceKind === 'control_plane')
+      return new ControlPlaneBackupSource(controlPlane.store, process.cwd(), join(process.cwd(), 'storage', 'cloud', 'restores'))
+    if (policy.resourceKind === 'infrastructure')
+      return new AwsInfrastructureBackupSource()
+    return undefined
+  }
+
+  const handlers = createBackupQueueHandlers({
+    store,
+    queue,
+    resolveSource,
+    resolveDestination: (value: BackupDestination) => value.provider === 'aws_backup' ? undefined : destination,
+  })
+  const worker = new DurableQueueWorker(queue, handlers, {
+    parallelism: 2,
+    pollIntervalMs: 2_000,
+    onError: error => console.error('[dashboard/recovery] worker failed:', error),
+  }).start()
+
+  runtime = { store, coordinator, queue, worker, dataServices, secrets }
+  return runtime
+}
+
+export function recoveryEnvironment() {
+  const controlPlane = operationsControlPlane()
+  const environment = operationsEnvironment(controlPlane)
+  if (!environment)
+    throw new Error('No cloud environment is configured for recovery operations.')
+  return { controlPlane, environment }
+}
+
+export function safeRecoveryDestination(destination: BackupDestination): Record<string, JsonValue> {
+  return {
+    ...destination,
+    credentialRef: null,
+    encryptionKeyRef: null,
+    credentialsConfigured: Boolean(destination.credentialRef),
+    clientEncryptionConfigured: Boolean(destination.encryptionKeyRef),
+  }
+}

package/app/Actions/Dashboard/Operations/scheduler-operations.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'bun:test'
+import { parseSchedulerRegistry, SchedulerOperationError } from './scheduler-operations'
+
+describe('scheduler operations', () => {
+  it('parses the Buddy scheduler registry marker', () => {
+    const tasks = parseSchedulerRegistry([
+      'loading application',
+      'STACKS_SCHEDULE_JSON={"jobs":[{"name":"Cleanup","pattern":"0 * * * *","timezone":"UTC","nextRun":"2026-08-12T12:00:00.000Z","enabled":false}],"locks":[]}',
+    ].join('\n'))
+
+    expect(tasks).toEqual([{
+      name: 'Cleanup',
+      pattern: '0 * * * *',
+      timezone: 'UTC',
+      nextRun: '2026-08-12T12:00:00.000Z',
+      enabled: false,
+    }])
+  })
+
+  it('rejects unmarked output instead of guessing', () => {
+    expect(() => parseSchedulerRegistry('{"jobs":[]}')).toThrow(SchedulerOperationError)
+  })
+})

package/app/Actions/Dashboard/Operations/scheduler-operations.ts

@@ -0,0 +1,138 @@
+import { join } from 'node:path'
+import process from 'node:process'
+
+export interface SchedulerTask {
+  name: string
+  pattern: string
+  timezone: string
+  nextRun: string | null
+  enabled: boolean
+}
+
+interface BuddyResult {
+  stdout: string
+  stderr: string
+  exitCode: number
+}
+
+interface SchedulerRegistryPayload {
+  jobs?: unknown
+}
+
+export class SchedulerOperationError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'SchedulerOperationError'
+  }
+}
+
+async function runBuddy(args: string[], timeoutMs = 30_000): Promise<BuddyResult> {
+  const subprocess = Bun.spawn([join(process.cwd(), 'buddy'), ...args], {
+    cwd: process.cwd(),
+    env: { ...process.env, NO_COLOR: '1' },
+    stdout: 'pipe',
+    stderr: 'pipe',
+  })
+
+  let timeout: ReturnType<typeof setTimeout> | undefined
+  const timedOut = new Promise<never>((_resolve, reject) => {
+    timeout = setTimeout(() => {
+      subprocess.kill()
+      reject(new SchedulerOperationError(`buddy ${args[0]} timed out.`))
+    }, timeoutMs)
+  })
+
+  try {
+    const [stdout, stderr, exitCode] = await Promise.race([
+      Promise.all([
+        new Response(subprocess.stdout).text(),
+        new Response(subprocess.stderr).text(),
+        subprocess.exited,
+      ]),
+      timedOut,
+    ])
+    return { stdout, stderr, exitCode }
+  }
+  finally {
+    if (timeout)
+      clearTimeout(timeout)
+  }
+}
+
+export function parseSchedulerRegistry(output: string): SchedulerTask[] {
+  const marker = 'STACKS_SCHEDULE_JSON='
+  const line = output.split(/\r?\n/).find(entry => entry.startsWith(marker))
+  if (!line)
+    throw new SchedulerOperationError('The scheduler registry did not return machine-readable output.')
+
+  let payload: SchedulerRegistryPayload
+  try {
+    payload = JSON.parse(line.slice(marker.length)) as SchedulerRegistryPayload
+  }
+  catch {
+    throw new SchedulerOperationError('The scheduler registry returned invalid JSON.')
+  }
+
+  if (!Array.isArray(payload.jobs))
+    throw new SchedulerOperationError('The scheduler registry response did not include a task list.')
+
+  return payload.jobs.map((value) => {
+    if (!value || typeof value !== 'object')
+      throw new SchedulerOperationError('The scheduler registry returned an invalid task.')
+    const job = value as Record<string, unknown>
+    if (typeof job.name !== 'string' || !job.name.trim())
+      throw new SchedulerOperationError('A scheduled task is missing its name.')
+    return {
+      name: job.name,
+      pattern: typeof job.pattern === 'string' ? job.pattern : '',
+      timezone: typeof job.timezone === 'string' ? job.timezone : 'UTC',
+      nextRun: typeof job.nextRun === 'string' ? job.nextRun : null,
+      enabled: job.enabled !== false,
+    }
+  })
+}
+
+export async function listSchedulerTasks(): Promise<SchedulerTask[]> {
+  const result = await runBuddy(['schedule:list', '--json'])
+  if (result.exitCode !== 0)
+    throw new SchedulerOperationError(result.stderr.trim() || 'The scheduler registry could not be loaded.')
+  return parseSchedulerRegistry(result.stdout)
+}
+
+async function requireSchedulerTask(name: string): Promise<SchedulerTask> {
+  const normalized = name.trim()
+  const task = (await listSchedulerTasks()).find(entry => entry.name === normalized)
+  if (!task)
+    throw new SchedulerOperationError(`Scheduled task "${normalized}" was not found.`)
+  return task
+}
+
+export async function runScheduledTask(name: string): Promise<{ message: string, task: string }> {
+  const task = await requireSchedulerTask(name)
+  if (!task.enabled)
+    throw new SchedulerOperationError(`Scheduled task "${task.name}" is paused.`)
+  const result = await runBuddy(['schedule:run-one', task.name], 5 * 60_000)
+  if (result.exitCode !== 0)
+    throw new SchedulerOperationError(result.stderr.trim() || `Scheduled task "${task.name}" failed.`)
+  return { message: `Scheduled task ${task.name} completed.`, task: task.name }
+}
+
+export async function setScheduledTaskEnabled(name: string, enabled: boolean): Promise<{ enabled: boolean, message: string, task: string }> {
+  const task = await requireSchedulerTask(name)
+  if (task.enabled === enabled) {
+    return {
+      enabled,
+      message: `Scheduled task ${task.name} is already ${enabled ? 'active' : 'paused'}.`,
+      task: task.name,
+    }
+  }
+
+  const result = await runBuddy([enabled ? 'schedule:enable' : 'schedule:disable', task.name])
+  if (result.exitCode !== 0)
+    throw new SchedulerOperationError(result.stderr.trim() || `Scheduled task "${task.name}" could not be updated.`)
+  return {
+    enabled,
+    message: `Scheduled task ${task.name} ${enabled ? 'resumed' : 'paused'}.`,
+    task: task.name,
+  }
+}

package/functions/deployments.ts

@@ -35,6 +35,16 @@ export interface DeploymentTerminal {
   exists: boolean
 }
 
+export interface DeploymentRollbackPlan {
+  revision: string
+  environment: string
+  site: string | null
+  release: string | null
+  target: string
+  output: string
+  warnings: string[]
+}
+
 export interface DeployScriptUpdate {
   success: boolean
   path: string
@@ -142,3 +152,11 @@ export async function updateDeployScript(content: string): Promise<DeployScriptU
 export async function fetchDeploymentTerminal(): Promise<DeploymentTerminal> {
   return dashboardApi<DeploymentTerminal>('/api/dashboard/deployments/terminal')
 }
+
+export function previewDeploymentRollback(input: { environment: string, site?: string, release?: string }): Promise<{ success: boolean, plan: DeploymentRollbackPlan }> {
+  return dashboardApi('/api/dashboard/deployments/rollback/preview', { method: 'POST', body: input })
+}
+
+export function runDeploymentRollback(input: { environment: string, site?: string, release?: string, revision: string, confirmation: string }): Promise<{ success: boolean, message: string }> {
+  return dashboardApi('/api/dashboard/deployments/rollback', { method: 'POST', body: input })
+}

package/functions/operations.ts

@@ -0,0 +1,361 @@
+import { dashboardApi } from './dashboard-api'
+
+export interface SchedulerTask {
+  name: string
+  pattern: string
+  timezone: string
+  nextRun: string | null
+  enabled: boolean
+}
+
+export interface OperatorOperation {
+  id: string
+  actorName: string
+  kind: string
+  state: 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled' | 'timed_out'
+  input: Record<string, unknown>
+  output: Record<string, unknown>
+  error?: string
+  startedAt?: string
+  finishedAt?: string
+  createdAt: string
+}
+
+export interface SchedulerOperationsResponse {
+  tasks: SchedulerTask[]
+  operations: OperatorOperation[]
+  summary: {
+    total: number
+    active: number
+    paused: number
+    nextRun: string | null
+  }
+}
+
+export interface SchedulerMutationResponse {
+  success: boolean
+  message: string
+  task: string
+  enabled?: boolean
+  operation: OperatorOperation
+}
+
+export function fetchSchedulerOperations(): Promise<SchedulerOperationsResponse> {
+  return dashboardApi<SchedulerOperationsResponse>('/api/dashboard/operations/scheduler')
+}
+
+export function runSchedulerTask(name: string): Promise<SchedulerMutationResponse> {
+  return dashboardApi<SchedulerMutationResponse>(`/api/dashboard/operations/scheduler/${encodeURIComponent(name)}/run`, {
+    method: 'POST',
+  })
+}
+
+export function updateSchedulerTask(name: string, enabled: boolean): Promise<SchedulerMutationResponse> {
+  return dashboardApi<SchedulerMutationResponse>(`/api/dashboard/operations/scheduler/${encodeURIComponent(name)}`, {
+    method: 'PATCH',
+    body: { enabled },
+  })
+}
+
+export type BackupResourceKind = 'managed_database' | 'logical_database' | 'volume' | 'files' | 'control_plane' | 'infrastructure'
+
+export interface RecoveryDestination {
+  id: string
+  name: string
+  provider: 'aws_s3' | 's3_compatible' | 'aws_backup'
+  bucket?: string
+  region?: string
+  status: 'untested' | 'healthy' | 'failing' | 'disabled'
+  credentialsConfigured: boolean
+  clientEncryptionConfigured: boolean
+  lastTestedAt?: string
+  lastError?: string
+}
+
+export interface RecoveryPolicy {
+  id: string
+  destinationId: string
+  name: string
+  resourceKind: BackupResourceKind
+  schedule: string
+  timezone: string
+  expectedRpoMinutes: number
+  expectedRtoMinutes: number
+  enabled: boolean
+  nextRunAt?: string
+  lastRunAt?: string
+}
+
+export interface RecoveryPoint {
+  id: string
+  policyId?: string
+  kind: BackupResourceKind
+  pointInTime: string
+  sizeBytes: number
+  status: 'pending' | 'available' | 'failed' | 'deleting' | 'deleted'
+  verificationState: 'unverified' | 'verifying' | 'verified' | 'corrupt' | 'failed'
+  verifiedAt?: string
+  held: boolean
+  pinned: boolean
+  expiresAt?: string
+  lockedUntil?: string
+}
+
+export interface RecoveryJob {
+  id: string
+  policyId?: string
+  recoveryPointId?: string
+  operationId?: string
+  kind: 'backup' | 'restore' | 'verify' | 'drill' | 'cleanup'
+  status: 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled' | 'cleanup_required'
+  progress: Record<string, unknown>
+  error?: string
+  startedAt?: string
+  finishedAt?: string
+  createdAt: string
+}
+
+export interface RecoveryCoverage {
+  policy: RecoveryPolicy
+  lastRecoveryPoint?: RecoveryPoint
+  missedRpo: boolean
+  unverified: number
+  destinationHealthy: boolean
+}
+
+export interface RecoveryResource {
+  id: string
+  kind: string
+  name: string
+  slug: string
+}
+
+export interface RecoveryDataService {
+  id: string
+  name: string
+  engine: string
+  provider: string
+  status: string
+}
+
+export interface RecoveryOperationsResponse {
+  environment: { id: string, name: string, slug: string }
+  coverage: RecoveryCoverage[]
+  destinations: RecoveryDestination[]
+  policies: RecoveryPolicy[]
+  recoveryPoints: RecoveryPoint[]
+  jobs: RecoveryJob[]
+  resources: RecoveryResource[]
+  dataServices: RecoveryDataService[]
+  summary: {
+    policies: number
+    protected: number
+    missedRpo: number
+    unverified: number
+    queuedJobs: number
+    latestPoint: string | null
+  }
+}
+
+export interface RecoveryDestinationInput {
+  name: string
+  provider: RecoveryDestination['provider']
+  bucket?: string
+  endpoint?: string
+  prefix?: string
+  region?: string
+  allowPrivate?: boolean
+  forcePathStyle?: boolean
+  encryption: 'provider' | 'client_side' | 'both'
+  encryptionKey?: string
+  lockDays?: number
+  credentials?: { accessKeyId?: string, secretAccessKey?: string, sessionToken?: string }
+}
+
+export interface RecoveryPolicyInput {
+  name: string
+  destinationId: string
+  resourceKind: BackupResourceKind
+  resourceId?: string
+  dataServiceId?: string
+  includePatterns: string[]
+  excludePatterns: string[]
+  schedule: string
+  timezone: string
+  keepLast: number
+  expireAfterDays: number
+  compression: 'none' | 'gzip' | 'zstd'
+  expectedRpoMinutes: number
+  expectedRtoMinutes: number
+  enabled: boolean
+}
+
+export interface RestorePlanInput {
+  mode: 'isolated' | 'in_place'
+  targetName: string
+  target?: Record<string, unknown>
+  drill?: boolean
+  execute?: boolean
+  confirm?: string
+  downtimeAcknowledged?: boolean
+  safetyBackupId?: string
+}
+
+export function fetchRecoveryOperations(): Promise<RecoveryOperationsResponse> {
+  return dashboardApi<RecoveryOperationsResponse>('/api/dashboard/operations/recovery')
+}
+
+export function createRecoveryDestination(input: RecoveryDestinationInput): Promise<{ success: boolean, destination: RecoveryDestination }> {
+  return dashboardApi('/api/dashboard/operations/recovery/destinations', { method: 'POST', body: input })
+}
+
+export function testRecoveryDestination(id: string): Promise<{ success: boolean, message: string, destination: RecoveryDestination }> {
+  return dashboardApi(`/api/dashboard/operations/recovery/destinations/${encodeURIComponent(id)}/test`, { method: 'POST' })
+}
+
+export function createRecoveryPolicy(input: RecoveryPolicyInput): Promise<{ success: boolean, policy: RecoveryPolicy }> {
+  return dashboardApi('/api/dashboard/operations/recovery/policies', { method: 'POST', body: input })
+}
+
+export function runRecoveryPolicy(id: string): Promise<{ success: boolean, message: string, job: RecoveryJob }> {
+  return dashboardApi(`/api/dashboard/operations/recovery/policies/${encodeURIComponent(id)}/run`, { method: 'POST' })
+}
+
+export function verifyRecoveryPoint(id: string): Promise<{ success: boolean, message: string, job: RecoveryJob }> {
+  return dashboardApi(`/api/dashboard/operations/recovery/points/${encodeURIComponent(id)}/verify`, { method: 'POST' })
+}
+
+export function planRecoveryRestore(id: string, input: RestorePlanInput): Promise<{ success: boolean, plan: { mode: string, target: Record<string, unknown>, warnings: string[] }, productionExecutionCreated: boolean }> {
+  return dashboardApi(`/api/dashboard/operations/recovery/points/${encodeURIComponent(id)}/restore`, { method: 'POST', body: input })
+}
+
+export function protectRecoveryPoint(id: string, input: { pinned?: boolean, held?: boolean }): Promise<{ success: boolean, recoveryPoint: RecoveryPoint }> {
+  return dashboardApi(`/api/dashboard/operations/recovery/points/${encodeURIComponent(id)}/protection`, { method: 'PATCH', body: input })
+}
+
+export function runRecoveryRetention(): Promise<{ success: boolean, message: string, jobs: RecoveryJob[] }> {
+  return dashboardApi('/api/dashboard/operations/recovery/retention', { method: 'POST' })
+}
+
+export interface MigrationPlanOperation {
+  kind: string
+  table: string
+  column?: string
+  sql?: string
+  destructive: boolean
+}
+
+export interface MigrationLedgerEntry {
+  file: string
+  status: string
+  recorded: boolean
+  effects: Array<{ kind: string, table?: string, name: string }>
+}
+
+export interface MigrationOperationsResponse {
+  environment: string
+  dialect: string
+  operations: MigrationPlanOperation[]
+  revision: string
+  applied: number
+  ledger: {
+    supported: boolean
+    drift: boolean
+    entries: MigrationLedgerEntry[]
+    orphans: Array<{ migration: string, renamedTo?: string }>
+    counts: Record<string, number>
+  }
+  reconciliation: Record<string, unknown>
+  operatorOperations: OperatorOperation[]
+  summary: { pending: number, destructive: number, drift: boolean, ledgerIssues: number }
+}
+
+export function fetchMigrationOperations(): Promise<MigrationOperationsResponse> {
+  return dashboardApi('/api/dashboard/operations/migrations')
+}
+
+export function applyMigrationOperations(revision: string, confirmation: string): Promise<{ success: boolean, message: string, operation: OperatorOperation }> {
+  return dashboardApi('/api/dashboard/operations/migrations/apply', { method: 'POST', body: { revision, confirmation } })
+}
+
+export function reconcileMigrationLedger(revision: string, confirmation: string): Promise<{ success: boolean, result: Record<string, unknown>, operation: OperatorOperation }> {
+  return dashboardApi('/api/dashboard/operations/migrations/reconcile', { method: 'POST', body: { revision, confirmation } })
+}
+
+export interface ReleaseApprovalItem {
+  id: string
+  sourceSha?: string
+  kind: string
+  strategy: string
+  createdAt: string
+  approvals: Array<{ decision: string, comment?: string, createdAt: string }>
+}
+
+export interface ChangeOperationsResponse {
+  environment?: { id: string, name: string, slug: string }
+  migrations: MigrationOperationsResponse
+  pendingReleases: ReleaseApprovalItem[]
+  activeOperations: OperatorOperation[]
+  recentOperations: OperatorOperation[]
+  summary: { migrationChanges: number, destructiveChanges: number, approvals: number, activeOperations: number }
+}
+
+export function fetchChangeOperations(): Promise<ChangeOperationsResponse> {
+  return dashboardApi('/api/dashboard/operations/changes')
+}
+
+export function decideRelease(id: string, decision: 'approved' | 'rejected', comment = ''): Promise<{ success: boolean }> {
+  return dashboardApi(`/api/dashboard/operations/changes/releases/${encodeURIComponent(id)}/decision`, { method: 'POST', body: { decision, comment } })
+}
+
+export interface IncidentAlert {
+  id: string
+  state: string
+  severity: string
+  title: string
+  occurrenceCount: number
+  ownerName?: string
+  acknowledgedAt?: string
+  silencedUntil?: string
+  firstSeenAt: string
+  lastSeenAt: string
+}
+
+export interface IncidentOperationsResponse {
+  alerts: IncidentAlert[]
+  rules: Array<{ id: string, name: string, severity: string, enabled: boolean }>
+  healthChecks: Array<{ id: string, name: string, kind: string, target: string, enabled: boolean }>
+  channels: Array<{ id: string, name: string, kind: string, status: string }>
+  deliveries: Array<Record<string, unknown>>
+  operations: OperatorOperation[]
+  summary: { firing: number, critical: number, acknowledged: number, rules: number }
+}
+
+export function fetchIncidentOperations(): Promise<IncidentOperationsResponse> {
+  return dashboardApi('/api/dashboard/operations/incidents')
+}
+
+export function updateIncident(id: string, input: { action: 'acknowledge' | 'assign_self' | 'unassign' | 'silence', until?: string }): Promise<{ success: boolean, alert: IncidentAlert }> {
+  return dashboardApi(`/api/dashboard/operations/incidents/${encodeURIComponent(id)}`, { method: 'PATCH', body: input })
+}
+
+export interface AuditEvent {
+  id: string
+  sequence: number
+  operationId?: string
+  actorName: string
+  type: string
+  level: string
+  payload: unknown
+  createdAt: string
+}
+
+export interface AuditOperationsResponse {
+  events: AuditEvent[]
+  operations: OperatorOperation[]
+  summary: { events: number, operators: number, failures: number, latestSequence: number }
+}
+
+export function fetchAuditOperations(): Promise<AuditOperationsResponse> {
+  return dashboardApi('/api/dashboard/operations/audit')
+}

package/ide/vscode/package.json

@@ -2,7 +2,7 @@
   "publisher": "Stacks",
   "name": "vscode-stacks",
   "displayName": "Stacks",
-  "version": "0.70.365",
+  "version": "0.70.367",
   "description": "A modern Stacks development environment.",
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",