@stacksjs/defaults 0.70.229 → 0.70.230

package/app/Actions/Dashboard/Buddy/buddy-chat.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from 'bun:test'
+import { buddySystemPrompt, isBuddyProviderConfigured, publicBuddyHistory, resolveBuddyProvider } from './buddy-chat'
+
+describe('dashboard Buddy chat', () => {
+  test('normalizes the configured provider', () => {
+    expect(resolveBuddyProvider({ default: 'anthropic.claude-sonnet' })).toBe('anthropic')
+    expect(resolveBuddyProvider({ default: 'ollama' })).toBe('ollama')
+    expect(resolveBuddyProvider({ default: 'gpt-5' })).toBe('openai')
+  })
+
+  test('reports provider readiness without exposing keys', () => {
+    expect(isBuddyProviderConfigured('openai', {}, { OPENAI_API_KEY: 'configured' })).toBe(true)
+    expect(isBuddyProviderConfigured('anthropic', {}, {})).toBe(false)
+    expect(isBuddyProviderConfigured('ollama', {}, {})).toBe(true)
+  })
+
+  test('only returns public text history', () => {
+    const history = publicBuddyHistory([
+      { role: 'system', content: 'private' },
+      { role: 'user', content: 'Question' },
+      { role: 'assistant', content: [{ type: 'text', text: 'Structured' }] },
+      { role: 'assistant', content: 'Answer' },
+    ])
+
+    expect(history).toEqual([
+      { role: 'user', content: 'Question' },
+      { role: 'assistant', content: 'Answer' },
+    ])
+    expect(buddySystemPrompt()).toContain('Use buddy commands and Bun')
+  })
+})

package/app/Actions/Dashboard/Buddy/buddy-chat.ts

@@ -0,0 +1,49 @@
+import type { AIMessage, AIProvider, ConfiguredAIOptions } from '@stacksjs/ai'
+
+export interface BuddyProviderEnvironment {
+  ANTHROPIC_API_KEY?: string
+  OPENAI_API_KEY?: string
+}
+
+export function resolveBuddyProvider(config: ConfiguredAIOptions): AIProvider {
+  const value = String(config.default || 'openai').toLowerCase()
+  if (value === 'anthropic' || value.startsWith('anthropic.'))
+    return 'anthropic'
+  if (value === 'ollama')
+    return 'ollama'
+  return 'openai'
+}
+
+export function isBuddyProviderConfigured(
+  provider: AIProvider,
+  config: ConfiguredAIOptions,
+  environment: BuddyProviderEnvironment,
+): boolean {
+  if (provider === 'anthropic')
+    return Boolean(config.drivers?.anthropic?.apiKey || environment.ANTHROPIC_API_KEY)
+  if (provider === 'openai')
+    return Boolean(config.drivers?.openai?.apiKey || environment.OPENAI_API_KEY)
+  return true
+}
+
+export function buddySystemPrompt(): string {
+  return `You are Buddy, the Stacks framework assistant. Give concise, accurate help for a Bun and TypeScript Stacks application.
+
+Follow Stacks conventions:
+- Use buddy commands and Bun, not npm, pnpm, yarn, or direct eslint commands.
+- Use defineModel with model-driven migrations and the useApi trait when a model should expose CRUD APIs.
+- Use server actions and guarded routes for dashboard operations.
+- Use stx signals, composables, components, and Crosswind utilities for frontend work.
+- Never invent an API. If you are uncertain, say what should be verified in the repository skills.
+
+This chat answers questions only. It does not edit files or run commands.`
+}
+
+export function publicBuddyHistory(history: AIMessage[], limit = 50): Array<{ role: 'user' | 'assistant', content: string }> {
+  return history
+    .filter((message): message is AIMessage & { role: 'user' | 'assistant', content: string } =>
+      (message.role === 'user' || message.role === 'assistant') && typeof message.content === 'string',
+    )
+    .slice(-limit)
+    .map(message => ({ role: message.role, content: message.content }))
+}

package/app/Actions/Dashboard/BuddyDashboardAction.ts

