@stacksjs/defaults 0.70.229 → 0.70.230

package/app/Actions/Dashboard/Infrastructure/log-dashboard.ts

@@ -0,0 +1,94 @@
+type DataRecord = Record<string, unknown>
+
+export const DASHBOARD_LOG_TYPES = ['error', 'warning', 'info', 'success'] as const
+
+export type DashboardLogType = typeof DASHBOARD_LOG_TYPES[number] | 'unknown'
+
+export interface DashboardLogRecord {
+  id: number
+  timestamp: string
+  type: DashboardLogType
+  source: string
+  message: string
+  project: string
+  stacktrace: string
+  file: string
+  createdAt: string
+  updatedAt: string
+}
+
+export interface DashboardLogSummary {
+  total: number
+  error: number
+  warning: number
+  info: number
+  success: number
+}
+
+function numberValue(value: unknown): number {
+  const normalized = Number(value)
+  return Number.isFinite(normalized) ? normalized : 0
+}
+
+function textValue(value: unknown): string {
+  return typeof value === 'string' ? value : value === null || value === undefined ? '' : String(value)
+}
+
+function dateValue(value: unknown, fallback: unknown): string {
+  const candidate = typeof value === 'number' || (typeof value === 'string' && /^\d+$/.test(value))
+    ? new Date(Number(value))
+    : new Date(textValue(value))
+  if (!Number.isNaN(candidate.getTime()))
+    return candidate.toISOString()
+
+  const fallbackDate = new Date(textValue(fallback))
+  return Number.isNaN(fallbackDate.getTime()) ? '' : fallbackDate.toISOString()
+}
+
+function logType(value: unknown): DashboardLogType {
+  const normalized = textValue(value).toLowerCase()
+  return DASHBOARD_LOG_TYPES.includes(normalized as typeof DASHBOARD_LOG_TYPES[number])
+    ? normalized as typeof DASHBOARD_LOG_TYPES[number]
+    : 'unknown'
+}
+
+export function normalizeDashboardLog(value: unknown): DashboardLogRecord {
+  const row = value && typeof value === 'object' && !Array.isArray(value)
+    ? value as DataRecord
+    : {}
+  const createdAt = textValue(row.created_at)
+
+  return {
+    id: numberValue(row.id),
+    timestamp: dateValue(row.timestamp, createdAt),
+    type: logType(row.type),
+    source: textValue(row.source),
+    message: textValue(row.message),
+    project: textValue(row.project),
+    stacktrace: textValue(row.stacktrace),
+    file: textValue(row.file),
+    createdAt,
+    updatedAt: textValue(row.updated_at),
+  }
+}
+
+export function summarizeDashboardLogTypes(
+  rows: Array<{ type: unknown, count: unknown }>,
+  total: unknown,
+): DashboardLogSummary {
+  const summary: DashboardLogSummary = {
+    total: numberValue(total),
+    error: 0,
+    warning: 0,
+    info: 0,
+    success: 0,
+  }
+
+  for (const row of rows) {
+    const type = logType(row.type)
+    if (type !== 'unknown')
+      summary[type] = numberValue(row.count)
+  }
+
+  return summary
+}

package/app/Actions/Dashboard/Infrastructure/mailbox-overview.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, test } from 'bun:test'
+import { getDashboardMailboxSnapshot } from './mailbox-overview'
+
+describe('dashboard mailbox overview', () => {
+  test('reports configured mail infrastructure without invented activity', () => {
+    const snapshot = getDashboardMailboxSnapshot({
+      domain: 'example.test',
+      mailboxes: ['hello', 'support@example.test', { email: 'billing' }, {}],
+      from: { name: 'Example', address: 'hello@example.test' },
+      forwards: {
+        'team@example.test': ['hello@example.test'],
+      },
+      server: {
+        enabled: true,
+        mode: 'server',
+        scan: true,
+        subdomain: 'mail',
+        features: { imap: true, webmail: false, ignored: 'yes' },
+        ports: { smtp: 25, imaps: 993, ignored: '443' },
+        storage: { retentionDays: 90, archive: true, ignored: {} },
+      },
+    }, () => new Date('2026-07-30T12:00:00.000Z'))
+
+    expect(snapshot.mailboxes.map(mailbox => mailbox.email)).toEqual([
+      'hello@example.test',
+      'support@example.test',
+      'billing@example.test',
+    ])
+    expect(snapshot.domains[0]).toEqual({
+      domain: 'example.test',
+      subdomain: 'mail.example.test',
+      status: 'configured',
+    })
+    expect(snapshot.server.features).toEqual([
+      { name: 'imap', enabled: true },
+      { name: 'webmail', enabled: false },
+    ])
+    expect(snapshot.server.ports).toEqual([
+      { name: 'smtp', port: 25 },
+      { name: 'imaps', port: 993 },
+    ])
+    expect(snapshot.server.storage).toEqual([
+      { name: 'retentionDays', value: '90' },
+      { name: 'archive', value: 'true' },
+    ])
+    expect(snapshot.generatedAt).toBe('2026-07-30T12:00:00.000Z')
+  })
+
+  test('keeps absent configuration empty', () => {
+    const snapshot = getDashboardMailboxSnapshot(null)
+    expect(snapshot.mailboxes).toEqual([])
+    expect(snapshot.domains).toEqual([])
+    expect(snapshot.forwards).toEqual([])
+    expect(snapshot.server.enabled).toBe(false)
+    expect(snapshot.server.mode).toBeNull()
+  })
+})

