@frontmcp/skills 1.1.2-beta.1 → 1.2.0

package/catalog/frontmcp-deployment/examples/build-for-browser/browser-build-with-custom-entry.md

@@ -2,25 +2,36 @@
 name: browser-build-with-custom-entry
 reference: build-for-browser
 level: intermediate
-description: 'Build a browser bundle using a dedicated client entry file that avoids Node.js-only imports.'
-tags: [deployment, browser, node, custom, entry]
+description: Build a browser bundle using a dedicated client entry file that avoids Node.js-only imports. Re-export the real `@frontmcp/react` symbols (`useListTools`, `useListResources`, `useCallTool`) — `useTools`/`useResources` do not exist.
+tags:
+  - deployment
+  - browser
+  - custom
+  - entry
 features:
-  - 'Creating a separate browser entry point (`src/client.ts`) that avoids importing Node.js-only modules like `fs` or `node:crypto`'
-  - 'Using the `-e` and `-o` flags to customize the entry file and output directory'
+  - Creating a separate browser entry point (`src/client.ts`) that re-exports only browser-safe symbols
+  - Using the real `@frontmcp/react` hook names (`useListTools`, `useListResources`, etc.)
+  - Using the `-e` and `-o` flags to customize the entry file and output directory
 ---
 
 # Browser Build with Custom Entry
 
-Build a browser bundle using a dedicated client entry file that avoids Node.js-only imports.
+Build a browser bundle using a dedicated client entry file that avoids Node.js-only imports. Re-export the real `@frontmcp/react` symbols (`useListTools`, `useListResources`, `useCallTool`) — `useTools`/`useResources` do not exist.
 
 ## Code
 
 ```typescript
 // src/client.ts
-// Browser-safe entry point - no Node.js modules imported here
-import { FrontMcpProvider, useTools, useResources } from '@frontmcp/react';
-
-export { FrontMcpProvider, useTools, useResources };
+// Browser-safe entry point — no Node.js modules imported here.
+export {
+  FrontMcpProvider,
+  useListTools,
+  useListResources,
+  useListPrompts,
+  useCallTool,
+  useReadResource,
+  useGetPrompt,
+} from '@frontmcp/react';
 ```
 
 ```bash
@@ -29,13 +40,14 @@ frontmcp build --target browser -e ./src/client.ts -o ./dist/browser
 ```
 
 ```bash
-# Verify output contains no Node.js-only modules
+# Verify output directory contents
 ls dist/browser/
 ```
 
 ## What This Demonstrates
 
-- Creating a separate browser entry point (`src/client.ts`) that avoids importing Node.js-only modules like `fs` or `node:crypto`
+- Creating a separate browser entry point (`src/client.ts`) that re-exports only browser-safe symbols
+- Using the real `@frontmcp/react` hook names (`useListTools`, `useListResources`, etc.)
 - Using the `-e` and `-o` flags to customize the entry file and output directory
 
 ## Related

package/catalog/frontmcp-deployment/examples/build-for-browser/browser-crypto-and-storage.md

@@ -2,22 +2,27 @@
 name: browser-crypto-and-storage
 reference: build-for-browser
 level: advanced
-description: 'Use `@frontmcp/utils` crypto functions (WebCrypto API) and in-memory storage in browser environments.'
-tags: [deployment, browser, database, remote, node, crypto]
+description: Use `@frontmcp/utils` crypto in the browser, and create the FrontMCP server with `create()` from `@frontmcp/sdk` so the React provider can consume it via the `server` prop.
+tags:
+  - deployment
+  - browser
+  - crypto
+  - react
 features:
-  - 'Using `@frontmcp/utils` for PKCE and hashing in the browser (backed by WebCrypto, not `node:crypto`)'
-  - 'Avoiding filesystem and native database storage in browser builds by relying on a remote server for persistence'
+  - Using `@frontmcp/utils` for PKCE and hashing in the browser (backed by WebCrypto, not `node:crypto`)
+  - Creating a `DirectMcpServer` with `create()` and passing it to `FrontMcpProvider` via `server={...}` (no `config={{ serverUrl }}`)
+  - Using `useListTools` (real hook) instead of the non-existent `useTools`
 ---
 
 # Browser-Safe Crypto and Storage
 