@@ -1,34 +1,2 @@
-import { Action } from '@stacksjs/actions'
-
-export default new Action({
-  name: 'BuddyDashboardAction',
-  description: 'Returns Buddy CLI dashboard data including commands, output, and stats.',
-  method: 'GET',
-  async handle() {
-    const commands = [
-      { command: 'buddy build', description: 'Build the application', lastRun: '5m ago', status: 'success' },
-      { command: 'buddy dev', description: 'Start development server', lastRun: 'Running', status: 'running' },
-      { command: 'buddy test', description: 'Run test suite', lastRun: '1h ago', status: 'success' },
-      { command: 'buddy lint', description: 'Run linter', lastRun: '30m ago', status: 'success' },
-      { command: 'buddy deploy', description: 'Deploy to production', lastRun: '2d ago', status: 'success' },
-      { command: 'buddy migrate', description: 'Run database migrations', lastRun: '1d ago', status: 'success' },
-    ]
-
-    const recentOutput = `[14:32:45] Starting development server...
-[14:32:46] Compiling TypeScript...
-[14:32:48] Compiled successfully in 2.3s
-[14:32:48] Server running at http://localhost:3000
-[14:32:48] Hot reload enabled
-[14:32:50] Connected to database
-[14:32:50] Ready for requests`
-
-    const stats = [
-      { label: 'Commands Run', value: '1,234' },
-      { label: 'Avg Build Time', value: '2.3s' },
-      { label: 'Test Coverage', value: '89%' },
-      { label: 'Last Deploy', value: '2d ago' },
-    ]
-
-    return { commands, recentOutput, stats }
-  },
-})
+// Preserve the legacy route while keeping one canonical Buddy state contract.
+export { default } from './Buddy/BuddyChatStateAction'

package/app/Actions/Dashboard/Ci/failure-notifier.ts

