@stacksjs/defaults 0.70.229 → 0.70.231

package/app/Actions/Dashboard/Infrastructure/CommandIndexAction.ts

@@ -1,18 +1,49 @@
 import { Action } from '@stacksjs/actions'
+import { existsSync, readFileSync, statSync } from 'node:fs'
+import { join, relative } from 'node:path'
+import process from 'node:process'
+import { parseCommandSource } from '../Source/source-inventory'
+
+interface CommandConfig {
+  file: string
+  enabled?: boolean
+  aliases?: string[]
+}
 
 export default new Action({
   name: 'CommandIndexAction',
-  description: 'Returns command history data for the dashboard.',
+  description: 'Lists commands registered by the application.',
   method: 'GET',
   async handle() {
+    const projectRoot = process.cwd()
+    const registryPath = join(projectRoot, 'app/Commands.ts')
+    const registryModule = await import(registryPath)
+    const registry = (registryModule.default || {}) as Record<string, string | CommandConfig>
+    const items = Object.entries(registry).flatMap(([signature, value]) => {
+      const config = typeof value === 'string'
+        ? { file: value, enabled: true, aliases: [] }
+        : { enabled: true, aliases: [], ...value }
+      const file = join(projectRoot, 'app/Commands', `${config.file}.ts`)
+      if (!existsSync(file))
+        return []
+
+      return [parseCommandSource(
+        readFileSync(file, 'utf8'),
+        relative(projectRoot, file),
+        signature,
+        config.aliases,
+        statSync(file).mtime.toISOString(),
+      )]
+    })
+
     return {
-      commands: [
-        { name: 'migrate', description: 'Run database migrations', lastRun: '2024-01-10 10:30', status: 'success' },
-        { name: 'seed', description: 'Seed the database', lastRun: '2024-01-10 10:31', status: 'success' },
-        { name: 'cache:clear', description: 'Clear application cache', lastRun: '2024-01-10 09:15', status: 'success' },
-        { name: 'queue:work', description: 'Process queue jobs', lastRun: 'Running', status: 'running' },
-        { name: 'schedule:run', description: 'Run scheduled tasks', lastRun: '2024-01-10 10:00', status: 'success' },
-      ],
+      items,
+      stats: {
+        total: items.length,
+        aliases: items.reduce((sum, item) => sum + (item.aliases?.length || 0), 0),
+        options: items.reduce((sum, item) => sum + (item.options?.length || 0), 0),
+        registered: Object.keys(registry).length,
+      },
     }
   },
 })

package/app/Actions/Dashboard/Infrastructure/DnsIndexAction.ts

@@ -1,101 +1,13 @@
 import { Action } from '@stacksjs/actions'
 import { config } from '@stacksjs/config'
+import { tsCloud } from '~/config/cloud'
+import { getDashboardDnsSnapshot } from './dns-overview'
 
 export default new Action({
   name: 'DnsIndexAction',
   description: 'Returns DNS configuration from config files.',
   method: 'GET',
   async handle() {
-    try {
-      const dnsConfig = config.dns || {}
-
-      // Read A records from config/dns.ts
-      const aRecords = (dnsConfig as any).a || []
-      const aaaaRecords = (dnsConfig as any).aaaa || []
-      const cnameRecords = (dnsConfig as any).cname || []
-      const mxRecords = (dnsConfig as any).mx || []
-      const txtRecords = (dnsConfig as any).txt || []
-      const nameservers = (dnsConfig as any).nameservers || []
-
-      // Build unified records list
-      const records: Array<Record<string, unknown>> = []
-
-      for (const rec of aRecords) {
-        records.push({
-          type: 'A',
-          name: rec.name || '@',
-          value: rec.address || rec.value || '',
-          ttl: String(rec.ttl || 300),
-        })
-      }
-
-      for (const rec of aaaaRecords) {
-        records.push({
-          type: 'AAAA',
-          name: rec.name || '@',
-          value: rec.address || rec.value || '',
-          ttl: String(rec.ttl || 300),
-        })
-      }
-
-      for (const rec of cnameRecords) {
-        records.push({
-          type: 'CNAME',
-          name: rec.name || '',
-          value: rec.target || rec.value || '',
-          ttl: String(rec.ttl || 300),
-        })
-      }
-
-      for (const rec of mxRecords) {
-        records.push({
-          type: 'MX',
-          name: rec.name || '@',
-          value: rec.server || rec.value || '',
-          ttl: String(rec.ttl || 3600),
-          priority: rec.priority,
-        })
-      }
-
-      for (const rec of txtRecords) {
-        records.push({
-          type: 'TXT',
-          name: rec.name || '@',
-          value: rec.value || '',
-          ttl: String(rec.ttl || 3600),
-        })
-      }
-
-      // Build domain info from the cloud config DNS settings
-      const cloudDns = (config.cloud as any)?.infrastructure?.dns ?? {}
-      const primaryDomain = cloudDns.domain || ''
-
-      const domains = []
-      if (primaryDomain) {
-        domains.push({
-          domain: primaryDomain,
-          records: records.length,
-          status: 'active',
-          hostedZoneId: cloudDns.hostedZoneId || '',
-        })
-      }
-
-      const stats = [
-        { label: 'Domains', value: String(domains.length || 1) },
-        { label: 'DNS Records', value: String(records.length) },
-        { label: 'Nameservers', value: String(nameservers.length) },
-        { label: 'A Records', value: String(aRecords.length) },
-      ]
-
-      return {
-        domains,
-        records,
-        nameservers,
-        stats,
-      }
-    }
-    catch {
-      return { domains: [], records: [], nameservers: [], stats: [] }
-    }
+    return getDashboardDnsSnapshot(config.dns, tsCloud)
   },
 })