package/app/Actions/Dashboard/Infrastructure/mailbox-overview.ts

@@ -0,0 +1,150 @@
+type DataRecord = Record<string, unknown>
+
+export interface DashboardMailbox {
+  id: string
+  email: string
+  username: string
+  status: 'configured'
+}
+
+export interface DashboardMailboxDomain {
+  domain: string
+  subdomain: string | null
+  status: 'configured'
+}
+
+export interface DashboardMailboxFeature {
+  name: string
+  enabled: boolean
+}
+
+export interface DashboardMailboxPort {
+  name: string
+  port: number
+}
+
+export interface DashboardMailboxStorage {
+  name: string
+  value: string
+}
+
+export interface DashboardMailboxForward {
+  source: string
+  destinations: string[]
+}
+
+export interface DashboardMailboxSnapshot {
+  mailboxes: DashboardMailbox[]
+  domains: DashboardMailboxDomain[]
+  from: {
+    name: string | null
+    address: string | null
+  }
+  server: {
+    enabled: boolean
+    mode: string | null
+    scan: boolean
+    features: DashboardMailboxFeature[]
+    ports: DashboardMailboxPort[]
+    storage: DashboardMailboxStorage[]
+  }
+  forwards: DashboardMailboxForward[]
+  generatedAt: string
+}
+
+function record(value: unknown): DataRecord {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? value as DataRecord
+    : {}
+}
+
+function text(value: unknown): string | null {
+  return typeof value === 'string' && value.trim() ? value.trim() : null
+}
+
+function mailboxAddress(value: string, domain: string | null): string {
+  return value.includes('@') || !domain ? value : `${value}@${domain}`
+}
+
+function configuredMailboxes(emailConfig: DataRecord, domain: string | null): DashboardMailbox[] {
+  if (!Array.isArray(emailConfig.mailboxes))
+    return []
+
+  return emailConfig.mailboxes.flatMap((entry, index) => {
+    const rawEmail = typeof entry === 'string'
+      ? text(entry)
+      : text(record(entry).email)
+    if (!rawEmail)
+      return []
+    const email = mailboxAddress(rawEmail, domain)
+    return [{
+      id: `mailbox:${index}`,
+      email,
+      username: email.split('@')[0] || email,
+      status: 'configured' as const,
+    }]
+  })
+}
+
+function stringValue(value: unknown): string | null {
+  if (typeof value === 'string')
+    return value
+  if (typeof value === 'number' || typeof value === 'boolean')
+    return String(value)
+  return null
+}
+
+export function getDashboardMailboxSnapshot(
+  value: unknown,
+  now: () => Date = () => new Date(),
+): DashboardMailboxSnapshot {
+  const emailConfig = record(value)
+  const server = record(emailConfig.server)
+  const domain = text(emailConfig.domain)
+  const subdomain = text(server.subdomain)
+  const from = record(emailConfig.from)
+  const features = record(server.features)
+  const ports = record(server.ports)
+  const storage = record(server.storage)
+  const forwards = record(emailConfig.forwards)
+
+  return {
+    mailboxes: configuredMailboxes(emailConfig, domain),
+    domains: domain
+      ? [{
+          domain,
+          subdomain: subdomain ? `${subdomain}.${domain}` : null,
+          status: 'configured',
+        }]
+      : [],
+    from: {
+      name: text(from.name),
+      address: text(from.address),
+    },
+    server: {
+      enabled: server.enabled === true,
+      mode: text(server.mode),
+      scan: server.scan === true,
+      features: Object.entries(features)
+        .filter(([, enabled]) => typeof enabled === 'boolean')
+        .map(([name, enabled]) => ({ name, enabled: enabled === true })),
+      ports: Object.entries(ports)
+        .filter(([, port]) => typeof port === 'number' && Number.isFinite(port))
+        .map(([name, port]) => ({ name, port: port as number })),
+      storage: Object.entries(storage)
+        .map(([name, storageValue]) => {
+          const normalized = stringValue(storageValue)
+          return normalized === null ? null : { name, value: normalized }
+        })
+        .filter((item): item is DashboardMailboxStorage => item !== null),
+    },
+    forwards: Object.entries(forwards)
+      .map(([source, destinations]) => ({
+        source,
+        destinations: Array.isArray(destinations)
+          ? destinations.map(text).filter((destination): destination is string => Boolean(destination))
+          : [],
+      })),
+    generatedAt: now().toISOString(),
+  }
+}

