@stacksjs/defaults 0.70.366 → 0.70.368

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.366",
+  "version": "0.70.368",
   "description": "A modern Stacks development environment.",
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/defaults",
   "type": "module",
   "sideEffects": false,
-  "version": "0.70.366",
+  "version": "0.70.368",
   "description": "The complete managed Stacks application scaffold, including runtime defaults, AI guidance, editor metadata, and npm-backed project support files.",
   "author": "Chris Breuer",
   "license": "MIT",

package/resources/components/Dashboard/Ci/CiDashboard.stx

@@ -263,13 +263,13 @@
             <span class="text-xs text-zinc-400" :text="repo.commitAuthor"></span>
           </div>
 
-          <div :if="repo.renovatePRs > 0 || repo.actionsPRs > 0" class="mt-2 pt-2 border-t border-zinc-200/60 dark:border-zinc-800">
+          <div :if="repo.buddyBotPRs > 0 || repo.actionsPRs > 0" class="mt-2 pt-2 border-t border-zinc-200/60 dark:border-zinc-800">
             <div class="mb-1 text-xs text-zinc-400">Pull Requests</div>
             <div class="flex flex-wrap gap-x-3 gap-y-0.5">
-              <a :if="repo.renovatePRs > 0" :href="repo.renovatePRsUrl" target="_blank" @click.stop class="no-underline text-xs text-zinc-500 dark:text-zinc-400 hover:underline">
-                renovatebot: <span :text="repo.renovatePRs"></span>
+              <a :if="repo.buddyBotPRs > 0" :href="repo.buddyBotPRsUrl" target="_blank" rel="noreferrer" @click.stop class="no-underline text-xs text-zinc-500 dark:text-zinc-400 hover:underline">
+                buddy-bot: <span :text="repo.buddyBotPRs"></span>
               </a>
-              <a :if="repo.actionsPRs > 0" :href="repo.actionsPRsUrl" target="_blank" @click.stop class="no-underline text-xs text-zinc-500 dark:text-zinc-400 hover:underline">
+              <a :if="repo.actionsPRs > 0" :href="repo.actionsPRsUrl" target="_blank" rel="noreferrer" @click.stop class="no-underline text-xs text-zinc-500 dark:text-zinc-400 hover:underline">
                 github-actions: <span :text="repo.actionsPRs"></span>
               </a>
             </div>