package/app/Actions/Dashboard/Infrastructure/EnvironmentIndexAction.ts

@@ -1,67 +1,16 @@
 import { Action } from '@stacksjs/actions'
+import { readEnvironmentFile } from './environment-file'
 
 export default new Action({
   name: 'EnvironmentIndexAction',
-  description: 'Returns environment variable data for the dashboard.',
+  description: 'Returns the project environment file and its latest dashboard backup.',
   method: 'GET',
-  async handle() {
-    const environments = [
-      { name: 'production', url: 'https://stacks.dev', status: 'healthy', lastDeploy: '2d ago', version: '1.2.3' },
-      { name: 'staging', url: 'https://staging.stacks.dev', status: 'healthy', lastDeploy: '1h ago', version: '1.2.4-beta' },
-      { name: 'development', url: 'http://localhost:3000', status: 'running', lastDeploy: 'Local', version: '1.2.4-dev' },
-    ]
-
-    let variables: Array<Record<string, unknown>> = [
-      { key: 'APP_NAME', value: 'Stacks', environments: ['production', 'staging', 'development'] },
-      { key: 'APP_URL', value: 'https://stacks.dev', environments: ['production'] },
-      { key: 'DATABASE_URL', value: '••••••••', environments: ['production', 'staging'], sensitive: true },
-      { key: 'REDIS_URL', value: '••••••••', environments: ['production', 'staging'], sensitive: true },
-      { key: 'DEBUG', value: 'false', environments: ['production'] },
-      { key: 'DEBUG', value: 'true', environments: ['staging', 'development'] },
-    ]
-
-    let stats = [
-      { label: 'Environments', value: '3' },
-      { label: 'Variables', value: '24' },
-      { label: 'Secrets', value: '8' },
-      { label: 'Last Sync', value: '5m ago' },
-    ]
-
-    try {
-      const { readFileSync } = await import('node:fs')
-      const { resolve } = await import('node:path')
-      const envPath = resolve(process.cwd(), '.env')
-      const envContent = readFileSync(envPath, 'utf-8')
-      const envLines = envContent.split('\n').filter(l => l.trim() && !l.trim().startsWith('#'))
-      const sensitiveKeys = ['PASSWORD', 'SECRET', 'KEY', 'TOKEN', 'DATABASE_URL', 'REDIS_URL', 'API_KEY']
-      const envVars: Array<Record<string, unknown>> = []
-      let secretCount = 0
+  apiResponse: true,
 
-      for (const line of envLines) {
-        const eqIdx = line.indexOf('=')
-        if (eqIdx > 0) {
-          const key = line.substring(0, eqIdx).trim()
-          let val = line.substring(eqIdx + 1).trim()
-          const isSensitive = sensitiveKeys.some(sk => key.toUpperCase().includes(sk))
-          if (isSensitive) { secretCount++; val = '••••••••' }
-          envVars.push({ key, value: val, environments: ['development'], sensitive: isSensitive })
-        }
-      }
-
-      if (envVars.length > 0) {
-        variables = envVars
-        stats = [
-          { label: 'Environments', value: '3' },
-          { label: 'Variables', value: String(envVars.length) },
-          { label: 'Secrets', value: String(secretCount) },
-          { label: 'Last Sync', value: 'Now' },
-        ]
-      }
-    }
-    catch {
-      // keep fallback data
-    }
-
-    return { environments, variables, stats }
+  async handle() {
+    return Response.json(
+      { environment: await readEnvironmentFile() },
+      { headers: { 'Cache-Control': 'no-store', Pragma: 'no-cache' } },
+    )
   },
 })

package/app/Actions/Dashboard/Infrastructure/EnvironmentUpdateAction.ts

@@ -0,0 +1,46 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+import { updateEnvironmentFile } from './environment-file'
+
+export default new Action({
+  name: 'EnvironmentUpdateAction',
+  description: 'Validates and atomically updates the project environment file.',
+  method: 'PUT',
+  apiResponse: true,
+
+  async handle(request: RequestInstance) {
+    const content = request.get('content')
+    const revision = request.get('revision')
+
+    if (typeof content !== 'string')
+      return response.json({ message: 'Environment content must be a string.' }, 422)
+    if (typeof revision !== 'string' || !/^[a-f0-9]{64}$/.test(revision))
+      return response.json({ message: 'A valid environment revision is required.' }, 422)
+
+    const result = await updateEnvironmentFile(content, revision)
+    if (result.issues?.length) {
+      const errors = Object.fromEntries(result.issues.map((issue, index) => [
+        issue.line ? String(issue.line) : `file-${index}`,
+        issue.message,
+      ]))
+      return response.json({
+        message: 'Fix the environment file validation errors before saving.',
+        errors,
+      }, 422)
+    }
+    if (result.conflict) {
+      return response.json({
+        message: 'The environment file changed on disk. Reload before saving your edits.',
+      }, 409)
+    }
+
+    return Response.json(
+      {
+        success: true,
+        environment: result.state,
+      },
+      { headers: { 'Cache-Control': 'no-store', Pragma: 'no-cache' } },
+    )
+  },
+})

package/app/Actions/Dashboard/Infrastructure/InsightsAction.ts

@@ -1,28 +1,251 @@
+import process from 'node:process'
+import { stat, statfs } from 'node:fs/promises'
+import { resolve } from 'node:path'
 import { Action } from '@stacksjs/actions'
+import { cache } from '@stacksjs/cache'
+import { config } from '@stacksjs/config'
+import { db } from '@stacksjs/database'
+import { checkQueueHealth } from '@stacksjs/queue'
+import {
+  compactSql,
+  countValue,
+  filesystemUsage,
+  finiteNumber,
+  percent,
+  safeRequestPath,
+  summarizeStatuses,
+  type NumericSummaryRow,
+  type StatusCountRow,
+} from './insights-dashboard'
+
+interface SourceResult<T> {
+  value: T
+  error: string
+}
+
+async function inspectSource<T>(work: Promise<T>, fallback: T): Promise<SourceResult<T>> {
+  try {
+    return { value: await work, error: '' }
+  }
+  catch (error) {
+    return {
+      value: fallback,
+      error: error instanceof Error ? error.message : 'The source could not be inspected.',
+    }
+  }
+}
 
 export default new Action({
   name: 'InsightsAction',
-  description: 'Returns performance and infrastructure insights for the dashboard.',
+  description: 'Returns persisted observations and current infrastructure telemetry for the dashboard.',
   method: 'GET',
+  apiResponse: true,
+
   async handle() {
+    const startedAt = performance.now()
+    const slowThresholdMs = Math.max(0, Number(config.database?.queryLogging?.slowThreshold || 100))
+    const memory = process.memoryUsage()
+    const cpu = process.cpuUsage()
+    const databaseDriver = String(config.database?.default || 'unknown')
+
+    const requestSummaryQuery = db
+      .selectFrom('requests')
+      .select([
+        db.fn.count('id').as('total'),
+        db.fn.avg('duration_ms').as('average'),
+        db.fn.max('duration_ms').as('maximum'),
+        db.fn.max('created_at').as('latest'),
+      ])
+      .where('deleted_at', 'is', null)
+      .executeTakeFirst() as Promise<NumericSummaryRow | undefined>
+
+    const requestSuccessQuery = db
+      .selectFrom('requests')
+      .select(db.fn.count('id').as('count'))
+      .where('deleted_at', 'is', null)
+      .where('status_code', '<', 400)
+      .executeTakeFirst() as Promise<{ count: number | string } | undefined>
+
+    const slowRequestsQuery = db
+      .selectFrom('requests')
+      .select(['id', 'method', 'path', 'status_code', 'duration_ms', 'created_at'])
+      .where('deleted_at', 'is', null)
+      .orderBy('duration_ms', 'desc')
+      .orderBy('id', 'desc')
+      .limit(5)
+      .execute()
+
+    const querySummaryQuery = db
+      .selectFrom('query_logs')
+      .select([
+        db.fn.count('id').as('total'),
+        db.fn.avg('duration').as('average'),
+        db.fn.max('duration').as('maximum'),
+        db.fn.max('executed_at').as('latest'),
+      ])
+      .executeTakeFirst() as Promise<NumericSummaryRow | undefined>
+
+    const queryStatusesQuery = db
+      .selectFrom('query_logs')
+      .select(['status', db.fn.count('id').as('count')])
+      .groupBy('status')
+      .execute() as Promise<StatusCountRow[]>
+
+    const slowQueriesQuery = db
+      .selectFrom('query_logs')
+      .select(['id', 'query', 'duration', 'status', 'connection', 'executed_at'])
+      .where('duration', '>=', slowThresholdMs)
+      .orderBy('duration', 'desc')
+      .orderBy('id', 'desc')
+      .limit(5)
+      .execute()
+
+    const errorSummaryQuery = db
+      .selectFrom('errors')
+      .select([
+        db.fn.count('id').as('total'),
+        db.fn.max('created_at').as('latest'),
+      ])
+      .executeTakeFirst() as Promise<NumericSummaryRow | undefined>
+
+    const recentErrorsQuery = db
+      .selectFrom('errors')
+      .select(['id', 'type', 'message', 'status', 'created_at'])
+      .orderBy('created_at', 'desc')
+      .orderBy('id', 'desc')
+      .limit(5)
+      .execute()
+
+    const filesystemQuery = statfs(process.cwd())
+    const databaseFileQuery = databaseDriver === 'sqlite'
+      ? stat(resolve(process.cwd(), String(config.database?.connections?.sqlite?.database || 'database/stacks.sqlite')))
+      : Promise.resolve(null)
+
+    const [
+      requestSummary,
+      requestSuccess,
+      slowRequests,
+      querySummary,
+      queryStatuses,
+      slowQueries,
+      errorSummary,
+      recentErrors,
+      queueHealth,
+      cacheStats,
+      filesystem,
+      databaseFile,
+    ] = await Promise.all([
+      inspectSource(requestSummaryQuery, undefined),
+      inspectSource(requestSuccessQuery, undefined),
+      inspectSource(slowRequestsQuery, []),
+      inspectSource(querySummaryQuery, undefined),
+      inspectSource(queryStatusesQuery, []),
+      inspectSource(slowQueriesQuery, []),
+      inspectSource(errorSummaryQuery, undefined),
+      inspectSource(recentErrorsQuery, []),
+      inspectSource(checkQueueHealth(), null),
+      inspectSource(cache.getStats(), null),
+      inspectSource(filesystemQuery, null),
+      inspectSource(databaseFileQuery, null),
+    ])
+
+    const requestTotal = countValue(requestSummary.value?.total)
+    const successfulRequests = countValue(requestSuccess.value?.count)
+    const statusCounts = summarizeStatuses(queryStatuses.value)
+    const filesystemState = filesystem.value
+      ? filesystemUsage(filesystem.value.bsize, filesystem.value.blocks, filesystem.value.bavail)
+      : { totalBytes: 0, availableBytes: 0, usedBytes: 0, usedPercent: 0 }
+
+    const issues = [
+      ['requests', requestSummary.error || requestSuccess.error || slowRequests.error],
+      ['queries', querySummary.error || queryStatuses.error || slowQueries.error],
+      ['errors', errorSummary.error || recentErrors.error],
+      ['queue', queueHealth.error],
+      ['cache', cacheStats.error],
+      ['filesystem', filesystem.error],
+      ['database file', databaseFile.error],
+    ]
+      .filter((entry): entry is [string, string] => Boolean(entry[1]))
+      .map(([source, message]) => ({ source, message }))
+
     return {
-      performance: {
-        avgResponseTime: '18ms',
-        p95ResponseTime: '45ms',
-        p99ResponseTime: '120ms',
-        throughput: '1,234 req/min',
+      sampledAt: new Date().toISOString(),
+      durationMs: Math.max(0, Math.round(performance.now() - startedAt)),
+      issues,
+      requests: {
+        total: requestTotal,
+        successful: successfulRequests,
+        errors: Math.max(0, requestTotal - successfulRequests),
+        successRate: percent(successfulRequests, requestTotal),
+        averageDurationMs: finiteNumber(requestSummary.value?.average),
+        maximumDurationMs: finiteNumber(requestSummary.value?.maximum),
+        latestAt: requestSummary.value?.latest || '',
+        slowest: slowRequests.value.map(row => ({
+          id: countValue(row.id),
+          method: String(row.method || 'GET'),
+          path: safeRequestPath(row.path),
+          statusCode: countValue(row.status_code),
+          durationMs: finiteNumber(row.duration_ms),
+          recordedAt: String(row.created_at || ''),
+        })),
+      },
+      queries: {
+        enabled: config.database?.queryLogging?.enabled === true,
+        slowThresholdMs,
+        total: countValue(querySummary.value?.total),
+        completed: countValue(statusCounts.completed),
+        slow: countValue(statusCounts.slow),
+        failed: countValue(statusCounts.failed),
+        averageDurationMs: finiteNumber(querySummary.value?.average),
+        maximumDurationMs: finiteNumber(querySummary.value?.maximum),
+        latestAt: querySummary.value?.latest || '',
+        slowest: slowQueries.value.map(row => ({
+          id: countValue(row.id),
+          query: compactSql(row.query),
+          durationMs: finiteNumber(row.duration),
+          status: String(row.status || 'completed'),
+          connection: String(row.connection || 'unknown'),
+          executedAt: String(row.executed_at || ''),
+        })),
+      },
+      runtime: {
+        uptimeSeconds: Math.max(0, Math.floor(process.uptime())),
+        cpuUserMs: Math.max(0, cpu.user / 1000),
+        cpuSystemMs: Math.max(0, cpu.system / 1000),
+        cpuTotalMs: Math.max(0, (cpu.user + cpu.system) / 1000),
+        residentMemoryBytes: Math.max(0, memory.rss),
+        heapUsedBytes: Math.max(0, memory.heapUsed),
+        heapTotalBytes: Math.max(0, memory.heapTotal),
+        heapUsedPercent: memory.heapTotal >= memory.heapUsed
+          ? percent(memory.heapUsed, memory.heapTotal)
+          : -1,
+        externalMemoryBytes: Math.max(0, memory.external),
       },
-      database: {
-        avgQueryTime: '2.3ms',
-        slowQueries: 5,
-        totalQueries: 45231,
-        connectionPoolUsage: '35%',
+      storage: {
+        ...filesystemState,
+        databaseDriver,
+        databaseBytes: Math.max(0, finiteNumber(databaseFile.value?.size)),
       },
-      memory: {
-        heapUsed: '128 MB',
-        heapTotal: '256 MB',
-        rss: '312 MB',
-        external: '24 MB',
+      queue: queueHealth.value,
+      cache: cacheStats.value
+        ? {
+            hits: countValue(cacheStats.value.hits),
+            misses: countValue(cacheStats.value.misses),
+            keys: countValue(cacheStats.value.keys),
+            sizeBytes: Math.max(0, finiteNumber(cacheStats.value.size)),
+            hitRate: percent(cacheStats.value.hits, finiteNumber(cacheStats.value.hits) + finiteNumber(cacheStats.value.misses)),
+          }
+        : null,
+      errors: {
+        total: countValue(errorSummary.value?.total),
+        latestAt: errorSummary.value?.latest || '',
+        recent: recentErrors.value.map(row => ({
+          id: countValue(row.id),
+          type: String(row.type || 'Error'),
+          message: String(row.message || ''),
+          status: countValue(row.status),
+          recordedAt: String(row.created_at || ''),
+        })),
       },
     }
   },