package/app/Actions/Dashboard/Infrastructure/server-detail.test.ts

@@ -0,0 +1,77 @@
+import type { DashboardCloudSnapshot } from '../Cloud/cloud-overview'
+import { describe, expect, test } from 'bun:test'
+import { resolveDashboardServer } from './server-detail'
+
+const snapshot: DashboardCloudSnapshot = {
+  project: {
+    name: 'Stacks',
+    slug: 'stacks',
+    mode: 'server',
+    provider: 'hetzner',
+    region: 'ash',
+  },
+  environments: [{
+    name: 'production',
+    type: 'production',
+    branch: 'main',
+    domain: 'stacks.test',
+    region: 'ash',
+    serverless: false,
+    status: 'deployed',
+  }],
+  serverDefinitions: [{
+    id: 'server:compute',
+    key: 'compute',
+    name: 'Application compute',
+    role: 'app',
+    region: 'ash',
+    size: 'cpx22',
+    instances: 1,
+    diskGb: 40,
+    diskType: 'local',
+    encrypted: true,
+    domain: null,
+    operatingSystem: null,
+    bunVersion: null,
+    database: 'sqlite',
+    status: 'configured',
+  }],
+  deployments: [{
+    id: 'deployment:stacks-production',
+    stackName: 'stacks-production',
+    environment: 'production',
+    serverName: 'stacks-app',
+    provider: 'hetzner',
+    publicIp: '203.0.113.10',
+    publicIpv6: null,
+    sshUser: 'deploy',
+    recordedAt: '2026-07-29T12:00:00.000Z',
+    status: 'deployed',
+    operation: null,
+  }],
+  resources: [],
+  serverlessServices: [],
+  serverlessLinks: [],
+  events: [],
+  generatedAt: '2026-07-29T12:00:00.000Z',
+}
+
+describe('resolveDashboardServer', () => {
+  test('resolves server definitions by key or stable id', () => {
+    expect(resolveDashboardServer(snapshot, 'compute')?.server?.name).toBe('Application compute')
+    expect(resolveDashboardServer(snapshot, 'server%3Acompute')?.kind).toBe('configuration')
+  })
+
+  test('resolves deployments by stack name or encoded stable id', () => {
+    expect(resolveDashboardServer(snapshot, 'stacks-production')?.deployment?.serverName).toBe('stacks-app')
+    const detail = resolveDashboardServer(snapshot, 'deployment%3Astacks-production')
+    expect(detail?.kind).toBe('deployment')
+    expect(detail?.environment?.name).toBe('production')
+  })
+
+  test('does not invent records for malformed or unknown identifiers', () => {
+    expect(resolveDashboardServer(snapshot, '%')).toBeNull()
+    expect(resolveDashboardServer(snapshot, 'missing')).toBeNull()
+    expect(resolveDashboardServer(snapshot, '')).toBeNull()
+  })
+})

package/app/Actions/Dashboard/Infrastructure/server-detail.ts

