@stacksjs/defaults 0.70.58 → 0.70.59

package/app/Actions/Dashboard/Data/UserIndexAction.ts

@@ -0,0 +1,48 @@
+import { Action } from '@stacksjs/actions'
+import { User } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'UserIndexAction',
+  description: 'Returns user data for the dashboard.',
+  method: 'GET',
+  async handle() {
+    const roles = ['All Roles', 'Admin', 'Editor', 'Author', 'Subscriber', 'User']
+
+    try {
+      const allUsers = await User.orderBy('created_at', 'desc').get()
+      const totalUsers = await User.count()
+
+      const users = allUsers.map((u) => {
+        const name = String(u.get('name') || 'Unknown')
+        const initials = name.split(' ').map(n => n[0]).join('').slice(0, 2).toUpperCase()
+        return {
+          name,
+          email: String(u.get('email') || 'N/A'),
+          role: 'User',
+          status: 'active',
+          lastLogin: 'Recently',
+          avatar: initials,
+        }
+      })
+
+      const stats = [
+        { label: 'Total Users', value: String(totalUsers) },
+        { label: 'Active Today', value: String(totalUsers) },
+        { label: 'New This Week', value: String(Math.min(totalUsers, 5)) },
+      ]
+
+      return { users, stats, roles }
+    }
+    catch {
+      return {
+        users: [],
+        stats: [
+          { label: 'Total Users', value: '0' },
+          { label: 'Active Today', value: '0' },
+          { label: 'New This Week', value: '0' },
+        ],
+        roles,
+      }
+    }
+  },
+})

package/app/Actions/Dashboard/Deployments/CreateDeployment.ts

@@ -0,0 +1,11 @@
+import { Action } from '@stacksjs/actions'
+
+export default new Action({
+  name: 'CreateDeployment',
+  description: 'Triggers/creates a new deployment.',
+  apiResponse: true,
+
+  async handle() {
+    //
+  },
+})

package/app/Actions/Dashboard/Deployments/GetAverageDeploymentTime.ts

@@ -0,0 +1,15 @@
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+
+// The original implementation called `Deployment.averageDuration()`,
+// which doesn't exist on the model yet. Returning a placeholder so
+// the route registers cleanly until the aggregation is wired.
+export default new Action({
+  name: 'GetAverageDeploymentTime',
+  description: 'Gets the average deployment time of your application.',
+  apiResponse: true,
+
+  async handle() {
+    return response.json({ average_seconds: null, note: 'Not yet implemented' })
+  },
+})

package/app/Actions/Dashboard/Deployments/GetDeployScript.ts

@@ -0,0 +1,12 @@
+import { Action } from '@stacksjs/actions'
+// import { Deployment } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetDeployScript',
+  description: 'Gets the deploy script used by the application.',
+  apiResponse: true,
+
+  async handle() {
+    // return Deployment.script()
+  },
+})

package/app/Actions/Dashboard/Deployments/GetDeploymentCount.ts

@@ -0,0 +1,12 @@
+import { Action } from '@stacksjs/actions'
+// import { Deployment } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetDeploymentCount',
+  description: 'Gets the total number of deployments.',
+  apiResponse: true,
+
+  async handle() {
+    // return Deployment.count()
+  },
+})

package/app/Actions/Dashboard/Deployments/GetDeploymentLiveTerminalOutput.ts

@@ -0,0 +1,12 @@
+import { Action } from '@stacksjs/actions'
+// import { Deployment } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetDeploymentLiveTerminalOutput',
+  description: 'Gets the live terminal output of the deployment.',
+  apiResponse: true,
+
+  async handle() {
+    // return Deployment.liveTerminalOutput()
+  },
+})

package/app/Actions/Dashboard/Deployments/GetDeployments.ts

@@ -0,0 +1,20 @@
+import { Action } from '@stacksjs/actions'
+import { Deployment } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetDeployments',
+  description: 'Gets your application deployments.',
+  method: 'GET',
+  async handle() {
+    try {
+      const deployments = await Deployment.orderBy('created_at', 'desc').limit(50).get()
+
+      return {
+        deployments: deployments.map(d => d.toJSON()),
+      }
+    }
+    catch {
+      return { deployments: [] }
+    }
+  },
+})

