@stacksjs/defaults 0.70.229 → 0.70.231

package/functions/inbox.ts

@@ -1,12 +1,248 @@
 /**
  * Inbox Composable
  *
- * Reads captured transactional emails from the framework's mail log driver
- * (in-memory + storage/logs/mail/*.html) for the dashboard inbox view.
+ * Reads inbound mailbox messages and exposes inbox actions for the dashboard.
  */
 
 import { ref } from '@stacksjs/stx'
 import { get } from './api'
+import { dashboardApi } from './dashboard-api'
+import { pushToast } from './toasts'
+
+export type InboxActivityRange = 'day' | 'week' | 'month' | 'year'
+
+export interface InboxActivity {
+  mailbox: string
+  range: InboxActivityRange
+  period: {
+    start: string
+    end: string
+  }
+  stats: {
+    messages: number
+    unread: number
+    failed: number
+    attachments: number
+    message_change: number | null
+    unread_rate: number
+  }
+  folder_counts: Record<'inbox' | 'starred' | 'sent' | 'drafts' | 'archive' | 'spam' | 'trash', number>
+  mailbox_state: {
+    read: number
+    unread: number
+  }
+  delivery_statuses: {
+    sent: number
+    delivered: number
+    failed: number
+    pending: number
+  }
+  series: Array<{
+    key: string
+    label: string
+    received: number
+    sent: number
+    failed: number
+  }>
+  recent: Array<{
+    id: string
+    direction: 'received' | 'sent'
+    subject: string
+    correspondent: string
+    occurred_at: string
+    status: string
+  }>
+}
+
+export interface InboxSendInput {
+  to: string
+  subject: string
+  body: string
+}
+
+export interface DashboardInboxEmail {
+  id: string
+  from: string
+  email: string
+  subject: string
+  preview: string
+  bodyHtml: string
+  bodyText: string
+  date: string
+  read: boolean
+  hasAttachments: boolean
+}
+
+interface DashboardInboxEntry {
+  messageId: string
+  from: string
+  fromName?: string
+  subject?: string
+  preview?: string
+  date: string
+  read?: boolean
+  hasAttachments?: boolean
+}
+
+interface DashboardInboxResponse {
+  mailbox?: string
+  total?: number
+  emails?: DashboardInboxEntry[]
+  error?: string
+}
+
+interface DashboardInboxBodyResponse {
+  html?: string
+  text?: string
+  error?: string
+}
+
+interface InboxMutationResult {
+  success: boolean
+  mailbox?: string
+  messageId?: string
+}
+
+export interface LoadedDashboardInbox {
+  mailbox: string
+  emails: DashboardInboxEmail[]
+  error: string
+}
+
+export function parseInboxSender(from: string, fromName = ''): { name: string; email: string } {
+  const match = from.match(/^"?([^"<]+)"?\s*<([^>]+)>$/)
+  const matchedName = match?.[1]
+  const matchedEmail = match?.[2]
+  if (matchedName && matchedEmail)
+    return { name: fromName.trim() || matchedName.trim(), email: matchedEmail.trim() }
+  return { name: fromName.trim() || from, email: from }
+}
+
+export function normalizeInboxPreview(preview: string, maxLength = 200): string {
+  let result = preview.trim().replace(/^[-=_]{2,}[^\s]*\s+/, '')
+
+  for (let pass = 0; pass < 6; pass++) {
+    const next = result
+      .replace(/^content-transfer-encoding:\s*[^\s]+\s*/i, '')
+      .replace(/^mime-version:\s*[^\s]+\s*/i, '')
+      .replace(/^content-description:\s*[^\s]+\s*/i, '')
+      .replace(/^content-type:\s*[^\s;]+(?:;\s*(?:charset|boundary|name)\s*=\s*(?:"[^"]*"|[^\s]+))*\s*/i, '')
+    if (next === result)
+      break
+    result = next
+  }
+
+  const encoded = result.replace(/^[-=_]{4,}[^\s]*\s*/, '').replace(/=\r?\n/g, '')
+  const bytes: number[] = []
+  const encoder = new TextEncoder()
+  for (let index = 0; index < encoded.length; index++) {
+    const token = encoded.slice(index, index + 3)
+    if (/^=[0-9a-f]{2}$/i.test(token)) {
+      bytes.push(Number.parseInt(token.slice(1), 16))
+      index += 2
+    }
+    else {
+      bytes.push(...encoder.encode(encoded[index]!))
+    }
+  }
+
+  return new TextDecoder().decode(Uint8Array.from(bytes))
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, maxLength)
+}
+
+export function mapDashboardInboxEntry(item: DashboardInboxEntry): DashboardInboxEmail {
+  const sender = parseInboxSender(item.from || '', item.fromName || '')
+  return {
+    id: item.messageId,
+    from: sender.name || sender.email,
+    email: sender.email,
+    subject: item.subject || '(no subject)',
+    preview: normalizeInboxPreview(item.preview || ''),
+    bodyHtml: '',
+    bodyText: '',
+    date: item.date,
+    read: item.read === true,
+    hasAttachments: item.hasAttachments === true,
+  }
+}
+
+export async function fetchDashboardInbox(mailbox?: string): Promise<LoadedDashboardInbox> {
+  const query = mailbox ? `?mailbox=${encodeURIComponent(mailbox)}` : ''
+  const data = await dashboardApi<DashboardInboxResponse>(`/api/dashboard/email/inbox${query}`)
+  return {
+    mailbox: data.mailbox || mailbox || '',
+    emails: (data.emails || []).map(mapDashboardInboxEntry),
+    error: data.error || '',
+  }
+}
+
+export async function fetchDashboardInboxBody(messageId: string, mailbox?: string): Promise<Pick<DashboardInboxEmail, 'bodyHtml' | 'bodyText'>> {
+  const query = mailbox ? `?mailbox=${encodeURIComponent(mailbox)}` : ''
+  const data = await dashboardApi<DashboardInboxBodyResponse>(`/api/dashboard/email/inbox/${encodeURIComponent(messageId)}${query}`)
+  if (data.error)
+    throw new Error(data.error)
+  return {
+    bodyHtml: data.html || '',
+    bodyText: data.text || '',
+  }
+}
+
+export async function fetchInboxActivity(range: InboxActivityRange): Promise<InboxActivity | null> {
+  try {
+    return await dashboardApi<InboxActivity>(`/api/dashboard/email/activity?range=${range}`)
+  }
+  catch (error) {
+    pushToast('error', 'Could not load mail activity', { detail: String(error) })
+    return null
+  }
+}
+
+export async function sendInboxEmail(input: InboxSendInput): Promise<boolean> {
+  try {
+    await dashboardApi<InboxMutationResult>('/api/dashboard/email/send', {
+      method: 'POST',
+      body: input,
+    })
+    pushToast('success', 'Email sent', { detail: `Delivered to ${input.to}` })
+    return true
+  }
+  catch (error) {
+    pushToast('error', 'Could not send email', { detail: String(error) })
+    return false
+  }
+}
+
+export async function setInboxEmailReadState(messageId: string, read: boolean, mailbox?: string): Promise<boolean> {
+  try {
+    await dashboardApi<InboxMutationResult>(`/api/dashboard/email/${read ? 'read' : 'unread'}`, {
+      method: 'POST',
+      body: { messageId, ...(mailbox ? { mailbox } : {}) },
+    })
+    return true
+  }
+  catch (error) {
+    pushToast('error', `Could not mark email as ${read ? 'read' : 'unread'}`, { detail: String(error) })
+    return false
+  }
+}
+
+export async function deleteInboxEmail(messageId: string, mailbox?: string): Promise<boolean> {
+  try {
+    const query = mailbox ? `?mailbox=${encodeURIComponent(mailbox)}` : ''
+    await dashboardApi<InboxMutationResult>(`/api/dashboard/email/inbox/${encodeURIComponent(messageId)}${query}`, {
+      method: 'DELETE',
+    })
+    pushToast('success', 'Email deleted')
+    return true
+  }
+  catch (error) {
+    pushToast('error', 'Could not delete email', { detail: String(error) })
+    return false
+  }
+}
 
 export interface InboxEntry {
   id: string

package/functions/jobs.ts

@@ -1,76 +1,138 @@
-/**
- * Jobs Composable
- *
- * Provides data fetching for job history and queue management.
- */
-
 import { ref } from '@stacksjs/stx'
-import { get, post } from './api'
+import { dashboardApi } from './dashboard-api'
+
+export type JobStatus = 'queued' | 'processing' | 'failed'
 
-export interface JobHistoryEntry {
+export interface DashboardJob {
   id: string
+  recordId: string
+  source: 'job' | 'failed'
   name: string
   queue: string
-  status: 'queued' | 'processing' | 'failed' | 'completed'
-  attempts: number
-  runtime?: number
+  connection: string | null
+  status: JobStatus
+  attempts: number | null
+  maxAttempts: number | null
+  duration: string | null
+  runtime: number | null
+  error?: string
+  payload: unknown
+  created_at: string
+  updated_at?: string
+  available_at?: string
+  reserved_at?: string
   started_at?: string
   finished_at?: string
+}
+
+export interface JobListResponse {
+  data: DashboardJob[]
+  total: number
+  page: number
+  perPage: number
+  queues: string[]
+  queueConnected: boolean
+}
+
+export interface JobStatsResponse {
+  totalJobs: number
+  totalFailed: number
+  avgProcessingTime: string
+  jobsPerMinute: number
+  failureRate: string
+}
+
+export interface JobListFilters {
+  page?: number
+  perPage?: number
+  queue?: string
+  status?: string
+  search?: string
+}
+
+export interface JobShowResponse {
+  job: DashboardJob | null
   error?: string
-  payload: any
 }
 
+export async function fetchJobs(filters: JobListFilters = {}): Promise<JobListResponse> {
+  const query = new URLSearchParams()
+  if (filters.page)
+    query.set('page', String(filters.page))
+  if (filters.perPage)
+    query.set('per_page', String(filters.perPage))
+  if (filters.queue && filters.queue !== 'all')
+    query.set('queue', filters.queue)
+  if (filters.status && filters.status !== 'all')
+    query.set('status', filters.status)
+  if (filters.search)
+    query.set('search', filters.search)
+  const suffix = query.size > 0 ? `?${query.toString()}` : ''
+  return await dashboardApi<JobListResponse>(`/api/dashboard/jobs${suffix}`)
+}
+
+export async function fetchJobStats(): Promise<JobStatsResponse> {
+  return await dashboardApi<JobStatsResponse>('/api/dashboard/jobs/stats')
+}
+
+export async function fetchJob(id: string): Promise<JobShowResponse> {
+  return await dashboardApi<JobShowResponse>(`/api/dashboard/jobs/${encodeURIComponent(id)}`)
+}
+
+export async function retryJob(id: string): Promise<{ success: boolean, message: string }> {
+  return await dashboardApi<{ success: boolean, message: string }>(`/api/dashboard/jobs/${encodeURIComponent(id)}/retry`, {
+    method: 'POST',
+  })
+}
+
+export async function retryFailedJobs(): Promise<{ success: boolean, message: string, count: number }> {
+  return await dashboardApi<{ success: boolean, message: string, count: number }>('/api/dashboard/queue/retry-failed', {
+    method: 'POST',
+  })
+}
+
+/** Backwards-compatible alias for dashboard consumers using the older composable. */
+export type JobHistoryEntry = DashboardJob
+
 export function useJobs() {
-  const jobs = ref<JobHistoryEntry[]>([])
+  const jobs = ref<DashboardJob[]>([])
   const totalJobs = ref(0)
   const isLoading = ref(false)
   const error = ref<string | null>(null)
 
-  async function fetchJobs(params?: { page?: number, perPage?: number, queue?: string, status?: string, search?: string }) {
+  async function loadJobs(filters: JobListFilters = {}) {
     isLoading.value = true
     error.value = null
-
     try {
-      const query = new URLSearchParams()
-      if (params?.page) query.set('page', String(params.page))
-      if (params?.perPage) query.set('per_page', String(params.perPage))
-      if (params?.queue && params.queue !== 'all') query.set('queue', params.queue)
-      if (params?.status && params.status !== 'all') query.set('status', params.status)
-      if (params?.search) query.set('search', params.search)
-
-      const data = await get<{ data: JobHistoryEntry[], total: number }>(`/jobs?${query.toString()}`)
-      jobs.value = data.data || []
-      totalJobs.value = data.total || 0
+      const result = await fetchJobs(filters)
+      jobs.value = result.data
+      totalJobs.value = result.total
     }
-    catch (e) {
+    catch {
       error.value = 'Failed to load job history.'
-      console.error('Failed to fetch jobs:', e)
     }
     finally {
       isLoading.value = false
     }
   }
 
-  async function retryJob(jobId: string) {
+  async function retryOneJob(id: string) {
     try {
-      await post(`/jobs/${jobId}/retry`)
-      // Refresh the job list after retry
-      await fetchJobs()
+      await retryJob(id)
+      await loadJobs()
     }
-    catch (e) {
-      error.value = `Failed to retry job ${jobId}.`
-      console.error('Failed to retry job:', e)
+    catch {
+      error.value = `Failed to retry job ${id}.`
     }
   }
 
-  async function retryFailedJobs() {
+  async function retryAllFailedJobs() {
     try {
-      await post('/queue/retry-failed')
-      await fetchJobs()
+      await retryFailedJobs()
+      await loadJobs()
     }
-    catch (e) {
+    catch {
       error.value = 'Failed to retry failed jobs.'
-      console.error('Failed to retry failed jobs:', e)
     }
   }
 
@@ -79,8 +141,8 @@ export function useJobs() {
     totalJobs,
     isLoading,
     error,
-    fetchJobs,
-    retryJob,
-    retryFailedJobs,
+    fetchJobs: loadJobs,
+    retryJob: retryOneJob,
+    retryFailedJobs: retryAllFailedJobs,
   }
 }

package/functions/mail-preferences.ts

@@ -0,0 +1,67 @@
+import { dashboardApi } from './dashboard-api'
+import { pushToast } from './toasts'
+
+export type DisplayDensity = 'comfortable' | 'default' | 'compact'
+export type MailTheme = 'light' | 'dark' | 'system'
+export type MailLanguage = 'en' | 'fr' | 'de' | 'es' | 'ja'
+export type ReplyBehavior = 'reply' | 'replyAll'
+export type AutoAdvance = 'newer' | 'older' | 'back'
+export type NotificationSound = 'default' | 'subtle' | 'none'
+
+export interface MailPreference {
+  id: number | null
+  mailbox: string
+  accountName: string
+  signature: string
+  displayDensity: DisplayDensity
+  theme: MailTheme
+  language: MailLanguage
+  defaultReplyBehavior: ReplyBehavior
+  sendAndArchive: boolean
+  autoAdvance: AutoAdvance
+  desktopNotifications: boolean
+  notificationSound: NotificationSound
+  notificationPreview: boolean
+  filters: string
+  blockedSenders: string
+  labels: string
+  loadRemoteImages: boolean
+  showExternalContent: boolean
+  vacationEnabled: boolean
+  vacationStartDate: string
+  vacationEndDate: string
+  vacationSubject: string
+  vacationMessage: string
+}
+
+interface MailPreferenceResponse {
+  success?: boolean
+  preference: MailPreference
+}
+
+export async function fetchMailPreference(mailbox?: string): Promise<MailPreference | null> {
+  try {
+    const query = mailbox ? `?mailbox=${encodeURIComponent(mailbox)}` : ''
+    const result = await dashboardApi<MailPreferenceResponse>(`/api/dashboard/email/preferences${query}`)
+    return result.preference
+  }
+  catch (error) {
+    pushToast('error', 'Could not load mail settings', { detail: String(error) })
+    return null
+  }
+}
+
+export async function saveMailPreference(preference: Omit<MailPreference, 'id'>): Promise<MailPreference | null> {
+  try {
+    const result = await dashboardApi<MailPreferenceResponse>('/api/dashboard/email/preferences', {
+      method: 'PUT',
+      body: preference,
+    })
+    pushToast('success', 'Mail settings saved', { detail: preference.mailbox })
+    return result.preference
+  }
+  catch (error) {
+    pushToast('error', 'Could not save mail settings', { detail: String(error) })
+    return null
+  }
+}

package/functions/monitoring/errors.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, it } from 'bun:test'
+import { errorGroupParams } from './errors'
+
+describe('errorGroupParams', () => {
+  it('encodes group identifiers exactly once', () => {
+    const params = errorGroupParams('Type/Error', 'Failed at 50%')
+
+    expect(params.toString()).toBe('type=Type%2FError&message=Failed+at+50%25')
+    expect(params.get('type')).toBe('Type/Error')
+    expect(params.get('message')).toBe('Failed at 50%')
+  })
+})

package/functions/monitoring/errors.ts

@@ -1,4 +1,5 @@
-import { useStorage } from '@stacksjs/browser'
+import { resolveApiBaseUrl } from '../api-url'
+import { useStorage } from '@stacksjs/browser/composables/useStorage'
 
 export interface GroupedError {
   id: number
@@ -42,14 +43,18 @@ const groupedErrors = useStorage<GroupedError[]>('grouped-errors', [])
 const errorStats = useStorage<ErrorStats | null>('error-stats', null)
 const errorTimeline = useStorage<ErrorTimelinePoint[]>('error-timeline', [])
 
-const baseURL = process.env.VITE_API_URL || `http://localhost:${process.env.PORT_API || '3008'}`
+const baseURL = `${resolveApiBaseUrl()}/dashboard/monitoring`
+
+export function errorGroupParams(type: string, message: string): URLSearchParams {
+  return new URLSearchParams({ type, message })
+}
 
 /**
  * Fetch all grouped errors
  */
 async function fetchGroupedErrors(): Promise<GroupedError[]> {
   try {
-    const response = await fetch(`${baseURL}/monitoring/errors`)
+    const response = await fetch(`${baseURL}/errors`)
     if (!response.ok) {
       throw new Error(`HTTP error! status: ${response.status}`)
     }
@@ -75,7 +80,7 @@ async function fetchGroupedErrors(): Promise<GroupedError[]> {
  */
 async function fetchErrorById(id: number): Promise<ErrorRecord | null> {
   try {
-    const response = await fetch(`${baseURL}/monitoring/errors/${id}`)
+    const response = await fetch(`${baseURL}/errors/${id}`)
     if (!response.ok) {
       throw new Error(`HTTP error! status: ${response.status}`)
     }
@@ -93,11 +98,7 @@ async function fetchErrorById(id: number): Promise<ErrorRecord | null> {
  */
 async function fetchErrorGroup(type: string, message: string): Promise<ErrorRecord[]> {
   try {
-    const params = new URLSearchParams({
-      type: encodeURIComponent(type),
-      message: encodeURIComponent(message),
-    })
-    const response = await fetch(`${baseURL}/monitoring/errors/group?${params}`)
+    const response = await fetch(`${baseURL}/errors/group?${errorGroupParams(type, message)}`)
     if (!response.ok) {
       throw new Error(`HTTP error! status: ${response.status}`)
     }
@@ -115,7 +116,7 @@ async function fetchErrorGroup(type: string, message: string): Promise<ErrorReco
  */
 async function fetchErrorStats(): Promise<ErrorStats | null> {
   try {
-    const response = await fetch(`${baseURL}/monitoring/errors/stats`)
+    const response = await fetch(`${baseURL}/errors/stats`)
     if (!response.ok) {
       throw new Error(`HTTP error! status: ${response.status}`)
     }
@@ -134,7 +135,7 @@ async function fetchErrorStats(): Promise<ErrorStats | null> {
  */
 async function fetchErrorTimeline(): Promise<ErrorTimelinePoint[]> {
   try {
-    const response = await fetch(`${baseURL}/monitoring/errors/timeline`)
+    const response = await fetch(`${baseURL}/errors/timeline`)
     if (!response.ok) {
       throw new Error(`HTTP error! status: ${response.status}`)
     }
@@ -153,7 +154,7 @@ async function fetchErrorTimeline(): Promise<ErrorTimelinePoint[]> {
  */
 async function resolveErrorGroup(type: string, message: string): Promise<boolean> {
   try {
-    const response = await fetch(`${baseURL}/monitoring/errors/resolve`, {
+    const response = await fetch(`${baseURL}/errors/resolve`, {
       method: 'PATCH',
       headers: {
         'Content-Type': 'application/json',
@@ -166,12 +167,11 @@ async function resolveErrorGroup(type: string, message: string): Promise<boolean
     }
 
     // Update local state
-    const index = groupedErrors.value.findIndex(
+    const group = groupedErrors.value.find(
       e => e.type === type && e.message === message,
     )
-    if (index !== -1) {
-      groupedErrors.value[index].status = 'resolved'
-    }
+    if (group)
+      group.status = 'resolved'
 
     return true
   }
@@ -186,7 +186,7 @@ async function resolveErrorGroup(type: string, message: string): Promise<boolean
  */
 async function ignoreErrorGroup(type: string, message: string): Promise<boolean> {
   try {
-    const response = await fetch(`${baseURL}/monitoring/errors/ignore`, {
+    const response = await fetch(`${baseURL}/errors/ignore`, {
       method: 'PATCH',
       headers: {
         'Content-Type': 'application/json',
@@ -199,12 +199,11 @@ async function ignoreErrorGroup(type: string, message: string): Promise<boolean>
     }
 
     // Update local state
-    const index = groupedErrors.value.findIndex(
+    const group = groupedErrors.value.find(
       e => e.type === type && e.message === message,
     )
-    if (index !== -1) {
-      groupedErrors.value[index].status = 'ignored'
-    }
+    if (group)
+      group.status = 'ignored'
 
     return true
   }
@@ -219,7 +218,7 @@ async function ignoreErrorGroup(type: string, message: string): Promise<boolean>
  */
 async function unresolveErrorGroup(type: string, message: string): Promise<boolean> {
   try {
-    const response = await fetch(`${baseURL}/monitoring/errors/unresolve`, {
+    const response = await fetch(`${baseURL}/errors/unresolve`, {
       method: 'PATCH',
       headers: {
         'Content-Type': 'application/json',
@@ -232,12 +231,11 @@ async function unresolveErrorGroup(type: string, message: string): Promise<boole
     }
 
     // Update local state
-    const index = groupedErrors.value.findIndex(
+    const group = groupedErrors.value.find(
       e => e.type === type && e.message === message,
     )
-    if (index !== -1) {
-      groupedErrors.value[index].status = 'unresolved'
-    }
+    if (group)
+      group.status = 'unresolved'
 
     return true
   }
@@ -252,11 +250,7 @@ async function unresolveErrorGroup(type: string, message: string): Promise<boole
  */
 async function deleteErrorGroup(type: string, message: string): Promise<boolean> {
   try {
-    const params = new URLSearchParams({
-      type: encodeURIComponent(type),
-      message: encodeURIComponent(message),
-    })
-    const response = await fetch(`${baseURL}/monitoring/errors?${params}`, {
+    const response = await fetch(`${baseURL}/errors?${errorGroupParams(type, message)}`, {
       method: 'DELETE',
     })