@@ -0,0 +1,64 @@
+import type {
+  DashboardCloudEnvironment,
+  DashboardCloudSnapshot,
+  DashboardServerDefinition,
+  DashboardServerDeployment,
+} from '../Cloud/cloud-overview'
+
+export interface DashboardServerDetail {
+  kind: 'configuration' | 'deployment'
+  server: DashboardServerDefinition | null
+  deployment: DashboardServerDeployment | null
+  environment: DashboardCloudEnvironment | null
+}
+
+function decodeIdentifier(value: string): string | null {
+  const identifier = value.trim()
+  if (!identifier)
+    return null
+
+  try {
+    return decodeURIComponent(identifier)
+  }
+  catch {
+    return null
+  }
+}
+
+export function resolveDashboardServer(
+  snapshot: DashboardCloudSnapshot,
+  rawIdentifier: string,
+): DashboardServerDetail | null {
+  const identifier = decodeIdentifier(rawIdentifier)
+  if (!identifier)
+    return null
+
+  const server = snapshot.serverDefinitions.find(definition =>
+    definition.id === identifier
+    || definition.key === identifier,
+  )
+  if (server) {
+    return {
+      kind: 'configuration',
+      server,
+      deployment: null,
+      environment: null,
+    }
+  }
+
+  const deployment = snapshot.deployments.find(item =>
+    item.id === identifier
+    || item.stackName === identifier,
+  )
+  if (!deployment)
+    return null
+
+  return {
+    kind: 'deployment',
+    server: null,
+    deployment,
+    environment: deployment.environment
+      ? snapshot.environments.find(environment => environment.name === deployment.environment) ?? null
+      : null,
+  }
+}

package/app/Actions/Dashboard/Jobs/JobIndexAction.ts

@@ -1,43 +1,7 @@
 import { Action } from '@stacksjs/actions'
 import { FailedJob, Job } from '@stacksjs/orm'