package/app/Actions/Dashboard/Deployments/GetRecentDeployments.ts

@@ -0,0 +1,12 @@
+import { Action } from '@stacksjs/actions'
+// import { Deployment } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetRecentDeployments',
+  description: 'Gets recent deployments.',
+  apiResponse: true,
+
+  async handle() {
+    // return Deployment.recent(3)
+  },
+})

package/app/Actions/Dashboard/Deployments/UpdateDeployScript.ts

@@ -0,0 +1,11 @@
+import { Action } from '@stacksjs/actions'
+
+export default new Action({
+  name: 'UpdateDeployScript',
+  description: 'Updates the deploy script.',
+  apiResponse: true,
+
+  async handle() {
+    //
+  },
+})

package/app/Actions/Dashboard/GetDnsRecords.ts

@@ -0,0 +1,12 @@
+import { Action } from '@stacksjs/actions'
+// import { Dns } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetDnsRecords',
+  description: 'Gets the DNS records.',
+  apiResponse: true,
+
+  async handle() {
+    // return Dns.records()
+  },
+})

package/app/Actions/Dashboard/GetEmailInboxes.ts

@@ -0,0 +1,12 @@
+import { Action } from '@stacksjs/actions'
+// import { Email } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetEmailInboxes',
+  description: 'Gets the email inboxes.',
+  apiResponse: true,
+
+  async handle() {
+    // return Email.inboxes()
+  },
+})

package/app/Actions/Dashboard/GetProjects.ts

@@ -0,0 +1,13 @@
+import { Action } from '@stacksjs/actions'
+// import { Project } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetProjects',
+  description: 'Gets your local Stacks projects.',
+  path: '/projects',
+
+  async handle() {
+    console.log('GetProjects called from Action')
+    // return Project.take(3) // reuse the buddy list:projects command
+  },
+})

package/app/Actions/Dashboard/GetRecentCommits.ts

@@ -0,0 +1,13 @@
+import { Action } from '@stacksjs/actions'
+// import { Commit } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetRecentCommits',
+  description: 'Gets recent commits.',
+  apiResponse: true,
+
+  async handle() {
+    // use git to get the last 3 commits
+    // Commit.recent(3)
+  },
+})

package/app/Actions/Dashboard/Inbox/InboxIndexAction.ts

