@frontmcp/skills 1.0.4 → 1.1.0

package/catalog/frontmcp-channels/references/channel-sources.md

@@ -0,0 +1,214 @@
+---
+name: channel-sources
+description: Configure different channel source types - webhooks, app events, agent/job completion, service connectors, file watchers, and manual push
+---
+
+# Channel Sources
+
+Every channel has a source that determines how events flow into it. FrontMCP supports seven source types, each optimized for a different integration pattern.
+
+## Webhook Source
+
+Registers an HTTP POST endpoint. External services (GitHub, CI/CD, monitoring) send payloads to this endpoint.
+
+```typescript
+@Channel({
+  name: 'ci-alerts',
+  description: 'CI/CD pipeline notifications',
+  source: { type: 'webhook', path: '/hooks/ci' },
+})
+class CIAlertChannel extends ChannelContext {
+  async onEvent(payload: unknown): Promise<ChannelNotification> {
+    const { body } = payload as WebhookPayload;
+    const data = body as { pipeline: string; status: string; url: string };
+    return {
+      content: `CI pipeline "${data.pipeline}" ${data.status}.\nDetails: ${data.url}`,
+      meta: { pipeline: data.pipeline, status: data.status },
+    };
+  }
+}
+```
+
+## App Event Source
+
+Subscribes to the in-process `ChannelEventBus`. Your application code emits events, and the channel transforms them into notifications.
+
+```typescript
+@Channel({
+  name: 'error-alerts',
+  description: 'Application error notifications',
+  source: { type: 'app-event', event: 'app:error' },
+})
+class ErrorAlertChannel extends ChannelContext {
+  async onEvent(payload: unknown): Promise<ChannelNotification> {
+    const error = payload as { message: string; stack?: string; level: string };
+    return {
+      content: `Application Error: ${error.message}\n${error.stack ?? ''}`,
+      meta: { severity: error.level },
+    };
+  }
+}
+
+// In your application code:
+scope.channelEventBus.emit('app:error', {
+  message: 'Connection refused',
+  stack: 'Error: ECONNREFUSED...',
+  level: 'critical',
+});
+```
+
+## Agent Completion Source
+
+Automatically pushes when registered agents finish execution. Optionally filter by agent IDs.
+
+```typescript
+@Channel({
+  name: 'agent-done',
+  description: 'Notifies when AI agents complete their tasks',
+  source: {
+    type: 'agent-completion',
+    agentIds: ['code-reviewer', 'test-writer'],
+  },
+})
+class AgentDoneChannel extends ChannelContext {
+  async onEvent(payload: unknown): Promise<ChannelNotification> {
+    const event = payload as {
+      agentId: string;
+      status: string;
+      durationMs: number;
+      output?: string;
+    };
+    return {
+      content: `Agent "${event.agentId}" finished (${event.status}) in ${event.durationMs}ms.${
+        event.output ? `\nResult: ${event.output}` : ''
+      }`,
+      meta: { agentId: event.agentId, status: event.status },
+    };
+  }
+}
+```
+
+## Job Completion Source
+
+Pushes when background jobs or workflows complete. Optionally filter by job names.
+
+```typescript
+@Channel({
+  name: 'job-done',
+  description: 'Background job completion notifications',
+  source: {
+    type: 'job-completion',
+    jobNames: ['daily-report', 'data-sync'],
+  },
+})
+class JobDoneChannel extends ChannelContext {
+  async onEvent(payload: unknown): Promise<ChannelNotification> {
+    const event = payload as {
+      jobName: string;
+      status: string;
+      durationMs: number;
+    };
+    return {
+      content: `Job "${event.jobName}" ${event.status} (${event.durationMs}ms)`,
+      meta: { jobName: event.jobName, status: event.status },
+    };
+  }
+}
+```
+
+## Service Connector Source
+
+Maintains a persistent connection to an external service. Claude sends outbound messages via channel-contributed tools, and incoming messages trigger `onEvent()`.
+
+```typescript
+@Channel({
+  name: 'whatsapp',
+  source: { type: 'service', service: 'whatsapp-business' },
+  tools: [SendWhatsAppTool], // Auto-registered for Claude to call
+  twoWay: true,
+})
+class WhatsAppChannel extends ChannelContext {
+  async onConnect(): Promise<void> {
+    // Establish connection, start listening for incoming messages
+    this.client.on('message', (msg) => this.pushIncoming(msg));
+  }
+  async onDisconnect(): Promise<void> {
+    /* tear down */
+  }
+  async onEvent(payload: unknown): Promise<ChannelNotification> {
+    /* transform */
+  }
+}
+```
+
+## File Watcher Source
+
+Watches file system paths for changes and pushes notifications. Uses `onConnect()` to start the watcher.
+
+```typescript
+@Channel({
+  name: 'log-watcher',
+  source: {
+    type: 'file-watcher',
+    paths: ['./logs/app.log', './logs/error.log'],
+    events: ['change', 'create'],
+  },
+})
+class LogWatcherChannel extends ChannelContext {
+  async onConnect(): Promise<void> {
+    // Start watching files, call pushIncoming() on changes
+  }
+  async onEvent(payload: unknown): Promise<ChannelNotification> {
+    const event = payload as { file: string; content: string };
+    return { content: `[${event.file}] ${event.content}`, meta: { file: event.file } };
+  }
+}
+```
+
+## Manual Source
+
+No automatic wiring. Push notifications programmatically via `scope.channelNotifications.send()`.
+
+```typescript
+const StatusChannel = channel({
+  name: 'status-updates',
+  description: 'Manual status broadcast',
+  source: { type: 'manual' },
+})((payload) => ({
+  content: `Status: ${(payload as { message: string }).message}`,
+}));
+
+// Push from anywhere with scope access:
+scope.channelNotifications.send('status-updates', 'Server maintenance starting in 5 minutes');
+```
+
+## Replay Buffer
+
+Enable event buffering so events are preserved when Claude Code is not connected:
+
+```typescript
+@Channel({
+  name: 'ci-alerts',
+  source: { type: 'webhook', path: '/hooks/ci' },
+  replay: { enabled: true, maxEvents: 100 },
+})
+class CIAlertChannel extends ChannelContext {
+  /* ... */
+}
+```
+
+Buffered events are replayed when a new session connects, with `replayed: "true"` in meta.
+
+## Examples
+
+| Example                                                                 | Level        | Description                                                                                                                      |
+| ----------------------------------------------------------------------- | ------------ | -------------------------------------------------------------------------------------------------------------------------------- |
+| [`webhook-github`](../examples/channel-sources/webhook-github.md)       | Basic        | Forward GitHub webhook events (PRs, pushes, CI) into Claude Code                                                                 |
+| [`app-errors`](../examples/channel-sources/app-errors.md)               | Basic        | Forward application errors to Claude Code via the in-process event bus                                                           |
+| [`agent-notify`](../examples/channel-sources/agent-notify.md)           | Intermediate | Notify Claude Code when AI agents complete their tasks                                                                           |
+| [`job-completion`](../examples/channel-sources/job-completion.md)       | Intermediate | Notify Claude Code when background jobs and workflows complete                                                                   |
+| [`service-connector`](../examples/channel-sources/service-connector.md) | Advanced     | Build a persistent service connector that lets Claude send and receive messages through WhatsApp, Telegram, or any messaging API |
+| [`file-watcher`](../examples/channel-sources/file-watcher.md)           | Intermediate | Watch files for changes and notify Claude Code in real-time                                                                      |
+| [`replay-buffer`](../examples/channel-sources/replay-buffer.md)         | Advanced     | Buffer channel events so Claude Code receives them when it connects, even if events occurred while offline                       |
+
+> See all examples in [`examples/channel-sources/`](../examples/channel-sources/)