-Use `@frontmcp/utils` crypto functions (WebCrypto API) and in-memory storage in browser environments.
+Use `@frontmcp/utils` crypto in the browser, and create the FrontMCP server with `create()` from `@frontmcp/sdk` so the React provider can consume it via the `server` prop.
 
 ## Code
 
 ```typescript
 // src/browser-auth.ts
-import { generateCodeVerifier, generateCodeChallenge, sha256Base64url, randomUUID } from '@frontmcp/utils';
+import { generateCodeChallenge, generateCodeVerifier, randomUUID, sha256Base64url } from '@frontmcp/utils';
 
 // PKCE flow in the browser - uses WebCrypto API automatically
 async function startPkceFlow(): Promise<{
@@ -40,27 +45,48 @@ async function hashToken(token: string): Promise<string> {
 export { startPkceFlow, hashToken };
 ```
 
+```typescript
+// src/server.ts — in-memory DirectMcpServer for the React app.
+//
+// NOTE: this file uses top-level `await`, which requires ES2022 module support.
+// The browser build target (target: "es2022", module: "esnext") emits the bundle
+// as an ES module so top-level await is preserved end-to-end.
+import { create, tool, z } from '@frontmcp/sdk';
+
+export const server = await create({
+  info: { name: 'browser-app', version: '1.0.0' },
+  tools: [
+    tool({
+      name: 'echo',
+      description: 'Echo input',
+      inputSchema: { msg: z.string() },
+    })((input) => ({
+      content: [{ type: 'text' as const, text: input.msg }],
+    })),
+  ],
+});
+```
+
 ```typescript
 // src/client-app.tsx
-import { FrontMcpProvider, useTools } from '@frontmcp/react';
+import { FrontMcpProvider, useListTools } from '@frontmcp/react';
+
+import { server } from './server';
 
-// Browser environments cannot use Redis or SQLite.
-// Use in-memory stores or connect to a remote server that handles persistence.
+// Browser environments cannot use Redis or SQLite. Either keep state in
+// memory (DirectMcpServer is in-process) or call a remote server from your
+// tools — the SDK does NOT include a built-in browser-side persistence layer.
 function App() {
   return (
-    <FrontMcpProvider
-      config={{
-        serverUrl: 'https://my-mcp.example.com',
-        // No local storage config - the remote server handles persistence
-      }}
-    >
+    <FrontMcpProvider server={server}>
       <ToolDashboard />
     </FrontMcpProvider>
   );
 }
 
 function ToolDashboard() {
-  const { tools, callTool } = useTools();
+  const { data } = useListTools();
+  const tools = data?.tools ?? [];
 
   return (
     <div>
@@ -78,7 +104,8 @@ export default App;
 ## What This Demonstrates
 
 - Using `@frontmcp/utils` for PKCE and hashing in the browser (backed by WebCrypto, not `node:crypto`)
-- Avoiding filesystem and native database storage in browser builds by relying on a remote server for persistence
+- Creating a `DirectMcpServer` with `create()` and passing it to `FrontMcpProvider` via `server={...}` (no `config={{ serverUrl }}`)
+- Using `useListTools` (real hook) instead of the non-existent `useTools`
 
 ## Related
 

package/catalog/frontmcp-deployment/examples/build-for-browser/react-provider-setup.md

@@ -2,60 +2,92 @@
 name: react-provider-setup
 reference: build-for-browser
 level: basic
-description: 'Connect a React application to a remote FrontMCP server using `@frontmcp/react`.'
-tags: [deployment, react, browser, remote, provider, setup]
+description: Connect a React application to a FrontMCP server using `@frontmcp/react`. `FrontMcpProvider` takes a `DirectMcpServer` instance via the `server` prop — there is no `serverUrl` option.
+tags:
+  - deployment
+  - react
+  - browser
+  - provider
+  - setup
 features:
-  - 'Wrapping your React app with `FrontMcpProvider` and pointing it at a remote server URL'
-  - 'Using the `useTools` hook to list and invoke MCP tools from a React component'
+  - Wrapping your React app with `FrontMcpProvider` and passing a real `DirectMcpServer` via `server={...}`
+  - Using `useListTools` to fetch the tools list and `useCallTool` to invoke one
+  - Creating the server with `create()` from `@frontmcp/sdk` (in-memory direct connection)
 ---
 
 # React Provider Setup
 
-Connect a React application to a remote FrontMCP server using `@frontmcp/react`.
+Connect a React application to a FrontMCP server using `@frontmcp/react`. `FrontMcpProvider` takes a `DirectMcpServer` instance via the `server` prop — there is no `serverUrl` option.
 
 ## Code
 
+```typescript
+// src/server.ts — create a DirectMcpServer (in-memory) for the React app to consume.
+import { create, tool, z } from '@frontmcp/sdk';
+
+export const server = await create({
+  info: { name: 'browser-app', version: '1.0.0' },
+  tools: [
+    tool({
+      name: 'greet',
+      description: 'Greet a user',
+      inputSchema: { name: z.string() },
+    })((input) => ({
+      content: [{ type: 'text' as const, text: `Hello, ${input.name}!` }],
+    })),
+  ],
+});
+```
+
 ```typescript
 // src/App.tsx