@@ -114,7 +114,7 @@ function buildPayload(t: FailedTransition): { subject: string, body: string, dat
   const shortSha = t.commitSha ? t.commitSha.slice(0, 7) : ''
   const commit = t.commitMessage ? `${shortSha} ${t.commitMessage.split('\n')[0]}` : shortSha
   const workflow = t.workflowName ? ` (${t.workflowName})` : ''
-  const author = t.commitAuthor ? ` — ${t.commitAuthor}` : ''
+  const author = t.commitAuthor ? `, ${t.commitAuthor}` : ''
   const subject = `CI failed: ${t.repoFullName}${workflow}`
   const lines = [
     `${t.repoFullName}${workflow}`,

package/app/Actions/Dashboard/Ci/runner-pressure-monitor.ts

@@ -132,7 +132,7 @@ async function upsertAlertState(org: string, alerting: boolean, nowIso: string):
 function buildPayload(action: PressureAction): { subject: string, body: string, data: Record<string, unknown> } {
   const { org, current, sustainedMs } = action
   const minutes = Math.round(sustainedMs / 60_000)
-  const subject = `Runner pressure: ${org} — ${current.queued} queued`
+  const subject = `Runner pressure: ${org}, ${current.queued} queued`
   const body = [
     `Org: ${org}`,
     `Queue depth: ${current.queued} (cap ${current.cap}, ${current.running} running)`,

package/app/Actions/Dashboard/Cloud/CloudIndexAction.ts

@@ -1,61 +1,12 @@
 import { Action } from '@stacksjs/actions'
+import { tsCloud } from '~/config/cloud'
+import { getDashboardCloudSnapshot } from './cloud-overview'
 
 export default new Action({
   name: 'CloudIndexAction',
-  description: 'Returns cloud services overview for the dashboard.',
+  description: 'Returns configured cloud infrastructure and persisted deployment state.',
   method: 'GET',
   async handle() {
-    const providers = [
-      { name: 'AWS', status: 'connected', resources: 24, spend: '$1,234/mo', region: 'us-east-1' },
-      { name: 'DigitalOcean', status: 'connected', resources: 8, spend: '$456/mo', region: 'nyc1' },
-      { name: 'Cloudflare', status: 'connected', resources: 12, spend: '$89/mo', region: 'Global' },
-      { name: 'Vercel', status: 'connected', resources: 5, spend: '$0/mo', region: 'Global' },
-    ]
-
-    const stats = [
-      { label: 'Monthly Spend', value: '$1,779' },
-      { label: 'Resources', value: '49' },
-      { label: 'Regions', value: '4' },
-      { label: 'Uptime', value: '99.99%' },
-    ]
-
-    const resources = [
-      { name: 'web-server-1', type: 'EC2', provider: 'AWS', status: 'running', cost: '$45/mo' },
-      { name: 'database-primary', type: 'RDS', provider: 'AWS', status: 'running', cost: '$234/mo' },
-      { name: 'cdn-assets', type: 'CloudFront', provider: 'AWS', status: 'active', cost: '$12/mo' },
-      { name: 'app-droplet', type: 'Droplet', provider: 'DigitalOcean', status: 'running', cost: '$48/mo' },
-      { name: 'stacks-site', type: 'Pages', provider: 'Cloudflare', status: 'active', cost: '$0/mo' },
-    ]
-
-    const functions = [
-      { name: 'api-handler', runtime: 'Node.js 20', invocations: '45.2K', avgDuration: '45ms', errors: 12, status: 'active' },
-      { name: 'image-processor', runtime: 'Node.js 20', invocations: '12.3K', avgDuration: '234ms', errors: 3, status: 'active' },
-      { name: 'email-sender', runtime: 'Node.js 20', invocations: '8.9K', avgDuration: '89ms', errors: 0, status: 'active' },
-      { name: 'webhook-handler', runtime: 'Node.js 20', invocations: '23.4K', avgDuration: '56ms', errors: 5, status: 'active' },
-      { name: 'cron-job', runtime: 'Node.js 20', invocations: '720', avgDuration: '1.2s', errors: 2, status: 'active' },
-    ]
-
-    const serverlessStats = [
-      { label: 'Total Functions', value: '5' },
-      { label: 'Invocations (24h)', value: '90.5K' },
-      { label: 'Avg Duration', value: '85ms' },
-      { label: 'Error Rate', value: '0.02%' },
-    ]
-
-    const edges = [
-      { region: 'US East', latency: '12ms', requests: '34.5K' },
-      { region: 'US West', latency: '45ms', requests: '12.3K' },
-      { region: 'Europe', latency: '89ms', requests: '23.4K' },
-      { region: 'Asia', latency: '156ms', requests: '8.9K' },
-    ]
-
-    return {
-      providers,
-      stats,
-      resources,
-      functions,
-      serverlessStats,
-      edges,
-    }
+    return getDashboardCloudSnapshot(tsCloud)
   },
 })

package/app/Actions/Dashboard/Cloud/ServerlessIndexAction.ts

@@ -0,0 +1,20 @@
+import { Action } from '@stacksjs/actions'
+import { tsCloud } from '~/config/cloud'
+import { getDashboardCloudSnapshot } from './cloud-overview'
+
+export default new Action({
+  name: 'ServerlessIndexAction',
+  description: 'Returns serverless services derived from environment application manifests.',
+  method: 'GET',
+  async handle() {
+    const snapshot = await getDashboardCloudSnapshot(tsCloud)
+    return {
+      project: snapshot.project,
+      environments: snapshot.environments.filter(environment => environment.serverless),
+      services: snapshot.serverlessServices,
+      links: snapshot.serverlessLinks,
+      events: snapshot.events.filter(event => event.service.toLowerCase().includes('serverless')),
+      generatedAt: snapshot.generatedAt,
+    }
+  },
+})

package/app/Actions/Dashboard/Cloud/cloud-overview.test.ts

@@ -0,0 +1,180 @@
+import type { CloudConfig } from '@stacksjs/ts-cloud'
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { getDashboardCloudSnapshot } from './cloud-overview'
+
+let stateDir = ''
+
+beforeEach(async () => {
+  stateDir = await mkdtemp(join(tmpdir(), 'stacks-dashboard-cloud-'))
+  await mkdir(join(stateDir, 'state'), { recursive: true })
+})
+
+afterEach(async () => {
+  await rm(stateDir, { force: true, recursive: true })
+})
+
+const cloudConfig: CloudConfig = {
+  project: { name: 'Example', slug: 'example', region: 'us-west-2' },
+  cloud: { provider: 'hetzner' },
+  mode: 'server',
+  environments: {
+    production: { type: 'production', deployBranch: 'main', region: 'us-east-1' },
+    staging: { type: 'staging', deployBranch: 'stage' },
+  },
+  infrastructure: {
+    compute: {
+      instances: 1,
+      size: 'medium',
+      disk: { size: 80, type: 'ssd', encrypted: true },
+    },
+    servers: {
+      app: {
+        name: 'app-server',
+        type: 'app',
+        domain: 'example.com',
+        size: 'small',
+        serverOS: 'ubuntu',
+        bunVersion: '1.3.0',
+        database: 'sqlite',
+      },
+    },
+    loadBalancer: { enabled: true, type: 'application', healthCheck: { path: '/health' } },
+    dns: { domain: 'example.com' },
+    storage: {
+      public: { public: true, encryption: true, versioning: true },
+    },
+    queues: {
+      jobs: { visibilityTimeout: 120 },
+    },
+    containers: {
+      api: { cpu: 512, memory: 1024, port: 3000 },
+    },
+  },
+  sites: {
+    main: { root: '.', domain: 'example.com', start: 'bun server.ts', port: 3000 },
+  },
+}
+
+describe('dashboard cloud overview', () => {
+  test('reports configured and persisted deployment state without invented metrics', async () => {
+    await writeFile(join(stateDir, 'state', 'example-production.json'), JSON.stringify({
+      stackName: 'example-production',
+      provider: 'hetzner',
+      serverName: 'example-production-app',
+      publicIp: '203.0.113.20',
+      sshUser: 'root',
+    }))
+    await writeFile(join(stateDir, 'state', 'example-production-resize.json'), JSON.stringify({
+      operationId: 'resize-1',
+      stackName: 'example-production',
+      serverName: 'example-production-app',
+      phase: 'waiting-capacity',
+      status: 'waiting-capacity',
+      sourceType: 'small',
+      targetType: 'medium',
+      attempts: 2,
+      updatedAt: '2026-07-29T10:00:00.000Z',
+    }))
+
+    const snapshot = await getDashboardCloudSnapshot(cloudConfig, {
+      stateDir,
+      now: () => new Date('2026-07-29T12:00:00.000Z'),
+    })
+
+    expect(snapshot.project).toEqual({
+      mode: 'server',
+      name: 'Example',
+      provider: 'hetzner',
+      region: 'us-west-2',
+      slug: 'example',
+    })
+    expect(snapshot.serverDefinitions).toContainEqual(expect.objectContaining({
+      diskGb: 80,
+      encrypted: true,
+      name: 'app-server',
+      size: 'small',
+    }))
+    expect(snapshot.deployments).toEqual([
+      expect.objectContaining({
+        environment: 'production',
+        operation: expect.objectContaining({ attempts: 2, status: 'waiting-capacity' }),
+        publicIp: '203.0.113.20',
+        status: 'attention',
+      }),
+    ])
+    expect(snapshot.environments.find(item => item.name === 'production')?.status).toBe('deployed')
+    expect(snapshot.resources.map(item => item.id)).toEqual([
+      'network:dns',
+      'network:load-balancer',
+      'storage:public',
+      'queue:jobs',
+      'container:api',
+      'site:main',
+    ])
+    expect(snapshot.resources.find(item => item.id === 'container:api')?.status).toBe('inactive')
+    expect(snapshot.events[0]).toMatchObject({
+      message: 'Deployment recorded; resize is waiting-capacity.',
+      timestamp: '2026-07-29T10:00:00.000Z',
+      type: 'attention',
+    })
+    expect(JSON.stringify(snapshot)).not.toContain('Monthly Spend')
+    expect(JSON.stringify(snapshot)).not.toContain('99.99%')
+  })
+
+  test('reports malformed state instead of presenting a configured-only snapshot', async () => {
+    await writeFile(join(stateDir, 'state', 'broken.json'), '{')
+
+    expect(getDashboardCloudSnapshot(cloudConfig, { stateDir })).rejects.toThrow(
+      'Could not read cloud state broken.json',
+    )
+  })
+
+  test('treats an absent state directory as no deployment state', async () => {
+    const missingStateDir = join(stateDir, 'not-created')
+    const snapshot = await getDashboardCloudSnapshot(cloudConfig, { stateDir: missingStateDir })
+
+    expect(snapshot.deployments).toEqual([])
+    expect(snapshot.events).toEqual([])
+    expect(snapshot.environments.every(environment => environment.status === 'configured')).toBe(true)
+  })
+
+  test('derives serverless services only from environment app manifests', async () => {
+    const serverlessConfig: CloudConfig = {
+      project: { name: 'Lambda App', slug: 'lambda-app', region: 'us-east-1' },
+      mode: 'serverless',
+      environments: {
+        production: {
+          type: 'production',
+          app: {
+            kind: 'bun',
+            runtimeVersion: '1.3.0',
+            entry: 'server.ts',
+            memory: 1024,
+            queues: true,
+            queueMemory: 512,
+            scheduler: 'on',
+            assets: 'public',
+            cache: { driver: 'dynamodb' },
+            firewall: { enabled: true, rateLimit: 2000 },
+          },
+        },
+      },
+    }
+
+    const snapshot = await getDashboardCloudSnapshot(serverlessConfig, { stateDir })
+
+    expect(snapshot.serverlessServices.map(service => service.type)).toEqual([
+      'api',
+      'cli',
+      'queue',
+      'assets',
+      'cache',
+      'firewall',
+    ])
+    expect(snapshot.serverlessLinks).toHaveLength(5)
+    expect(snapshot.serverlessServices.every(service => service.environment === 'production')).toBe(true)
+  })
+})