package/catalog/frontmcp-channels/references/channel-two-way.md

@@ -0,0 +1,195 @@
+---
+name: channel-two-way
+description: Build two-way chat bridges connecting WhatsApp, Telegram, Slack, and Discord to Claude Code
+---
+
+# Two-Way Channels (Chat Bridges)
+
+Two-way channels let external users communicate with Claude Code through messaging platforms. Claude receives messages as channel events and replies using the auto-registered `channel-reply` tool.
+
+## Architecture
+
+1. **Incoming**: External message arrives (WhatsApp, Telegram, Slack webhook)
+2. **Transform**: `onEvent()` converts to `ChannelNotification`
+3. **Push**: Notification sent to Claude Code session
+4. **Reply**: Claude calls `channel-reply` tool with response text
+5. **Forward**: `onReply()` sends the reply back to the external platform
+
+## WhatsApp Business API Bridge
+
+```typescript
+import { Channel, ChannelContext, ChannelNotification } from '@frontmcp/sdk';
+
+// Store verified senders for security
+const allowedSenders = new Set<string>();
+
+@Channel({
+  name: 'whatsapp',
+  description: 'WhatsApp Business API bridge for Claude Code',
+  source: { type: 'webhook', path: '/hooks/whatsapp' },
+  twoWay: true,
+  meta: { platform: 'whatsapp' },
+})
+export class WhatsAppChannel extends ChannelContext {
+  async onEvent(payload: unknown): Promise<ChannelNotification> {
+    const { body } = payload as { body: Record<string, unknown> };
+
+    // WhatsApp Cloud API webhook payload structure
+    const entry = (body as any).entry?.[0];
+    const change = entry?.changes?.[0];
+    const message = change?.value?.messages?.[0];
+    const contact = change?.value?.contacts?.[0];
+
+    if (!message || !contact) {
+      return { content: 'WhatsApp: received non-message webhook (status update)' };
+    }
+
+    const sender = contact.wa_id;
+    const senderName = contact.profile?.name ?? sender;
+
+    // Security: only allow verified senders
+    if (!allowedSenders.has(sender)) {
+      this.logger.warn(`WhatsApp: rejecting message from unverified sender ${sender}`);
+      return {
+        content: `WhatsApp: message from unverified sender ${senderName} (${sender}). Add to allowlist to process.`,
+        meta: { sender, sender_name: senderName, verified: 'false' },
+      };
+    }
+
+    const text = message.text?.body ?? '[non-text message]';
+
+    return {
+      content: `${senderName}: ${text}`,
+      meta: {
+        sender,
+        sender_name: senderName,
+        message_id: message.id,
+        chat_id: sender,
+      },
+    };
+  }
+
+  async onReply(reply: string, meta?: Record<string, string>): Promise<void> {
+    const chatId = meta?.chat_id;
+    if (!chatId) {
+      this.logger.warn('WhatsApp reply: no chat_id in meta');
+      return;
+    }
+
+    // Send via WhatsApp Cloud API
+    const token = process.env['WHATSAPP_TOKEN'];
+    const phoneNumberId = process.env['WHATSAPP_PHONE_ID'];
+
+    await fetch(`https://graph.facebook.com/v18.0/${phoneNumberId}/messages`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        messaging_product: 'whatsapp',
+        to: chatId,
+        text: { body: reply },
+      }),
+    });
+  }
+}
+```
+
+## Telegram Bot Bridge
+
+```typescript
+@Channel({
+  name: 'telegram',
+  description: 'Telegram bot bridge for Claude Code',
+  source: { type: 'webhook', path: '/hooks/telegram' },
+  twoWay: true,
+  meta: { platform: 'telegram' },
+})
+export class TelegramChannel extends ChannelContext {
+  async onEvent(payload: unknown): Promise<ChannelNotification> {
+    const { body } = payload as { body: Record<string, unknown> };
+    const update = body as {
+      message?: {
+        chat: { id: number };
+        from: { username?: string; first_name: string; id: number };
+        text?: string;
+      };
+    };
+
+    const msg = update.message;
+    if (!msg?.text) {
+      return { content: 'Telegram: non-text update received' };
+    }
+
+    const sender = msg.from.username ?? msg.from.first_name;
+
+    return {
+      content: `${sender}: ${msg.text}`,
+      meta: {
+        chat_id: String(msg.chat.id),
+        sender: String(msg.from.id),
+        sender_name: sender,
+      },
+    };
+  }
+
+  async onReply(reply: string, meta?: Record<string, string>): Promise<void> {
+    const chatId = meta?.chat_id;
+    if (!chatId) return;
+
+    const token = process.env['TELEGRAM_BOT_TOKEN'];
+    await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ chat_id: chatId, text: reply }),
+    });
+  }
+}
+```
+
+## Security Best Practices
+
+### Sender Gating
+
+Always validate individual sender identity, not room/group membership:
+
+```typescript
+// Good: check individual sender
+if (!allowedSenders.has(senderId)) {
+  return { content: 'Rejected: unverified sender', meta: { verified: 'false' } };
+}
+
+// Bad: trust anyone in a group chat
+if (isGroupMember(chatId)) {
+  /* dangerous */
+}
+```
+
+### Webhook Verification
+
+Validate webhook signatures for each platform:
+
+```typescript
+// WhatsApp: verify X-Hub-Signature-256 header
+// Telegram: verify secret_token parameter
+// Slack: verify X-Slack-Signature header
+```
+
+### Pairing Codes
+
+For bootstrapping trust, use pairing codes:
+
+```typescript
+// 1. User sends "/pair ABC123" in chat
+// 2. Server verifies code, adds sender to allowlist
+// 3. Future messages from this sender are trusted
+```
+
+## Examples
+
+| Example                                                             | Level    | Description                                                                            |
+| ------------------------------------------------------------------- | -------- | -------------------------------------------------------------------------------------- |
+| [`whatsapp-bridge`](../examples/channel-two-way/whatsapp-bridge.md) | Advanced | Full WhatsApp Business API bridge allowing users to chat with Claude Code via WhatsApp |
+
+> See all examples in [`examples/channel-two-way/`](../examples/channel-two-way/)

package/catalog/frontmcp-config/SKILL.md

@@ -52,24 +52,26 @@ Entry point for configuring FrontMCP servers. This skill helps you find the righ
 
 ## Scenario Routing Table
 
-| Scenario                                                       | Skill                                  | Description                                                      |
-| -------------------------------------------------------------- | -------------------------------------- | ---------------------------------------------------------------- |
-| Choose between SSE, Streamable HTTP, or stdio                  | `configure-transport`                  | Transport protocol selection with distributed session options    |
-| Set up CORS, port, base path, or request limits                | `configure-http`                       | HTTP server options for Streamable HTTP and SSE transports       |
-| Add rate limiting, concurrency, or IP filtering                | `configure-throttle`                   | Server-level and per-tool throttle configuration                 |
-| Enable tools to ask users for input                            | `configure-elicitation`                | Elicitation schemas, stores, and multi-step flows                |
-| Set up authentication (public, transparent, local, remote)     | `configure-auth`                       | OAuth flows, credential vault, multi-app auth                    |
-| Configure session storage backends                             | `configure-session`                    | Memory, Redis, Vercel KV, and custom session stores              |
-| Add Redis for production storage                               | `setup-redis`                          | Docker Redis, Vercel KV, pub/sub for subscriptions               |
-| Add SQLite for local development                               | `setup-sqlite`                         | SQLite with WAL mode, migration helpers                          |
-| Understand auth mode details (public/transparent/local/remote) | `configure-auth-modes`                 | Authentication mode details (public, transparent, local, remote) |
-| Fine-tune guard configuration for throttling                   | `configure-throttle-guard-config`      | Advanced guard configuration for throttling                      |
-| Use transport protocol presets                                 | `configure-transport-protocol-presets` | Transport protocol preset configurations                         |
-| Split apps into separate scopes (`splitByApp`)                 | `decorators-guide`                     | Per-app scope and basePath isolation on `@FrontMcp`              |
-| Enable widget-to-host communication (ext-apps)                 | `decorators-guide`                     | `extApps` host capabilities, session validation, widget comms    |
-| Enable background jobs and workflows                           | `decorators-guide`                     | `jobs: { enabled: true, store? }` on `@FrontMcp`                 |
-| Configure pagination for list operations                       | `decorators-guide`                     | `pagination` defaults for `tools/list` endpoint                  |
-| Configure npm/ESM package loader for remote apps               | `decorators-guide`                     | `loader` config for `App.esm()` / `App.remote()` resolution      |
+| Scenario                                                       | Skill                                  | Description                                                         |
+| -------------------------------------------------------------- | -------------------------------------- | ------------------------------------------------------------------- |
+| Choose between SSE, Streamable HTTP, or stdio                  | `configure-transport`                  | Transport protocol selection with distributed session options       |
+| Set up CORS, port, base path, or request limits                | `configure-http`                       | HTTP server options for Streamable HTTP and SSE transports          |
+| Add rate limiting, concurrency, or IP filtering                | `configure-throttle`                   | Server-level and per-tool throttle configuration                    |
+| Enable tools to ask users for input                            | `configure-elicitation`                | Elicitation schemas, stores, and multi-step flows                   |
+| Set up authentication (public, transparent, local, remote)     | `configure-auth`                       | OAuth flows, credential vault, multi-app auth                       |
+| Configure session storage backends                             | `configure-session`                    | Memory, Redis, Vercel KV, and custom session stores                 |
+| Add Redis for production storage                               | `setup-redis`                          | Docker Redis, Vercel KV, pub/sub for distributed subscriptions      |
+| Add SQLite for local development                               | `setup-sqlite`                         | SQLite with WAL mode, migration helpers                             |
+| Understand auth mode details (public/transparent/local/remote) | `configure-auth-modes`                 | Authentication mode details (public, transparent, local, remote)    |
+| Fine-tune guard configuration for throttling                   | `configure-throttle-guard-config`      | Advanced guard configuration for throttling                         |
+| Use transport protocol presets                                 | `configure-transport-protocol-presets` | Transport protocol preset configurations                            |
+| Configure multi-target deployments and frontmcp.config.ts      | `configure-deployment-targets`         | Typed config with defineConfig(), 8 deployment targets, JSON schema |
+| Add CSP, HSTS, X-Frame-Options, and other security headers     | `configure-security-headers`           | CSP directives, report-only mode, HSTS preload, custom headers      |
+| Split apps into separate scopes (`splitByApp`)                 | `decorators-guide`                     | Per-app scope and basePath isolation on `@FrontMcp`                 |
+| Enable widget-to-host communication (ext-apps)                 | `decorators-guide`                     | `extApps` host capabilities, session validation, widget comms       |
+| Enable background jobs and workflows                           | `decorators-guide`                     | `jobs: { enabled: true, store? }` on `@FrontMcp`                    |
+| Configure pagination for list operations                       | `decorators-guide`                     | `pagination` defaults for `tools/list` endpoint                     |
+| Configure npm/ESM package loader for remote apps               | `decorators-guide`                     | `loader` config for `App.esm()` / `App.remote()` resolution         |
 
 ## Configuration Layers
 

package/catalog/frontmcp-config/examples/configure-auth/multi-app-auth.md

@@ -18,8 +18,7 @@ Configure a single FrontMCP server with multiple apps, each using a different au
 
 ```typescript
 // src/server.ts