-import { request } from '@stacksjs/router'
-
-interface NormalizedJob {
-  id: string
-  name: string
-  queue: string
-  status: 'queued' | 'processing' | 'completed' | 'failed'
-  attempts: number
-  maxAttempts: number
-  duration: string
-  runtime?: number
-  error?: string
-  payload: unknown
-  created_at: string
-  started_at?: string
-  finished_at?: string
-}
-
-const STATUS_MAP: Record<string, NormalizedJob['status']> = {
-  pending: 'queued',
-  waiting: 'queued',
-  queued: 'queued',
-  active: 'processing',
-  processing: 'processing',
-  done: 'completed',
-  completed: 'completed',
-  failed: 'failed',
-}
-
-function safeParse(payload: unknown): unknown {
-  if (typeof payload !== 'string') return payload ?? null
-  try {
-    return JSON.parse(payload)
-  }
-  catch {
-    return payload
-  }
-}
+import { request, response } from '@stacksjs/router'
+import { matchesJobSearch, normalizeActiveJob, normalizeFailedJob } from './job-records'
 
 export default new Action({
   name: 'JobIndexAction',
@@ -64,52 +28,8 @@ export default new Action({
         FailedJob.orderByDesc('id').get(),
       ])
 
-      const activeNormalized: NormalizedJob[] = activeJobs.map((j) => {
-        const rawStatus = String(j.get('status') || 'pending').toLowerCase()
-        const status = STATUS_MAP[rawStatus] || 'queued'
-        const payload = safeParse(j.get('payload'))
-        const name = String(
-          (payload && typeof payload === 'object' && (payload as { displayName?: string }).displayName)
-          || j.get('name')
-          || j.get('queue')
-          || 'Job',
-        )
-        const duration = j.get('duration') ? `${j.get('duration')}ms` : '-'
-        return {
-          id: String(j.get('id') ?? ''),
-          name,
-          queue: String(j.get('queue') || 'default'),
-          status,
-          attempts: Number(j.get('attempts') || 0),
-          maxAttempts: Number(j.get('max_attempts') || 3),
-          duration,
-          runtime: Number(j.get('duration') || 0),
-          payload,
-          created_at: String(j.get('created_at') || ''),
-        }
-      })
-
-      const failedNormalized: NormalizedJob[] = failedJobs.map((f) => {
-        const payload = safeParse(f.get('payload'))
-        const name = String(
-          (payload && typeof payload === 'object' && (payload as { displayName?: string }).displayName)
-          || f.get('queue')
-          || 'Failed job',
-        )
-        return {
-          id: String(f.get('id') ?? ''),
-          name,
-          queue: String(f.get('queue') || 'default'),
-          status: 'failed',
-          attempts: Number(f.get('attempts') || 0),
-          maxAttempts: Number(f.get('max_attempts') || 3),
-          duration: '-',
-          error: String(f.get('exception') || ''),
-          payload,
-          created_at: String(f.get('failed_at') || f.get('created_at') || ''),
-          finished_at: String(f.get('failed_at') || ''),
-        }
-      })
+      const activeNormalized = activeJobs.map(normalizeActiveJob)
+      const failedNormalized = failedJobs.map(normalizeFailedJob)
 
       const merged = [...activeNormalized, ...failedNormalized].sort((a, b) =>
         new Date(b.created_at).getTime() - new Date(a.created_at).getTime(),
@@ -118,7 +38,7 @@ export default new Action({
       const filtered = merged.filter((job) => {
         if (queueFilter && queueFilter !== 'all' && job.queue !== queueFilter) return false
         if (statusFilter && statusFilter !== 'all' && job.status !== statusFilter) return false
-        if (search && !job.name.toLowerCase().includes(search)) return false
+        if (!matchesJobSearch(job, search)) return false
         return true
       })
 
@@ -129,8 +49,10 @@ export default new Action({
 
       return { data, total, page, perPage, queues, queueConnected: true }
     }
-    catch {
-      return { data: [], total: 0, page, perPage, queues: [], queueConnected: false }
+    catch (error) {
+      return response.json({
+        message: error instanceof Error ? error.message : 'Job history could not be loaded.',
+      }, 503)
     }
   },
 })

package/app/Actions/Dashboard/Jobs/JobRetryAction.ts

@@ -1,15 +1,21 @@
 import { Action } from '@stacksjs/actions'
-import { request } from '@stacksjs/router'
+import { request, response } from '@stacksjs/router'
 import { retryFailedJob } from '@stacksjs/queue'
+import { parseJobReference } from './job-records'
 
 export default new Action({
   name: 'JobRetryAction',
   description: 'Retries a single failed job by its failed_jobs id.',
   method: 'POST',
   async handle() {
-    const id = Number((request as any).params?.id)
+    const reference = String((request as any).params?.id || '')
+    const parsed = parseJobReference(reference)
+    const id = Number(parsed.id)
+    if (parsed.source === 'job') {
+      return response.json({ message: 'Only failed jobs can be retried.' }, 409)
+    }
     if (!Number.isFinite(id) || id <= 0) {
-      return { success: false, message: 'Invalid job id' }
+      return response.json({ message: 'Job id must identify a failed job.' }, 422)
     }
 
     try {
@@ -17,7 +23,8 @@ export default new Action({
       return { success: true, message: `Job ${id} re-queued` }
     }
     catch (e) {
-      return { success: false, message: (e as Error).message || 'Retry failed' }
+      const message = (e as Error).message || 'Failed job could not be retried.'
+      return response.json({ message }, message.includes('not found') ? 404 : 500)
     }
   },
 })

package/app/Actions/Dashboard/Jobs/JobShowAction.ts

@@ -0,0 +1,43 @@
+import { Action } from '@stacksjs/actions'
+import { FailedJob, Job } from '@stacksjs/orm'
+import { request } from '@stacksjs/router'
+import { normalizeActiveJob, normalizeFailedJob, parseJobReference } from './job-records'
+
+export default new Action({
+  name: 'JobShowAction',
+  description: 'Returns one native Job or FailedJob record for dashboard inspection.',
+  method: 'GET',
+  async handle() {
+    const reference = String((request as any).params?.id || '')
+    const parsed = parseJobReference(reference)
+    const id = Number(parsed.id)
+
+    if (!Number.isFinite(id) || id <= 0)
+      return { job: null, error: 'Invalid job id.' }
+
+    try {
+      if (parsed.source === 'failed') {
+        const record = await FailedJob.find(id)
+        return { job: record ? normalizeFailedJob(record) : null }
+      }
+
+      if (parsed.source === 'job') {
+        const record = await Job.find(id)
+        return { job: record ? normalizeActiveJob(record) : null }
+      }
+
+      const activeRecord = await Job.find(id)
+      if (activeRecord)
+        return { job: normalizeActiveJob(activeRecord) }
+
+      const failedRecord = await FailedJob.find(id)
+      return { job: failedRecord ? normalizeFailedJob(failedRecord) : null }
+    }
+    catch (error) {
+      return {
+        job: null,
+        error: error instanceof Error ? error.message : 'Job could not be loaded.',
+      }
+    }
+  },
+})

package/app/Actions/Dashboard/Jobs/JobStatsAction.ts

@@ -1,6 +1,7 @@
 import { Action } from '@stacksjs/actions'
 import { FailedJob, Job } from '@stacksjs/orm'
 import { getGlobalMetrics } from '@stacksjs/queue'
+import { response } from '@stacksjs/router'
 
 export default new Action({
   name: 'JobStatsAction',
@@ -36,14 +37,10 @@ export default new Action({
         // from a dedicated endpoint.
       }
     }
-    catch {
-      return {
-        totalJobs: 0,
-        totalFailed: 0,
-        avgProcessingTime: '0ms',
-        jobsPerMinute: 0,
-        failureRate: '0%',
-      }
+    catch (error) {
+      return response.json({
+        message: error instanceof Error ? error.message : 'Job metrics could not be loaded.',
+      }, 503)
     }
   },
 })