@stacksjs/defaults 0.70.207 → 0.70.208

package/ai/skills/stacks-chat/SKILL.md

@@ -0,0 +1,371 @@
+---
+name: stacks-chat
+description: Use when implementing chat messaging in Stacks — sending messages to Slack (webhooks, bot tokens, block kit), Discord (webhooks, bot tokens, embeds), Microsoft Teams (adaptive cards, webhooks), the BaseChatDriver abstraction, retry logic, or multi-channel chat routing. Covers @stacksjs/chat.
+license: MIT
+compatibility: Bun >= 1.3.0, TypeScript
+allowed-tools: Read Edit Write Bash Grep Glob
+---
+
+# Stacks Chat
+
+Multi-driver chat messaging with Slack, Discord, and Microsoft Teams support. Each driver supports both webhook and bot token modes, with retry logic and structured message formats.
+
+## Key Paths
+- Core package: `storage/framework/core/chat/src/`
+- Types: `storage/framework/core/types/src/chat.ts`
+
+## Source Files
+```
+chat/src/
+├── index.ts              # router, configure functions, type re-exports
+└── drivers/
+    ├── base.ts           # BaseChatDriver abstract class
+    ├── slack.ts          # SlackDriver + sendWebhook()
+    ├── discord.ts        # DiscordDriver + sendWebhook() + sendEmbed()
+    └── teams.ts          # TeamsDriver + sendWebhook() + sendCard()
+```
+
+## Router (index.ts)
+
+The main `send()` function routes to the specified driver. Default driver is `'slack'`:
+
+```typescript
+import { send, sendToSlack, sendToDiscord, sendToTeams } from '@stacksjs/chat'
+
+// Route to driver (default: 'slack')
+await send(message, { driver: 'slack' })
+await send(message, { driver: 'discord' })
+await send(message, { driver: 'teams' })
+
+// Direct webhook helpers
+await sendToSlack(webhookUrl, text, options?)
+await sendToDiscord(webhookUrl, content, options?)
+await sendToTeams(webhookUrl, text)
+```
+
+Configure functions:
+```typescript
+import { configureSlack, configureDiscord, configureTeams } from '@stacksjs/chat'
+configureSlack({ webhookUrl: '...', botToken: '...' })
+configureDiscord({ webhookUrl: '...', botToken: '...' })
+configureTeams({ webhookUrl: '...' })
+```
+
+Exported types: `ChatDriver` (union), `SendOptions`, `SlackConfig`, `SlackMessage`, `SlackBlock`, `SlackAttachment`, `DiscordConfig`, `DiscordMessage`, `DiscordEmbed`, `TeamsConfig`, `TeamsMessage`, `TeamsAdaptiveCard`, `TeamsCardElement`, `TeamsCardAction`
+
+## BaseChatDriver (base.ts)
+
+Abstract base class all drivers extend. Implements `ChatDriver` interface from `@stacksjs/types`:
+
+```typescript
+abstract class BaseChatDriver implements ChatDriver {
+  public abstract name: string
+  protected config: Required<ChatDriverConfig>
+
+  constructor(config?: ChatDriverConfig)  // defaults: maxRetries=3, retryTimeout=1000
+
+  configure(config: ChatDriverConfig): void
+  abstract send(message: ChatMessage, options?: RenderOptions): Promise<ChatResult>
+
+  // Protected helpers
+  protected validateMessage(message: ChatMessage): boolean  // throws if no `to` or no `content`/`template`
+  protected async handleError(error: unknown, message: ChatMessage): Promise<ChatResult>
+  protected async handleSuccess(message: ChatMessage, messageId?: string): Promise<ChatResult>
+}
+```
+
+- `handleError()` logs the error, then calls `message.onError()` if defined, returns `ChatResult` with `success: false`
+- `handleSuccess()` calls `message.handle()` first, then `message.onSuccess()` if defined, returns `ChatResult` with `success: true`
+- Both handlers merge any partial result from callbacks into the final `ChatResult`
+
+## ChatMessage Interface (from @stacksjs/types)
+
+```typescript
+interface ChatMessage {
+  to: string | string[]                // recipient (channel ID, user ID, etc.)
+  from?: { id?: string, name?: string, avatar?: string }
+  subject?: string                      // title for rich messages
+  content?: string                      // plain text content
+  template?: string                     // template for rich message rendering
+  data?: Record<string, any>           // template data
+  attachments?: ChatAttachment[]
+  onSuccess?: () => void | Promise<void> | Partial<ChatResult>
+  onError?: (error: Error) => void | Promise<void> | Partial<ChatResult>
+  handle?: () => void | Promise<void> | Partial<ChatResult>
+  [key: string]: any                    // custom platform-specific fields
+}
+```
+
+## ChatResult Interface (from @stacksjs/types)
+
+```typescript
+interface ChatResult {
+  success: boolean
+  message: string
+  provider: string                      // 'slack' | 'discord' | 'teams'
+  messageId?: string
+  data?: Record<string, any>
+}
+```
+
+## Slack Driver
+
+### SlackConfig
+```typescript
+interface SlackConfig {
+  webhookUrl?: string
+  botToken?: string
+  maxRetries?: number       // default: 3
+  retryTimeout?: number     // default: 1000ms
+}
+```
+
+### SlackMessage (for webhook payloads)
+```typescript
+interface SlackMessage {
+  channel?: string
+  text?: string
+  blocks?: SlackBlock[]
+  attachments?: SlackAttachment[]
+  username?: string
+  iconEmoji?: string
+  iconUrl?: string
+  threadTs?: string
+  mrkdwn?: boolean
+}
+```
+
+### SlackBlock
+```typescript
+interface SlackBlock {
+  type: 'section' | 'divider' | 'header' | 'context' | 'actions' | 'image'
+  text?: { type: 'plain_text' | 'mrkdwn', text: string, emoji?: boolean }
+  accessory?: any
+  elements?: any[]
+  block_id?: string
+}
+```
+
+### SlackAttachment
+```typescript
+interface SlackAttachment {
+  color?: string
+  pretext?: string
+  author_name?: string
+  author_link?: string
+  author_icon?: string
+  title?: string
+  title_link?: string
+  text?: string
+  fields?: Array<{ title: string, value: string, short?: boolean }>
+  image_url?: string
+  thumb_url?: string
+  footer?: string
+  footer_icon?: string
+  ts?: number
+}
+```
+
+### Slack Sending Modes
+
+1. **Webhook mode**: If `config.webhookUrl` is set, sends via `POST` to webhook URL. Payload includes `text`, `username`, `mrkdwn: true`. If `message.template` exists, builds Block Kit blocks.
+2. **Bot token mode**: If `config.botToken` is set, sends via Slack API `https://slack.com/api/chat.postMessage` with `Authorization: Bearer <token>`. Returns `ts` (timestamp) as message ID.
+3. Throws `Error('Slack not configured: provide webhookUrl or botToken')` if neither is set.
+
+### Direct Webhook Function
+```typescript
+async function sendWebhook(webhookUrl: string, text: string, options?: Partial<SlackMessage>): Promise<ChatResult>
+```
+Merges `options` into payload, sends POST to the provided webhook URL.
+
+### Block Building
+When `message.template` is set, `buildBlocks()` creates:
+- A `header` block from `message.subject` (if present)
+- A `section` block from `message.content` with `mrkdwn` type
+
+### Exports
+- `SlackDriver` class (also as `Driver`)
+- `driver` -- pre-instantiated `SlackDriver` singleton
+- `send()`, `sendWebhook()`, `configure()` functions
+
+## Discord Driver
+
+### DiscordConfig
+```typescript
+interface DiscordConfig {
+  webhookUrl?: string
+  botToken?: string
+  maxRetries?: number       // default: 3
+  retryTimeout?: number     // default: 1000ms
+}
+```
+
+### DiscordEmbed
+```typescript
+interface DiscordEmbed {
+  title?: string
+  description?: string
+  url?: string
+  color?: number              // integer color value (e.g. 0x5865F2)
+  timestamp?: string          // ISO 8601
+  footer?: { text: string, icon_url?: string }
+  image?: { url: string }
+  thumbnail?: { url: string }
+  author?: { name: string, url?: string, icon_url?: string }
+  fields?: Array<{ name: string, value: string, inline?: boolean }>
+}
+```
+
+### DiscordMessage
+```typescript
+interface DiscordMessage {
+  content?: string
+  username?: string
+  avatarUrl?: string
+  tts?: boolean
+  embeds?: DiscordEmbed[]
+  allowedMentions?: {
+    parse?: Array<'roles' | 'users' | 'everyone'>
+    roles?: string[]
+    users?: string[]
+  }
+}
+```
+
+### Discord Sending Modes
+
+1. **Webhook mode**: POST to `config.webhookUrl`. Handles `204` (empty success) responses. Returns `id` from response.
+2. **Bot token mode**: POST to `https://discord.com/api/v10/channels/{channelId}/messages` with `Authorization: Bot <token>`. Uses `message.to` as the channel ID.
+
+### Embed Building
+When `message.subject` or `message.template` is set, `buildEmbed()` creates an embed with:
+- `title` from `message.subject`
+- `description` from `message.content`
+- Default color: `0x5865F2` (Discord blurple)
+- `timestamp`: current ISO date
+
+### Extra Functions
+```typescript
+async function sendWebhook(webhookUrl: string, content: string, options?: Partial<DiscordMessage>): Promise<ChatResult>
+async function sendEmbed(webhookUrl: string, embed: DiscordEmbed, options?: Partial<DiscordMessage>): Promise<ChatResult>
+```
+`sendEmbed()` wraps the embed inside `sendWebhook()` with empty content.
+
+### Exports
+- `DiscordDriver` class (also as `Driver`)
+- `driver` -- pre-instantiated singleton
+- `send()`, `sendWebhook()`, `sendEmbed()`, `configure()` functions
+
+## Teams Driver
+
+### TeamsConfig
+```typescript
+interface TeamsConfig {
+  webhookUrl?: string
+  maxRetries?: number       // default: 3
+  retryTimeout?: number     // default: 1000ms
+}
+```
+
+### TeamsAdaptiveCard
+```typescript
+interface TeamsAdaptiveCard {
+  type: 'AdaptiveCard'
+  version: string           // '1.4'
+  body: TeamsCardElement[]
+  actions?: TeamsCardAction[]
+  $schema?: string          // 'http://adaptivecards.io/schemas/adaptive-card.json'
+}
+```
+
+### TeamsCardElement
+```typescript
+interface TeamsCardElement {
+  type: 'TextBlock' | 'Image' | 'Container' | 'ColumnSet' | 'Column' | 'FactSet' | 'ImageSet'
+  text?: string
+  size?: 'Small' | 'Default' | 'Medium' | 'Large' | 'ExtraLarge'
+  weight?: 'Lighter' | 'Default' | 'Bolder'
+  color?: 'Default' | 'Dark' | 'Light' | 'Accent' | 'Good' | 'Warning' | 'Attention'
+  wrap?: boolean
+  url?: string
+  altText?: string
+  items?: TeamsCardElement[]
+  columns?: TeamsCardElement[]
+  width?: string
+  facts?: Array<{ title: string, value: string }>
+  images?: Array<{ type: 'Image', url: string, size?: string }>
+}
+```
+
+### TeamsCardAction
+```typescript
+interface TeamsCardAction {
+  type: 'Action.OpenUrl' | 'Action.Submit' | 'Action.ShowCard'
+  title: string
+  url?: string
+  data?: Record<string, any>
+  card?: TeamsAdaptiveCard
+}
+```
+
+### TeamsMessage
+```typescript
+interface TeamsMessage {
+  type?: 'message'
+  summary?: string
+  text?: string
+  attachments?: Array<{
+    contentType: 'application/vnd.microsoft.card.adaptive'
+    content: TeamsAdaptiveCard
+  }>
+}
+```
+
+### Teams Sending
+
+- Uses `config.webhookUrl` or falls back to `message.to` as the webhook URL
+- Validates URL contains `webhook.office.com`
+- Simple messages (no subject/template): sends `{ type: 'message', text: content }`
+- Rich messages (with subject or template): builds an Adaptive Card v1.4 with:
+  - Title as `TextBlock` (size: Large, weight: Bolder)
+  - Content as `TextBlock` (wrap: true)
+  - Timestamp as `TextBlock` (size: Small, color: Dark)
+
+### Extra Functions
+```typescript
+async function sendWebhook(webhookUrl: string, text: string): Promise<ChatResult>
+async function sendCard(webhookUrl: string, card: TeamsAdaptiveCard, summary?: string): Promise<ChatResult>
+```
+
+### Exports
+- `TeamsDriver` class (also as `Driver`)
+- `driver` -- pre-instantiated singleton
+- `send()`, `sendWebhook()`, `sendCard()`, `configure()` functions
+
+## Retry Logic
+
+All three drivers implement `sendWithRetry()`:
+- Retries up to `config.maxRetries` times (default 3)
+- Waits `config.retryTimeout` ms between attempts (default 1000ms)
+- On final failure, throws the error (caught by the outer `send()` which calls `handleError()`)
+
+## Dependencies
+- `@stacksjs/types` -- `ChatMessage`, `ChatResult`, `RenderOptions`, `ChatDriver`, `ChatDriverConfig`
+- `@stacksjs/logging` -- `log` for info/warn/error logging
+
+## Gotchas
+- The default driver for `send()` is `'slack'`, not auto-detected
+- Each driver has two modes: webhook (simpler) and bot token (richer, returns message IDs)
+- Slack bot token mode uses `https://slack.com/api/chat.postMessage`, not a webhook
+- Discord webhook returns `204` on success with no body -- this is handled as success
+- Discord bot token mode uses `message.to` as the channel ID
+- Teams validates that the webhook URL contains `webhook.office.com`
+- Teams uses `message.to` as fallback webhook URL if `config.webhookUrl` is not set
+- All drivers set `mrkdwn: true` or equivalent by default
+- Block Kit blocks are only built when `message.template` is set (Slack) or when `message.subject`/`message.template` is set (Discord/Teams)
+- `validateMessage()` requires both `to` and either `content` or `template`
+- The `handle()` callback runs before `onSuccess()` -- both results are merged
+- `ChatMessage` supports `onSuccess`, `onError`, and `handle` callbacks that can return partial `ChatResult` objects
+- Each driver module exports a pre-instantiated `driver` singleton and both class-based and function-based APIs
+- Discord embed default color is `0x5865F2` (Discord blurple), not customizable via the auto-build path
+- Teams Adaptive Cards use version `1.4` with the official JSON schema URL