-import { FrontMcpProvider, useTools } from '@frontmcp/react';
+import { FrontMcpProvider, useCallTool, useListTools } from '@frontmcp/react';
+
+import { server } from './server';
 
 function App() {
   return (
-    <FrontMcpProvider config={{ serverUrl: 'https://my-mcp.example.com' }}>
+    <FrontMcpProvider server={server}>
       <ToolUI />
     </FrontMcpProvider>
   );
 }
 
 function ToolUI() {
-  const { tools, callTool } = useTools();
-
-  const handleClick = async (toolName: string) => {
-    const result = await callTool(toolName, { query: 'hello' });
-    console.log(result);
-  };
-
+  // useListTools returns ToolInfo[] directly (live-updates from the registry).
+  const tools = useListTools();
   return (
     <ul>
-      {tools.map((tool) => (
-        <li key={tool.name}>
-          <button onClick={() => handleClick(tool.name)}>
-            {tool.name}: {tool.description}
-          </button>
+      {tools.map((t) => (
+        <li key={t.name}>
+          <ToolButton tool={t} />
         </li>
       ))}
     </ul>
   );
 }
 
+// useCallTool requires the tool name as a hook arg, so each row owns its own
+// hook instance. The mutate fn takes just the arguments object — not `{ name, arguments }`.
+function ToolButton({ tool }: { tool: { name: string; description?: string } }) {
+  const [callTool] = useCallTool<{ name: string }>(tool.name);
+  return (
+    <button onClick={() => callTool({ name: 'World' })}>
+      {tool.name}: {tool.description}
+    </button>
+  );
+}
+
 export default App;
 ```
 
 ## What This Demonstrates
 
-- Wrapping your React app with `FrontMcpProvider` and pointing it at a remote server URL
-- Using the `useTools` hook to list and invoke MCP tools from a React component
+- Wrapping your React app with `FrontMcpProvider` and passing a real `DirectMcpServer` via `server={...}`
+- Using `useListTools` to fetch the tools list and `useCallTool` to invoke one
+- Creating the server with `create()` from `@frontmcp/sdk` (in-memory direct connection)
 
 ## Related
 
 - See `build-for-browser` for the full build command and browser limitations
+- See `build-for-sdk` for the `create()` factory and `tool()` builder

package/catalog/frontmcp-deployment/examples/build-for-cli/cli-binary-build.md

@@ -25,7 +25,7 @@ import { App, FrontMcp, Tool, ToolContext, z } from '@frontmcp/sdk';
   description: 'Greet a user by name',
   inputSchema: { name: z.string() },
 })
-class GreetTool extends ToolContext<{ name: string }> {
+class GreetTool extends ToolContext {
   async execute(input: { name: string }) {
     return { content: [{ type: 'text' as const, text: `Hello, ${input.name}!` }] };
   }

package/catalog/frontmcp-deployment/examples/build-for-cli/unix-socket-daemon.md

@@ -25,7 +25,7 @@ import { App, FrontMcp, Tool, ToolContext, z } from '@frontmcp/sdk';
   description: 'Look up a term in the local database',
   inputSchema: { term: z.string() },
 })
-class LookupTool extends ToolContext<{ term: string }> {
+class LookupTool extends ToolContext {
   async execute(input: { term: string }) {
     return { content: [{ type: 'text' as const, text: `Result for: ${input.term}` }] };
   }

package/catalog/frontmcp-deployment/examples/build-for-mcpb/mcpb-bundle-build.md

@@ -25,7 +25,7 @@ import { App, FrontMcp, Tool, ToolContext, z } from '@frontmcp/sdk';
   description: 'Greet a user by name',
   inputSchema: { name: z.string() },
 })
-class GreetTool extends ToolContext<{ name: string }> {
+class GreetTool extends ToolContext {
   async execute(input: { name: string }) {
     const apiBase = process.env.API_BASE ?? 'https://api.example.com';
     return {

package/catalog/frontmcp-deployment/examples/build-for-sdk/connect-openai.md

@@ -25,7 +25,7 @@ import { App, connectOpenAI, FrontMcp, Tool, ToolContext, z } from '@frontmcp/sd
   description: 'Search documentation by keyword',
   inputSchema: { query: z.string(), limit: z.number().optional() },
 })
-class SearchDocsTool extends ToolContext<{ query: string; limit?: number }> {
+class SearchDocsTool extends ToolContext {
   async execute(input: { query: string; limit?: number }) {
     return {
       content: [{ type: 'text' as const, text: `Found results for: ${input.query}` }],

package/catalog/frontmcp-deployment/examples/build-for-sdk/multi-platform-connect.md

@@ -25,7 +25,7 @@ import { App, FrontMcp, Tool, ToolContext, z } from '@frontmcp/sdk';
   description: 'Translate text to a target language',
   inputSchema: { text: z.string(), targetLang: z.string() },
 })
-class TranslateTool extends ToolContext<{ text: string; targetLang: string }> {
+class TranslateTool extends ToolContext {
   async execute(input: { text: string; targetLang: string }) {
     return {
       content: [{ type: 'text' as const, text: `[${input.targetLang}] ${input.text}` }],

package/catalog/frontmcp-deployment/examples/deploy-to-cloudflare/basic-worker-deploy.md

@@ -25,7 +25,7 @@ import { App, FrontMcp, Tool, ToolContext, z } from '@frontmcp/sdk';
   description: 'Echo back the input',
   inputSchema: { message: z.string() },
 })
-class EchoTool extends ToolContext<{ message: string }> {
+class EchoTool extends ToolContext {
   async execute(input: { message: string }) {
     return { content: [{ type: 'text' as const, text: input.message }] };
   }
@@ -47,13 +47,12 @@ export default MyServer;
 ```
 
 ```toml
-# wrangler.toml
+# wrangler.toml — the Cloudflare adapter overwrites this on every build
+# with exactly these three lines (configure name/compatibility_date via
+# frontmcp.config.deployments[].wrangler).
 name = "frontmcp-worker"
-main = "dist/index.js"
+main = "dist/cloudflare/index.js"
 compatibility_date = "2024-01-01"
-
-[vars]
-NODE_ENV = "production"
 ```
 
 ```bash
@@ -66,8 +65,8 @@ wrangler dev
 # Deploy to production
 wrangler deploy
 
-# Verify
-curl https://frontmcp-worker.your-subdomain.workers.dev/health
+# Verify (FrontMCP serves /healthz by default)
+curl https://frontmcp-worker.your-subdomain.workers.dev/healthz
 ```
 
 ## What This Demonstrates

package/catalog/frontmcp-deployment/examples/deploy-to-cloudflare/worker-custom-domain.md

@@ -31,7 +31,7 @@ import { App, FrontMcp, Tool, ToolContext, z } from '@frontmcp/sdk';
   description: 'Translate text',
   inputSchema: { text: z.string(), lang: z.string() },
 })
-class TranslateTool extends ToolContext<{ text: string; lang: string }> {
+class TranslateTool extends ToolContext {
   async execute(input: { text: string; lang: string }) {
     return {
       content: [{ type: 'text' as const, text: `[${input.lang}] ${input.text}` }],
@@ -46,7 +46,7 @@ class TranslateApp {}
   info: { name: 'translate-worker', version: '1.0.0' },
   apps: [TranslateApp],
   transport: {
-    type: 'sse',
+    protocol: 'modern',
   },
 })
 class TranslateServer {}
@@ -55,9 +55,11 @@ export default TranslateServer;
 ```
 
 ```toml
-# wrangler.toml
+# wrangler.toml — name/compatibility_date are managed by frontmcp.config;
+# bindings appended below are re-applied after each build (the adapter
+# overwrites the top-level keys on every `frontmcp build --target cloudflare`).
 name = "translate-worker"
-main = "dist/index.js"
+main = "dist/cloudflare/index.js"
 compatibility_date = "2024-01-01"
 
 [[kv_namespaces]]
@@ -76,8 +78,8 @@ wrangler deploy
 # Add a custom domain
 wrangler domains add mcp.example.com
 
-# Verify health endpoint
-curl https://mcp.example.com/health
+# Verify health endpoint (FrontMCP serves /healthz by default)
+curl https://mcp.example.com/healthz
 
 # Test MCP endpoint
 curl -X POST https://mcp.example.com/mcp \

package/catalog/frontmcp-deployment/examples/deploy-to-cloudflare/worker-with-kv-storage.md

@@ -25,7 +25,7 @@ import { App, FrontMcp, Tool, ToolContext, z } from '@frontmcp/sdk';
   description: 'Store a value by key',
   inputSchema: { key: z.string(), value: z.string() },
 })
-class StoreValueTool extends ToolContext<{ key: string; value: string }> {
+class StoreValueTool extends ToolContext {
   async execute(input: { key: string; value: string }) {
     return {
       content: [{ type: 'text' as const, text: `Stored: ${input.key}` }],
@@ -40,7 +40,7 @@ class StorageApp {}
   info: { name: 'my-worker', version: '1.0.0' },
   apps: [StorageApp],
   transport: {
-    type: 'sse',
+    protocol: 'modern',
   },
 })
 class MyServer {}
@@ -49,9 +49,10 @@ export default MyServer;
 ```
 
 ```toml
-# wrangler.toml
+# wrangler.toml — name/main/compatibility_date are rewritten by the build.
+# Bindings below need to be re-applied (or appended) after each build.
 name = "frontmcp-worker"
-main = "dist/index.js"
+main = "dist/cloudflare/index.js"
 compatibility_date = "2024-01-01"
 
 [[kv_namespaces]]

package/catalog/frontmcp-deployment/examples/deploy-to-lambda/cdk-deployment.md

@@ -19,9 +19,9 @@ Deploy a FrontMCP server to AWS Lambda using CDK with provisioned concurrency an
 ```typescript
 // lib/frontmcp-stack.ts
 import * as cdk from 'aws-cdk-lib';
-import * as lambda from 'aws-cdk-lib/aws-lambda';
 import * as apigw from 'aws-cdk-lib/aws-apigatewayv2';
 import * as integrations from 'aws-cdk-lib/aws-apigatewayv2-integrations';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
 import { Construct } from 'constructs';
 
 export class FrontMcpStack extends cdk.Stack {
@@ -31,7 +31,7 @@ export class FrontMcpStack extends cdk.Stack {
     const fn = new lambda.Function(this, 'FrontMcpHandler', {
       runtime: lambda.Runtime.NODEJS_24_X,
       handler: 'handler.handler',
-      code: lambda.Code.fromAsset('.'),
+      code: lambda.Code.fromAsset('dist/lambda'),
       memorySize: 512,
       timeout: cdk.Duration.seconds(30),
       architecture: lambda.Architecture.ARM_64,
@@ -65,7 +65,10 @@ export class FrontMcpStack extends cdk.Stack {
 ```
 
 ```bash
-# Build the FrontMCP server
+# Install the peer dep validated by the lambda adapter
+npm install @codegenie/serverless-express
+
+# Build the FrontMCP server — emits dist/lambda/handler.cjs
 frontmcp build --target lambda
 
 # Store secrets in SSM Parameter Store
@@ -77,8 +80,8 @@ aws ssm put-parameter \
 # Deploy with CDK
 cdk deploy
 
-# Verify
-curl https://abc123.execute-api.us-east-1.amazonaws.com/health
+# Verify (FrontMCP serves /healthz by default)
+curl https://abc123.execute-api.us-east-1.amazonaws.com/healthz
 ```
 
 ## What This Demonstrates

package/catalog/frontmcp-deployment/examples/deploy-to-lambda/lambda-handler-with-cors.md

@@ -2,23 +2,26 @@
 name: lambda-handler-with-cors
 reference: deploy-to-lambda
 level: intermediate
-description: 'Create a custom Lambda handler with an explicit API Gateway definition for CORS support.'
-tags: [deployment, lambda, handler, cors]
+description: CORS for a FrontMCP Lambda is configured at the API Gateway HTTP API level, not in the handler. `frontmcp build --target lambda` writes `dist/lambda/handler.cjs` — your `@FrontMcp` server is wrapped automatically with `@codegenie/serverless-express`, so CORS belongs on the gateway.
+tags:
+  - deployment
+  - lambda
+  - handler
+  - cors
 features:
-  - 'Creating a custom Lambda handler with `createLambdaHandler()` from `@frontmcp/adapters/lambda`'
-  - 'Defining an explicit HTTP API resource with CORS configuration for cross-origin requests'
+  - Configuring CORS at the API Gateway HTTP API layer (not the handler) via `CorsConfiguration`
   - 'Linking the function events to the explicit API via `ApiId: !Ref`'
+  - Pointing SAM `CodeUri` at `dist/lambda/` so the auto-generated `handler.cjs` is uploaded
 ---
 
 # Lambda Handler with CORS and API Gateway
 
-Create a custom Lambda handler with an explicit API Gateway definition for CORS support.
+CORS for a FrontMCP Lambda is configured at the API Gateway HTTP API level, not in the handler. `frontmcp build --target lambda` writes `dist/lambda/handler.cjs` — your `@FrontMcp` server is wrapped automatically with `@codegenie/serverless-express`, so CORS belongs on the gateway.
 
 ## Code
 
 ```typescript
-// src/lambda.ts
-import { createLambdaHandler } from '@frontmcp/adapters/lambda';
+// src/main.ts — your @FrontMcp server. The CLI emits the Lambda handler.
 import { App, FrontMcp, Tool, ToolContext, z } from '@frontmcp/sdk';
 
 @Tool({
@@ -26,7 +29,7 @@ import { App, FrontMcp, Tool, ToolContext, z } from '@frontmcp/sdk';
   description: 'Analyze text content',
   inputSchema: { text: z.string() },
 })
-class AnalyzeTool extends ToolContext<{ text: string }> {
+class AnalyzeTool extends ToolContext {
   async execute(input: { text: string }) {
     return {
       content: [{ type: 'text' as const, text: `Analysis of: ${input.text}` }],
@@ -41,15 +44,11 @@ class AnalyzerApp {}
   info: { name: 'analyzer', version: '1.0.0' },
   apps: [AnalyzerApp],
 })
-class AnalyzerServer {}
-
-export const handler = createLambdaHandler(AnalyzerServer, {
-  streaming: false,
-});
+export default class AnalyzerServer {}
 ```
 
 ```yaml
-# template.yaml - with explicit API Gateway and CORS
+# template.yaml — explicit HTTP API with CORS configuration
 AWSTemplateFormatVersion: '2010-09-09'
 Transform: AWS::Serverless-2016-10-31
 Description: FrontMCP server with CORS
@@ -80,7 +79,7 @@ Resources:
     Type: AWS::Serverless::Function
     Properties:
       Handler: handler.handler
-      CodeUri: .
+      CodeUri: dist/lambda/
       Architectures:
         - arm64
       Environment:
@@ -96,6 +95,9 @@ Resources:
 ```
 
 ```bash
+# Make sure the peer dep is installed (the build's validate hook checks)
+npm install @codegenie/serverless-express
+
 # Build and deploy
 frontmcp build --target lambda
 sam build && sam deploy
@@ -103,10 +105,10 @@ sam build && sam deploy
 
 ## What This Demonstrates
 
-- Creating a custom Lambda handler with `createLambdaHandler()` from `@frontmcp/adapters/lambda`
-- Defining an explicit HTTP API resource with CORS configuration for cross-origin requests
+- Configuring CORS at the API Gateway HTTP API layer (not the handler) via `CorsConfiguration`
 - Linking the function events to the explicit API via `ApiId: !Ref`
+- Pointing SAM `CodeUri` at `dist/lambda/` so the auto-generated `handler.cjs` is uploaded
 
 ## Related
 
-- See `deploy-to-lambda` for secrets management, provisioned concurrency, and CDK deployment
+- See `deploy-to-lambda` for the peer-dep flow, secrets management, provisioned concurrency, and CDK deployment.

package/catalog/frontmcp-deployment/examples/deploy-to-lambda/sam-template-basic.md

@@ -37,7 +37,7 @@ Resources:
     Type: AWS::Serverless::Function
     Properties:
       Handler: handler.handler
-      CodeUri: .
+      CodeUri: dist/lambda/
       Description: FrontMCP MCP server
       Architectures:
         - arm64
@@ -50,7 +50,7 @@ Resources:
         HealthCheck:
           Type: HttpApi
           Properties:
-            Path: /health
+            Path: /healthz
             Method: GET
 
   FrontMcpLogGroup:
@@ -69,7 +69,10 @@ Outputs:
 ```
 
 ```bash
-# Build for Lambda
+# Install the peer dep validated by the lambda adapter
+npm install @codegenie/serverless-express
+
+# Build for Lambda — emits dist/lambda/handler.cjs with a `handler` export
 frontmcp build --target lambda
 
 # Deploy with guided prompts (first time)
@@ -85,8 +88,8 @@ aws cloudformation describe-stacks \
   --query "Stacks[0].Outputs[?OutputKey=='ApiEndpoint'].OutputValue" \
   --output text
 
-# Verify
-curl https://abc123.execute-api.us-east-1.amazonaws.com/health
+# Verify (FrontMCP serves /healthz by default)
+curl https://abc123.execute-api.us-east-1.amazonaws.com/healthz
 ```
 
 ## What This Demonstrates

package/catalog/frontmcp-deployment/examples/deploy-to-node/docker-compose-with-redis.md

@@ -37,7 +37,7 @@ services:
         condition: service_healthy
     restart: unless-stopped
     healthcheck:
-      test: ['CMD', 'wget', '-qO-', 'http://localhost:3000/health']
+      test: ['CMD', 'wget', '-qO-', 'http://localhost:3000/healthz']
       interval: 30s
       timeout: 5s
       retries: 3
@@ -76,7 +76,7 @@ COPY --from=builder /app/yarn.lock ./
 RUN yarn install --frozen-lockfile --production && yarn cache clean
 EXPOSE 3000
 HEALTHCHECK --interval=30s --timeout=5s --retries=3 --start-period=10s \
-  CMD wget -qO- http://localhost:3000/health || exit 1
+  CMD wget -qO- http://localhost:3000/healthz || exit 1
 CMD ["node", "dist/main.js"]
 ```
 
@@ -86,7 +86,7 @@ docker compose up -d
 
 # Verify
 docker compose ps
-curl http://localhost:3000/health
+curl http://localhost:3000/healthz
 # {"status":"ok","uptime":12345}
 ```
 

package/catalog/frontmcp-deployment/examples/deploy-to-node/pm2-with-nginx.md

@@ -65,7 +65,7 @@ sudo ln -s /etc/nginx/sites-available/mcp.example.com /etc/nginx/sites-enabled/
 sudo nginx -t && sudo systemctl reload nginx
 
 # Verify
-curl https://mcp.example.com/health
+curl https://mcp.example.com/healthz
 ```
 
 ## What This Demonstrates