-import { FrontMcp, App, Tool, ToolContext } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { App, FrontMcp, Tool, ToolContext, z } from '@frontmcp/sdk';
 
 @Tool({
   name: 'public_search',

package/catalog/frontmcp-config/examples/configure-auth/public-mode-setup.md

@@ -18,8 +18,7 @@ Set up a FrontMCP server with public (unauthenticated) access and anonymous scop
 
 ```typescript
 // src/server.ts
-import { FrontMcp, App, Tool, ToolContext } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { App, FrontMcp, Tool, ToolContext, z } from '@frontmcp/sdk';
 
 @Tool({
   name: 'search',

package/catalog/frontmcp-config/examples/configure-auth/remote-oauth-with-vault.md

@@ -18,8 +18,7 @@ Configure a FrontMCP server with remote OAuth 2.1 authentication and use the cre
 
 ```typescript
 // src/server.ts
-import { FrontMcp, App, Tool, ToolContext } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { App, FrontMcp, Tool, ToolContext, z } from '@frontmcp/sdk';
 
 @Tool({
   name: 'create_github_issue',

package/catalog/frontmcp-config/examples/configure-auth-modes/local-self-signed-tokens.md

@@ -20,8 +20,7 @@ Configure a server that signs its own JWT tokens with consent and incremental au
 
 ```typescript
 // src/server.ts
-import { FrontMcp, App, Tool, ToolContext } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { App, FrontMcp, Tool, ToolContext, z } from '@frontmcp/sdk';
 
 @Tool({
   name: 'manage_users',

package/catalog/frontmcp-config/examples/configure-auth-modes/remote-enterprise-oauth.md

@@ -19,8 +19,7 @@ Delegate authentication to an external OAuth orchestrator with Redis-backed toke
 
 ```typescript
 // src/server.ts
-import { FrontMcp, App, Tool, ToolContext } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { App, FrontMcp, Tool, ToolContext, z } from '@frontmcp/sdk';
 
 @Tool({
   name: 'query_data',

package/catalog/frontmcp-config/examples/configure-auth-modes/transparent-jwt-validation.md

@@ -18,8 +18,7 @@ Validate externally-issued JWTs without managing token lifecycle on the server.
 
 ```typescript
 // src/server.ts
-import { FrontMcp, App, Tool, ToolContext } from '@frontmcp/sdk';
-import { z } from 'zod';
+import { App, FrontMcp, Tool, ToolContext, z } from '@frontmcp/sdk';
 
 @Tool({
   name: 'get_profile',

package/catalog/frontmcp-config/examples/configure-deployment-targets/distributed-ha-config.md

@@ -0,0 +1,121 @@
+---
+name: distributed-ha-config
+reference: configure-deployment-targets
+level: advanced
+description: Configure a distributed deployment target with HA settings for heartbeat, session takeover, and Redis-backed session persistence
+tags: [config, deployment, distributed, ha, redis, heartbeat, session-takeover]
+features:
+  - Configuring the distributed deployment target with HA options
+  - Setting custom heartbeat intervals and TTL for pod liveness detection
+  - Combining server config (CSP, cookies) with HA config in the same target
+  - Using per-target environment variables for Redis connection
+---
+
+# Distributed Deployment with HA Configuration
+
+Configure a distributed deployment target with HA settings for heartbeat, session takeover, and Redis-backed session persistence
+
+## Code
+
+```typescript
+// frontmcp.config.ts
+import { defineConfig } from '@frontmcp/cli';
+
+export default defineConfig({
+  name: 'ha-server',
+  version: '1.0.0',
+  deployments: [
+    // Development: standalone Node.js
+    {
+      target: 'node',
+      server: { http: { port: 3000 } },
+    },
+
+    // Production: distributed with HA
+    {
+      target: 'distributed',
+      ha: {
+        heartbeatIntervalMs: 5000, // Write heartbeat every 5s (fast detection)
+        heartbeatTtlMs: 15000, // 3x interval for TTL
+        takeoverGracePeriodMs: 3000, // Wait 3s before claiming orphaned sessions
+        redisKeyPrefix: 'mcp:ha:', // Default prefix for all HA keys
+      },
+      server: {
+        http: { port: 8080 },
+        cookies: {
+          affinity: '__myapp_node', // Custom affinity cookie name
+          sameSite: 'Lax',
+        },
+        csp: {
+          enabled: true,
+          directives: { 'default-src': "'self'" },
+        },
+      },
+      env: {
+        REDIS_HOST: 'redis.prod.internal',
+        NODE_ENV: 'production',
+      },
+    },
+  ],
+});
+```
+
+### Build Both Targets
+
+```bash
+# Development
+frontmcp build --target node
+
+# Production
+FRONTMCP_DEPLOYMENT_MODE=distributed frontmcp build --target distributed
+```
+
+### Server Code
+
+```typescript
+// src/main.ts
+import { App, FrontMcp, Tool, ToolContext, z } from '@frontmcp/sdk';
+
+@Tool({ name: 'status', description: 'Server status', inputSchema: {} })
+class StatusTool extends ToolContext {
+  async execute() {
+    return { status: 'healthy', timestamp: Date.now() };
+  }
+}
+
+@App({ name: 'main', tools: [StatusTool] })
+class MainApp {}
+
+@FrontMcp({
+  info: { name: 'ha-server', version: '1.0.0' },
+  apps: [MainApp],
+  redis: {
+    provider: 'redis',
+    host: process.env['REDIS_HOST'] || 'localhost',
+    port: 6379,
+  },
+  transport: {
+    persistence: {
+      redis: {
+        provider: 'redis',
+        host: process.env['REDIS_HOST'] || 'localhost',
+        port: 6379,
+      },
+    },
+  },
+})
+class Server {}
+```
+
+## What This Demonstrates
+
+- Configuring the distributed deployment target with HA options
+- Setting custom heartbeat intervals and TTL for pod liveness detection
+- Combining server config (CSP, cookies) with HA config in the same target
+- Using per-target environment variables for Redis connection
+
+## Related
+
+- See `configure-deployment-targets` for the full multi-target reference
+- See `distributed-ha` for the HA architecture deep dive
+- See `configure-security-headers` for full security headers setup