@@ -0,0 +1,144 @@
+import { readdir, readFile, stat } from 'node:fs/promises'
+import { join } from 'node:path'
+import { Action } from '@stacksjs/actions'
+import { log as logDriver } from '@stacksjs/email'
+import { logsPath } from '@stacksjs/path'
+
+const { LogEmailDriver } = logDriver
+
+interface InboxEntry {
+  id: string
+  source: 'memory' | 'disk'
+  from: string
+  to: string
+  subject: string
+  preview: string
+  sent_at: string
+  has_html: boolean
+  has_text: boolean
+  size: number
+}
+
+function formatAddress(value: unknown): string {
+  if (!value) return ''
+  if (typeof value === 'string') return value
+  if (Array.isArray(value)) return value.map(formatAddress).filter(Boolean).join(', ')
+  const obj = value as { name?: string, address?: string }
+  if (obj.address) return obj.name ? `${obj.name} <${obj.address}>` : obj.address
+  return ''
+}
+
+function makePreview(input?: string): string {
+  if (!input) return ''
+  // Strip HTML and collapse whitespace; preview ~140 chars.
+  const text = input.replace(/<style[\s\S]*?<\/style>/gi, '')
+    .replace(/<script[\s\S]*?<\/script>/gi, '')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+  return text.slice(0, 140)
+}
+
+async function readDiskEntries(): Promise<InboxEntry[]> {
+  const dir = process.env.LOG_MAIL_DIR || logsPath('mail')
+  let names: string[] = []
+  try {
+    names = await readdir(dir)
+  }
+  catch {
+    return []
+  }
+
+  const entries = await Promise.all(
+    names
+      .filter(n => n.endsWith('.html'))
+      .map(async (name) => {
+        const filePath = join(dir, name)
+        try {
+          const [body, info] = await Promise.all([readFile(filePath, 'utf8'), stat(filePath)])
+          // The log driver writes a `<!-- ... -->` header at the top of the file; parse it.
+          const headerMatch = body.match(/<!--([\s\S]*?)-->/)
+          const header = headerMatch?.[1] || ''
+          const grab = (label: string) => {
+            const m = header.match(new RegExp(`${label}:\\s*([^\\n]+)`, 'i'))
+            return (m?.[1] || '').trim()
+          }
+          const subject = grab('Subject') || name.replace(/\.html$/, '')
+          const from = grab('From')
+          const to = grab('To')
+          const stamp = grab('Captured by .* at')
+            // The "Captured by ... at <iso>" line uses a fixed prefix; fall back to mtime.
+            || (header.match(/at\s+([^\n]+)/)?.[1] || '').trim()
+            || info.mtime.toISOString()
+          // Strip the HTML comment so the preview reflects the visible body.
+          const visible = body.replace(/<!--[\s\S]*?-->/, '')
+          return {
+            id: `disk:${name}`,
+            source: 'disk' as const,
+            from,
+            to,
+            subject,
+            preview: makePreview(visible),
+            sent_at: stamp,
+            has_html: visible.trim().startsWith('<') || /<\w/.test(visible),
+            has_text: !!visible.trim(),
+            size: info.size,
+          }
+        }
+        catch {
+          return null
+        }
+      }),
+  )
+
+  return entries.filter((entry): entry is InboxEntry => entry !== null)
+}
+
+export default new Action({
+  name: 'InboxIndexAction',
+  description: 'Returns transactional emails captured by the log mail driver.',
+  method: 'GET',
+  async handle() {
+    // 1) In-memory captured list (live for this process; survives nothing).
+    const memory = LogEmailDriver.captured().map((email, index): InboxEntry => {
+      const html = email.rendered?.html ?? email.html
+      const text = email.rendered?.text ?? email.text
+      return {
+        id: `mem:${index}`,
+        source: 'memory',
+        from: formatAddress(email.from),
+        to: formatAddress(email.to),
+        subject: email.subject || '(no subject)',
+        preview: makePreview(html || text),
+        sent_at: email.sentAt.toISOString(),
+        has_html: Boolean(html),
+        has_text: Boolean(text),
+        size: (html?.length || 0) + (text?.length || 0),
+      }
+    })
+
+    // 2) Disk-rendered files (survive restarts, written by every send).
+    const disk = await readDiskEntries()
+
+    // Disk entries are authoritative across restarts, so prefer them when both
+    // exist for the same subject/timestamp. We dedupe by `subject + sent_at`.
+    const seen = new Set<string>()
+    const merged: InboxEntry[] = []
+    for (const entry of [...disk, ...memory]) {
+      const key = `${entry.subject}|${entry.sent_at}`
+      if (seen.has(key)) continue
+      seen.add(key)
+      merged.push(entry)
+    }
+
+    merged.sort((a, b) => new Date(b.sent_at).getTime() - new Date(a.sent_at).getTime())
+
+    const driver = process.env.MAIL_MAILER || 'log'
+
+    return {
+      driver,
+      total: merged.length,
+      data: merged,
+    }
+  },
+})

package/app/Actions/Dashboard/Inbox/InboxShowAction.ts