package/ai/skills/stacks-cli/SKILL.md

@@ -0,0 +1,112 @@
+---
+name: stacks-cli
+description: Use when building CLI commands or tools with Stacks — the @stacksjs/cli package for creating commands with argument parsing, option handling, colored output, tables, progress indicators, prompts, or integrating with the buddy command system. Covers @stacksjs/cli and app/Commands/.
+license: MIT
+compatibility: Bun >= 1.3.0, TypeScript
+allowed-tools: Read Edit Write Bash Grep Glob
+---
+
+# Stacks CLI Framework
+
+The `@stacksjs/cli` package provides the foundation for building CLI commands, used internally by the buddy CLI.
+
+## Key Paths
+- Core package: `storage/framework/core/cli/src/`
+- CLI configuration: `config/cli.ts`
+- Application commands: `app/Commands/`
+- Command registry: `app/Commands.ts`
+
+## Creating Commands
+
+### Simple Command
+```typescript
+// app/Commands/Greet.ts
+export default {
+  name: 'greet',
+  description: 'Greet a user',
+  alias: 'g',
+  options: {
+    name: { alias: 'n', description: 'Name to greet', default: 'World' },
+    loud: { alias: 'l', description: 'Shout the greeting', type: 'boolean' }
+  },
+  handle: async ({ options }) => {
+    const greeting = `Hello, ${options.name}!`
+    console.log(options.loud ? greeting.toUpperCase() : greeting)
+  }
+}
+```
+
+### Register in app/Commands.ts
+```typescript
+export default {
+  'greet': 'Greet',
+  'inspire': 'Inspire',
+}
+```
+
+### Three Registration Methods
+1. **app/Commands.ts** — name → file mapping
+2. **Event listeners** — CLI events in `app/Listeners/Console.ts`
+3. **Inline** — direct command definitions
+
+## CLI Event Listeners
+
+```typescript
+// app/Listeners/Console.ts
+export default function(cli: CLI) {
+  cli.on('custom:command', () => {
+    console.log('Custom command executed!')
+  })
+
+  cli.on('my:*', () => {
+    // Wildcard — matches my:anything
+  })
+
+  cli.on('unknown:!', () => {
+    // Default/fallback handler
+  })
+}
+```
+
+## Output Formatting
+
+Via `@stacksjs/utils` color functions (available in CLI context):
+```typescript
+import { bold, green, red, yellow, dim, underline } from '@stacksjs/utils'
+
+console.log(green('✓ Success'))
+console.log(red('✗ Error'))
+console.log(yellow('⚠ Warning'))
+console.log(bold('Important'))
+console.log(dim('Subtle info'))
+```
+
+## config/cli.ts (BinaryConfig)
+
+```typescript
+{
+  name: 'My Custom CLI',
+  command: 'mycli',
+  description: 'My custom CLI tool',
+  deploy: true
+}
+```
+
+## CLI Commands
+- `buddy make:command [name]` — scaffold a new command
+
+## Compiled Binaries
+
+```bash
+buddy build:cli                    # build CLI binary
+# Compiles for: linux-x64, linux-arm64, windows-x64, darwin-x64, darwin-arm64
+```
+
+## Gotchas
+- Application commands go in `app/Commands/`, framework commands in `storage/framework/core/buddy/src/commands/`
+- Commands are auto-discovered from `app/Commands.ts` registry
+- CLI events support wildcards (`*`) and default handlers (`!`)
+- The buddy CLI lazy-loads commands — not all load at startup
+- Output formatting uses ANSI colors from `@stacksjs/utils`
+- Custom CLIs can be compiled to platform-specific binaries
+- The CLI framework is separate from buddy — buddy uses it internally