@@ -0,0 +1,89 @@
+import { readdir, readFile } from 'node:fs/promises'
+import { basename, join } from 'node:path'
+import { Action } from '@stacksjs/actions'
+import { log as logDriver } from '@stacksjs/email'
+import { logsPath } from '@stacksjs/path'
+import { request } from '@stacksjs/router'
+
+const { LogEmailDriver } = logDriver
+
+function formatAddress(value: unknown): string {
+  if (!value) return ''
+  if (typeof value === 'string') return value
+  if (Array.isArray(value)) return value.map(formatAddress).filter(Boolean).join(', ')
+  const obj = value as { name?: string, address?: string }
+  if (obj.address) return obj.name ? `${obj.name} <${obj.address}>` : obj.address
+  return ''
+}
+
+export default new Action({
+  name: 'InboxShowAction',
+  description: 'Returns the body of a single captured transactional email.',
+  method: 'GET',
+  async handle() {
+    // bun-router exposes route params as `request.params` (Record). The
+    // Stacks `request` proxy returns undefined for any function that doesn't
+    // exist on the underlying request, so older `getParam` callers in the
+    // codebase silently get '' — that's why we read params directly.
+    const id = String((request as any).params?.id || '')
+
+    if (id.startsWith('mem:')) {
+      const idx = Number(id.slice(4))
+      const list = LogEmailDriver.captured()
+      const entry = list[idx]
+      if (!entry) return { error: 'Email not found in memory store' }
+
+      return {
+        id,
+        from: formatAddress(entry.from),
+        to: formatAddress(entry.to),
+        cc: formatAddress(entry.cc),
+        bcc: formatAddress(entry.bcc),
+        subject: entry.subject,
+        sent_at: entry.sentAt.toISOString(),
+        html: entry.rendered?.html ?? entry.html ?? '',
+        text: entry.rendered?.text ?? entry.text ?? '',
+      }
+    }
+
+    if (id.startsWith('disk:')) {
+      // Reject path traversal — only accept the basename, no slashes.
+      const raw = id.slice(5)
+      const safe = basename(raw)
+      if (safe !== raw) return { error: 'Invalid email id' }
+
+      const dir = process.env.LOG_MAIL_DIR || logsPath('mail')
+      try {
+        // Re-list to confirm the file exists in the inbox directory.
+        const names = await readdir(dir)
+        if (!names.includes(safe)) return { error: 'Email not found on disk' }
+
+        const body = await readFile(join(dir, safe), 'utf8')
+        const headerMatch = body.match(/<!--([\s\S]*?)-->/)
+        const header = headerMatch?.[1] || ''
+        const grab = (label: string) => {
+          const m = header.match(new RegExp(`${label}:\\s*([^\\n]+)`, 'i'))
+          return (m?.[1] || '').trim()
+        }
+        const visible = body.replace(/<!--[\s\S]*?-->/, '').trim()
+
+        return {
+          id,
+          from: grab('From'),
+          to: grab('To'),
+          cc: grab('Cc'),
+          bcc: grab('Bcc'),
+          subject: grab('Subject') || safe.replace(/\.html$/, ''),
+          sent_at: (header.match(/at\s+([^\n]+)/)?.[1] || '').trim(),
+          html: visible,
+          text: '',
+        }
+      }
+      catch {
+        return { error: 'Email not found on disk' }
+      }
+    }
+
+    return { error: 'Unknown email id format' }
+  },
+})

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

@@ -0,0 +1,18 @@
+import { Action } from '@stacksjs/actions'
+
+export default new Action({
+  name: 'CommandIndexAction',
+  description: 'Returns command history data for the dashboard.',
+  method: 'GET',
+  async handle() {
+    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' },
+      ],
+    }
+  },
+})

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

@@ -0,0 +1,101 @@
+import { Action } from '@stacksjs/actions'
+import { config } from '@stacksjs/config'
+
+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: [] }
+    }
+  },
+})

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

@@ -0,0 +1,67 @@
+import { Action } from '@stacksjs/actions'
+
+export default new Action({
+  name: 'EnvironmentIndexAction',
+  description: 'Returns environment variable data for the dashboard.',
+  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
+
+      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 }
+  },
+})

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

@@ -0,0 +1,29 @@
+import { Action } from '@stacksjs/actions'
+
+export default new Action({
+  name: 'InsightsAction',
+  description: 'Returns performance and infrastructure insights for the dashboard.',
+  method: 'GET',
+  async handle() {
+    return {
+      performance: {
+        avgResponseTime: '18ms',
+        p95ResponseTime: '45ms',
+        p99ResponseTime: '120ms',
+        throughput: '1,234 req/min',
+      },
+      database: {
+        avgQueryTime: '2.3ms',
+        slowQueries: 5,
+        totalQueries: 45231,
+        connectionPoolUsage: '35%',
+      },
+      memory: {
+        heapUsed: '128 MB',
+        heapTotal: '256 MB',
+        rss: '312 MB',
+        external: '24 MB',
+      },
+    }
+  },
+})