package/ai/skills/stacks-cloud/SKILL.md

@@ -0,0 +1,192 @@
+---
+name: stacks-cloud
+description: Use when deploying or managing cloud infrastructure for Stacks — AWS deployment via CloudFormation/CDK, server mode (EC2, ALB, VPC), serverless mode (Lambda, API Gateway, CloudFront), jump boxes, domain management (Route53), S3 storage, SES email, edge computing, security groups, IAM, or the cloud configuration. Covers @stacksjs/cloud, @stacksjs/deploy, storage/framework/cloud/, and cloud/.
+license: MIT
+compatibility: Bun >= 1.3.0, TypeScript, AWS
+allowed-tools: Read Edit Write Bash Grep Glob
+---
+
+# Stacks Cloud & Deployment
+
+AWS-focused cloud deployment using CloudFormation via `@stacksjs/ts-cloud`.
+
+## Key Paths
+- Cloud package: `storage/framework/core/cloud/src/`
+- Deploy package: `storage/framework/core/deploy/`
+- CDK stacks: `storage/framework/cloud/` (deploy.ts, cdk.json, package.json)
+- Cloud config: `cloud/` (serverless.ts, servers.ts, deploy-script.ts)
+- Cloud driver state: `storage/cloud/` (ts-cloud's `stateDir`, set in `config/cloud.ts`)
+- Configuration: `config/cloud.ts`
+
+## Deployment Modes
+
+### Server Mode (EC2)
+- EC2 instances with configurable types (t3.micro, t4g.nano, etc.)
+- Application Load Balancer (ALB)
+- VPC with public/private subnets
+- Security groups with firewall rules
+- Auto-scaling capabilities
+- SQLite database on instance
+- Docker support via Dockerfile
+
+### Serverless Mode (Lambda)
+- Lambda functions for API
+- API Gateway (REST/WebSocket)
+- CloudFront CDN for static assets
+- S3 buckets (frontend, docs, logs, assets)
+- SQS queues for background jobs
+- DynamoDB (optional)
+
+## Deployment Flow
+
+```bash
+buddy deploy                    # deploy to cloud
+```
+
+1. Validates APP_KEY format (colon-separated)
+2. Checks AWS region and credentials
+3. Validates app URL, name, team configuration
+4. Creates `InfrastructureGenerator` from cloud config
+5. Generates CloudFormation template
+6. Creates or updates stack with:
+   - Capabilities: `CAPABILITY_IAM`, `CAPABILITY_NAMED_IAM`
+   - Tags: Environment, Project, ManagedBy
+   - OnFailure: ROLLBACK
+
+## Cloud Helper Functions
+
+```typescript
+import { getSecurityGroupId, purchaseDomain, hasBeenDeployed, isFirstDeployment, isFailedState } from '@stacksjs/cloud'
+
+// Domain management
+await purchaseDomain('example.com', { years: 1, privacy: true, autoRenew: true })
+
+// Infrastructure queries
+const sgId = await getSecurityGroupId('my-sg')
+const jumpBoxId = await getJumpBoxInstanceId('stack-name')
+const deployed = await hasBeenDeployed()
+const firstDeploy = await isFirstDeployment()
+const failed = await isFailedState()
+
+// Resource management
+await addJumpBox('stack-name')
+await deleteJumpBox('stack-name')
+await deleteEc2Instance(instanceId, 'stack-name')
+
+// Cleanup
+await deleteStacksBuckets()
+await deleteStacksFunctions()
+await deleteLogGroups()
+await deleteParameterStore()
+await deleteVpcs()
+await deleteCdkRemnants()
+await deleteIamUsers()
+await deleteSubnets()
+```
+
+## DNS Functions (AWS Route53)
+
+```typescript
+import { createHostedZone, deleteHostedZone, findHostedZone, getNameservers, updateNameservers } from '@stacksjs/cloud'
+
+const zone = await createHostedZone('example.com')
+const zoneId = await findHostedZone('example.com')
+const ns = await getNameservers('example.com')
+const hostedNs = await getHostedZoneNameservers('example.com')
+await updateNameservers(hostedNs, 'example.com')
+await deleteHostedZoneRecords('example.com')
+await writeNameserversToConfig(nameservers)
+```
+
+## Server Configuration (cloud/servers.ts)
+
+```typescript
+export default [
+  {
+    name: 'app-server-1',
+    domain: 'stacksjs.com',
+    region: 'us-east-1',
+    type: 'app',              // 'app' | 'web' | 'cache' | 'worker' | 'search'
+    instance: 't3.micro',
+    disk: 20,                  // GB
+    os: 'ubuntu-20-lts-x86_64',
+    bun: '1.1.26',
+    database: { type: 'sqlite', name: 'stacks' }
+  },
+  // ... more servers
+]
+```
+
+## Deploy Hooks (cloud/deploy-script.ts)
+
+```typescript
+export default {
+  beforeDeploy({ environment, region }) {
+    // Pre-deployment: build assets, validate, notify
+  },
+  afterDeploy({ environment, region, outputs }) {
+    // Post-deployment: cache warming, smoke tests, database seeding
+    console.log('Public IP:', outputs.PublicIp)
+    console.log('DNS:', outputs.DNS)
+  }
+}
+```
+
+## CLI Commands
+
+```bash
+buddy deploy                          # deploy application
+buddy cloud --diff                    # show infrastructure changes
+buddy cloud --ssh                     # SSH into cloud
+buddy cloud --invalidate-cache        # invalidate CDN
+buddy cloud:add --jump-box            # add jump box instance
+buddy cloud:remove --force            # destroy cloud resources
+buddy cloud:cleanup                   # clean retained resources
+buddy cloud:optimize-cost             # remove optional resources
+buddy domains:purchase <domain>       # purchase domain via Route53
+buddy domains:add <domain>            # add existing domain
+buddy domains:remove <domain>         # remove domain
+```
+
+## config/cloud.ts
+
+```typescript
+{
+  project: { name: 'my-app', slug: 'my-app', region: 'us-east-1' },
+  mode: 'server',             // 'server' | 'serverless'
+  environments: {
+    production: { domain: 'app.com', region: 'us-east-1' },
+    staging: { domain: 'staging.app.com' }
+  },
+  infrastructure: {
+    compute: { type: 't3.micro', spot: false },
+    loadBalancer: { enabled: true, type: 'application' },
+    ssl: { enabled: true },
+    dns: { provider: 'route53' },
+    storage: { buckets: [] },
+    cdn: { enabled: true },
+    cache: { enabled: false },
+    queue: { enabled: false }
+  }
+}
+```
+
+## Infrastructure Stack (storage/framework/cloud/)
+
+- `deploy.ts` — Main deployment script (CDK app entry)
+- `cdk.json` — CDK configuration with 54 AWS context settings
+- `package.json` — Cloud package dependencies
+
+Stack naming: `{slugified-app-name}-cloud`
+
+## Gotchas
+- AWS credentials MUST be configured (`buddy configure:aws` or env vars)
+- Default region is `us-east-1` (from AWS_DEFAULT_REGION env)
+- APP_KEY must be colon-separated format (validated during deployment)
+- Server mode uses EC2 + ALB; serverless uses Lambda + API Gateway + CloudFront
+- Jump boxes are optional — used for SSH access to private instances
+- `cloud:remove` with `--force` skips confirmation — destructive operation
+- CDK toolkit stack is named `stacks-toolkit`
+- Environment mapping: `local` → `development`, others preserved
+- Deploy hooks run before/after deployment for custom logic
+- The cloud package has its own `package.json` with framework dependencies