@frontmcp/skills 1.1.2 → 1.2.1

package/catalog/frontmcp-deployment/examples/deploy-to-node/resource-limits.md

@@ -46,7 +46,7 @@ services:
           memory: 256M
           cpus: '0.5'
     healthcheck:
-      test: ['CMD', 'wget', '-qO-', 'http://localhost:3000/health']
+      test: ['CMD', 'wget', '-qO-', 'http://localhost:3000/healthz']
       interval: 30s
       timeout: 5s
       retries: 3
@@ -74,7 +74,7 @@ volumes:
 
 ```bash
 # Verify health check endpoint
-curl http://localhost:3000/health
+curl http://localhost:3000/healthz
 # {"status":"ok","uptime":12345}
 
 # Monitor resource usage

package/catalog/frontmcp-deployment/examples/deploy-to-node-dockerfile/basic-multistage-dockerfile.md

@@ -39,7 +39,7 @@ RUN yarn install --frozen-lockfile --production && \
     yarn cache clean
 EXPOSE 3000
 HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
-    CMD wget --no-verbose --tries=1 --spider http://localhost:3000/health || exit 1
+    CMD wget --no-verbose --tries=1 --spider http://localhost:3000/healthz || exit 1
 CMD ["node", "dist/main.js"]
 ```
 
@@ -49,7 +49,7 @@ docker build -t my-frontmcp-server .
 docker run -p 3000:3000 -e NODE_ENV=production my-frontmcp-server
 
 # Verify
-curl http://localhost:3000/health
+curl http://localhost:3000/healthz
 ```
 
 ## What This Demonstrates

package/catalog/frontmcp-deployment/examples/deploy-to-node-dockerfile/secure-nonroot-dockerfile.md

@@ -55,7 +55,7 @@ ENV PORT=3000
 EXPOSE 3000
 
 HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
-    CMD wget --no-verbose --tries=1 --spider http://localhost:3000/health || exit 1
+    CMD wget --no-verbose --tries=1 --spider http://localhost:3000/healthz || exit 1
 
 CMD ["node", "dist/main.js"]
 ```

package/catalog/frontmcp-deployment/examples/deploy-to-vercel/vercel-mcp-endpoint-test.md

@@ -2,23 +2,28 @@
 name: vercel-mcp-endpoint-test
 reference: deploy-to-vercel
 level: advanced
-description: 'Verify a Vercel-deployed FrontMCP server by testing health, tool listing, and tool invocation.'
-tags: [deployment, json-rpc, vercel, mcp, endpoint]
+description: Verify a Vercel-deployed FrontMCP server by testing health, tool listing, and tool invocation. The CLI emits the Build Output API v3 structure — there is no `api/frontmcp.ts` to test against; the function lives at `.vercel/output/functions/index.func/handler.cjs` and is routed via `.vercel/output/config.json`.
+tags:
+  - deployment
+  - json-rpc
+  - vercel
+  - mcp
+  - endpoint
 features:
-  - 'Testing the health endpoint and MCP JSON-RPC API of a deployed Vercel function'
-  - 'Using preview deployments to validate changes before promoting to production'
-  - 'Setting `maxDuration` according to your Vercel plan (Hobby: 10s, Pro: 60s, Enterprise: 900s)'
+  - Testing the health endpoint (`/healthz`) and MCP JSON-RPC API of a deployed Vercel function
+  - Using preview deployments to validate changes before promoting to production
+  - "Vercel plan limits for `maxDuration` (Hobby: 10s, Pro: 60s, Enterprise: 900s) — configure these in the Vercel dashboard, not via `functions: { 'api/frontmcp.ts': ... }`"
 ---
 
 # Testing a Vercel MCP Endpoint
 
-Verify a Vercel-deployed FrontMCP server by testing health, tool listing, and tool invocation.
+Verify a Vercel-deployed FrontMCP server by testing health, tool listing, and tool invocation. The CLI emits the Build Output API v3 structure — there is no `api/frontmcp.ts` to test against; the function lives at `.vercel/output/functions/index.func/handler.cjs` and is routed via `.vercel/output/config.json`.
 
 ## Code
 
 ```bash
-# Health check
-curl https://your-project.vercel.app/health
+# Health check (FrontMCP serves /healthz by default; /health is a legacy alias)
+curl https://your-project.vercel.app/healthz
 # {"status":"ok"}
 
 # List tools via JSON-RPC
@@ -33,36 +38,33 @@ curl -X POST https://your-project.vercel.app/mcp \
 ```
 
 ```bash
-# Preview deployment for PR testing
+# Build, then preview deployment for PR testing
+frontmcp build --target vercel
 vercel
 # Creates a unique preview URL: https://my-project-abc123.vercel.app
 
 # Test the preview before promoting to production
-curl https://my-project-abc123.vercel.app/health
+curl https://my-project-abc123.vercel.app/healthz
 
 # Promote to production
 vercel --prod
 ```
 
 ```json
-// vercel.json - with maxDuration matching your plan
+// vercel.json — auto-written by the build adapter; do not add `functions` or
+// `rewrites` keyed on `api/frontmcp.ts`/`.js` (no such file exists).
 {
-  "rewrites": [{ "source": "/(.*)", "destination": "/api/frontmcp" }],
-  "functions": {
-    "api/frontmcp.ts": {
-      "memory": 1024,
-      "maxDuration": 10
-    }
-  },
-  "regions": ["iad1"]
+  "version": 2,
+  "buildCommand": "yarn build",
+  "installCommand": "yarn install"
 }
 ```
 
 ## What This Demonstrates
 
-- Testing the health endpoint and MCP JSON-RPC API of a deployed Vercel function
+- Testing the health endpoint (`/healthz`) and MCP JSON-RPC API of a deployed Vercel function
 - Using preview deployments to validate changes before promoting to production
-- Setting `maxDuration` according to your Vercel plan (Hobby: 10s, Pro: 60s, Enterprise: 900s)
+- Vercel plan limits for `maxDuration` (Hobby: 10s, Pro: 60s, Enterprise: 900s) — configure these in the Vercel dashboard, not via `functions: { 'api/frontmcp.ts': ... }`
 
 ## Related
 

package/catalog/frontmcp-deployment/examples/deploy-to-vercel/vercel-with-kv.md

@@ -2,22 +2,28 @@
 name: vercel-with-kv
 reference: deploy-to-vercel
 level: basic
-description: 'Deploy a FrontMCP server to Vercel serverless functions with Vercel KV for session persistence.'
-tags: [deployment, vercel-kv, vercel, session, performance, serverless]
+description: Deploy a FrontMCP server to Vercel serverless functions with Vercel KV for session persistence. The CLI emits the full Build Output API v3 structure for you — you do **not** author `api/frontmcp.ts` and you do **not** add a `rewrites` block.
+tags:
+  - deployment
+  - vercel-kv
+  - vercel
+  - session
+  - performance
+  - serverless
 features:
   - "Configuring `{ provider: 'vercel-kv' }` for automatic Vercel KV session storage"
-  - 'The `vercel.json` catch-all rewrite that routes all requests to the single FrontMCP handler'
-  - 'Setting function memory to 1024 MB for faster cold starts'
+  - Letting the CLI produce the Build Output API v3 structure (no manual `api/` directory or `rewrites`)
+  - Deploying with `vercel --prod` after the build emits `.vercel/output/`
 ---
 
 # Deploy to Vercel with KV Storage
 
-Deploy a FrontMCP server to Vercel serverless functions with Vercel KV for session persistence.
+Deploy a FrontMCP server to Vercel serverless functions with Vercel KV for session persistence. The CLI emits the full Build Output API v3 structure for you — you do **not** author `api/frontmcp.ts` and you do **not** add a `rewrites` block.
 
 ## Code
 
 ```typescript
-// src/server.ts
+// src/main.ts
 import { App, FrontMcp, Tool, ToolContext, z } from '@frontmcp/sdk';
 
 @Tool({
@@ -25,7 +31,7 @@ import { App, FrontMcp, Tool, ToolContext, z } from '@frontmcp/sdk';
   description: 'Greet a user',
   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}!` }] };
   }
@@ -39,25 +45,22 @@ class MyApp {}
   apps: [MyApp],
   redis: { provider: 'vercel-kv' },
 })
-class MyServer {}
+export default class MyServer {}
 ```
 
 ```json
-// vercel.json
+// vercel.json — written for you by `frontmcp build --target vercel`.
+// buildCommand/installCommand are detected from your lockfile.
 {
-  "rewrites": [{ "source": "/(.*)", "destination": "/api/frontmcp" }],
-  "functions": {
-    "api/frontmcp.ts": {
-      "memory": 1024,
-      "maxDuration": 60
-    }
-  },
-  "regions": ["iad1"]
+  "version": 2,
+  "buildCommand": "yarn build",
+  "installCommand": "yarn install"
 }
 ```
 
 ```bash
-# Build for Vercel
+# Build for Vercel — emits .vercel/output/functions/index.func/handler.cjs
+# plus .vercel/output/config.json with the catch-all route.
 frontmcp build --target vercel
 
 # Preview deployment
@@ -66,15 +69,15 @@ vercel
 # Production deployment
 vercel --prod
 
-# Verify
-curl https://your-project.vercel.app/health
+# Verify (FrontMCP serves /healthz by default)
+curl https://your-project.vercel.app/healthz
 ```
 
 ## What This Demonstrates
 
 - Configuring `{ provider: 'vercel-kv' }` for automatic Vercel KV session storage
-- The `vercel.json` catch-all rewrite that routes all requests to the single FrontMCP handler
-- Setting function memory to 1024 MB for faster cold starts
+- Letting the CLI produce the Build Output API v3 structure (no manual `api/` directory or `rewrites`)
+- Deploying with `vercel --prod` after the build emits `.vercel/output/`
 
 ## Related
 

package/catalog/frontmcp-deployment/examples/deploy-to-vercel/vercel-with-skills-cache.md

@@ -2,23 +2,28 @@
 name: vercel-with-skills-cache
 reference: deploy-to-vercel
 level: intermediate
-description: 'Deploy a FrontMCP server to Vercel with skills enabled and KV-backed skill caching.'
-tags: [deployment, vercel-kv, vercel, cache, security, skills]
+description: Deploy a FrontMCP server to Vercel with skills enabled and KV-backed skill caching. The CLI handles the Build Output API v3 emission for you — your job is to configure the server and provision Vercel KV.
+tags:
+  - deployment
+  - vercel-kv
+  - vercel
+  - cache
+  - skills
 features:
-  - 'Enabling skills cache backed by Vercel KV with a 60-second TTL'
-  - 'Setting environment variables via `vercel env add` instead of hardcoding in source'
-  - 'Adding security headers (`X-Content-Type-Options`, `X-Frame-Options`) in `vercel.json`'
+  - Enabling skills cache backed by Vercel KV with a 60-second TTL
+  - Setting environment variables via `vercel env add` instead of hardcoding in source
+  - Letting the CLI emit the Build Output API v3 structure rather than hand-authoring `api/frontmcp.ts`
 ---
 
 # Vercel Deployment with Skills Cache
 
-Deploy a FrontMCP server to Vercel with skills enabled and KV-backed skill caching.
+Deploy a FrontMCP server to Vercel with skills enabled and KV-backed skill caching. The CLI handles the Build Output API v3 emission for you — your job is to configure the server and provision Vercel KV.
 
 ## Code
 
 ```typescript
-// src/server.ts
-import { FrontMcp, App } from '@frontmcp/sdk';
+// src/main.ts
+import { App, FrontMcp } from '@frontmcp/sdk';
 
 @App({ name: 'MyApp' })
 class MyApp {}
@@ -36,11 +41,12 @@ class MyApp {}
     },
   },
 })
-class MyServer {}
+export default class MyServer {}
 ```
 
 ```bash
-# Set environment variables via Vercel CLI
+# Set environment variables via Vercel CLI (or link KV in the dashboard
+# to inject KV_REST_API_URL/KV_REST_API_TOKEN automatically)
 vercel env add KV_REST_API_URL "https://your-kv-store.kv.vercel-storage.com"
 vercel env add KV_REST_API_TOKEN "your-token"
 vercel env add NODE_ENV production
@@ -48,30 +54,17 @@ vercel env add LOG_LEVEL info
 ```
 
 ```json
-// vercel.json
+// vercel.json — written by `frontmcp build --target vercel` from your lockfile.
+// Do not add functions/rewrites referencing api/frontmcp.* (no such file).
 {
-  "rewrites": [{ "source": "/(.*)", "destination": "/api/frontmcp" }],
-  "functions": {
-    "api/frontmcp.ts": {
-      "memory": 1024,
-      "maxDuration": 60
-    }
-  },
-  "regions": ["iad1"],
-  "headers": [
-    {
-      "source": "/(.*)",
-      "headers": [
-        { "key": "X-Content-Type-Options", "value": "nosniff" },
-        { "key": "X-Frame-Options", "value": "DENY" }
-      ]
-    }
-  ]
+  "version": 2,
+  "buildCommand": "yarn build",
+  "installCommand": "yarn install"
 }
 ```
 
 ```bash
-# Deploy to production
+# Build, then deploy to production
 frontmcp build --target vercel
 vercel --prod
 
@@ -83,7 +76,7 @@ vercel domains add mcp.example.com
 
 - Enabling skills cache backed by Vercel KV with a 60-second TTL
 - Setting environment variables via `vercel env add` instead of hardcoding in source
-- Adding security headers (`X-Content-Type-Options`, `X-Frame-Options`) in `vercel.json`
+- Letting the CLI emit the Build Output API v3 structure rather than hand-authoring `api/frontmcp.ts`
 
 ## Related
 

package/catalog/frontmcp-deployment/examples/deploy-to-vercel-config/minimal-vercel-config.md

@@ -2,48 +2,72 @@
 name: minimal-vercel-config
 reference: deploy-to-vercel-config
 level: basic
-description: 'The minimum `vercel.json` needed to deploy a FrontMCP server to Vercel.'
-tags: [deployment, vercel, serverless, config, minimal]
+description: '`frontmcp build --target vercel` writes this minimal `vercel.json` for you. The package manager is detected from your lockfile.'
+tags:
+  - deployment
+  - vercel
+  - serverless
+  - config
+  - minimal
 features:
-  - 'The catch-all rewrite (`/(.*) -> /api/frontmcp`) routes all requests to the single FrontMCP handler'
-  - 'Setting `buildCommand` and `outputDirectory` so Vercel uses the FrontMCP build pipeline'
-  - 'Configuring function memory (512 MB) and max duration (30s) for the serverless function'
+  - The exact shape of the auto-generated `vercel.json` — three keys, nothing else
+  - That routing and function configuration live in `.vercel/output/`, not `vercel.json`
+  - That hand-authoring `api/frontmcp.ts` references in `vercel.json` is unnecessary and breaks deploys
 ---
 
-# Minimal vercel.json Configuration
+# Minimal vercel.json (auto-generated)
 
-The minimum `vercel.json` needed to deploy a FrontMCP server to Vercel.
+`frontmcp build --target vercel` writes this minimal `vercel.json` for you. The package manager is detected from your lockfile.
 
 ## Code
 
 ```json
-// vercel.json
+// vercel.json — yarn project (yarn.lock present)
 {
-  "$schema": "https://openapi.vercel.sh/vercel.json",
-  "buildCommand": "frontmcp build --target vercel",
-  "outputDirectory": "dist",
-  "rewrites": [
-    {
-      "source": "/(.*)",
-      "destination": "/api/frontmcp"
-    }
-  ],
-  "functions": {
-    "api/frontmcp.js": {
-      "memory": 512,
-      "maxDuration": 30
-    }
-  },
-  "regions": ["iad1"]
+  "version": 2,
+  "buildCommand": "yarn build",
+  "installCommand": "yarn install"
 }
 ```
 
+```json
+// vercel.json — pnpm project (pnpm-lock.yaml present)
+{
+  "version": 2,
+  "buildCommand": "pnpm run build",
+  "installCommand": "pnpm install"
+}
+```
+
+```json
+// vercel.json — npm project (package-lock.json present)
+{
+  "version": 2,
+  "buildCommand": "npm run build",
+  "installCommand": "npm install"
+}
+```
+
+The actual function and routes live under `.vercel/output/`:
+
+```text
+.vercel/output/
+├── config.json                            # routes /(.*) -> /index function
+└── functions/
+    └── index.func/
+        ├── .vc-config.json                # nodejs24.x, handler: handler.cjs
+        ├── handler.cjs                    # bundled handler
+        ├── package.json                   # peer-dep manifest
+        └── node_modules/                  # peer deps installed by the adapter
+```
+
 ## What This Demonstrates
 
-- The catch-all rewrite (`/(.*) -> /api/frontmcp`) routes all requests to the single FrontMCP handler
-- Setting `buildCommand` and `outputDirectory` so Vercel uses the FrontMCP build pipeline
-- Configuring function memory (512 MB) and max duration (30s) for the serverless function
+- The exact shape of the auto-generated `vercel.json` — three keys, nothing else
+- That routing and function configuration live in `.vercel/output/`, not `vercel.json`
+- That hand-authoring `api/frontmcp.ts` references in `vercel.json` is unnecessary and breaks deploys
 
 ## Related
 
-- See `deploy-to-vercel-config` for the full reference configuration with security headers
+- See `deploy-to-vercel-config` for headers/regions you may safely add on top
+- See `deploy-to-vercel` for the full deployment workflow

package/catalog/frontmcp-deployment/examples/deploy-to-vercel-config/vercel-config-with-security-headers.md

@@ -2,78 +2,54 @@
 name: vercel-config-with-security-headers
 reference: deploy-to-vercel-config
 level: intermediate
-description: 'A complete `vercel.json` with per-route security headers for health, MCP, and all other endpoints.'
-tags: [deployment, vercel, cache, security, config, headers]
+description: "The Vercel adapter emits a minimal `vercel.json` (version + buildCommand + installCommand). You can layer extra Vercel-supported keys on top after the build — but never add `functions: { 'api/frontmcp.ts': ... }` or `rewrites` to `/api/frontmcp` (the build does not produce an `api/` directory)."
+tags:
+  - deployment
+  - vercel
+  - security
+  - config
+  - headers
 features:
-  - 'Per-route header configuration: `/health` and `/mcp` get `Cache-Control: no-store` to prevent caching'
-  - 'Global security headers (`X-Frame-Options`, `X-Content-Type-Options`, `Referrer-Policy`) applied to all routes'
-  - 'Setting `framework: null` to tell Vercel this is not a framework project'
+  - Adding `regions` to constrain function placement (e.g., `iad1` for US East)
+  - 'Per-route `Cache-Control: no-store` on `/healthz` and `/mcp` to prevent caching'
+  - 'Global security headers applied to all routes via the catch-all `source: "/(.*)"`'
 ---
 
-# vercel.json with Security Headers
+# vercel.json with Regions and Security Headers
 
-A complete `vercel.json` with per-route security headers for health, MCP, and all other endpoints.
+The Vercel adapter emits a minimal `vercel.json` (version + buildCommand + installCommand). You can layer extra Vercel-supported keys on top after the build — but never add `functions: { 'api/frontmcp.ts': ... }` or `rewrites` to `/api/frontmcp` (the build does not produce an `api/` directory).
+
+> Note: header configuration is also possible inside your FrontMCP server (works locally and in production). Use `vercel.json` headers when you need them applied at the edge before reaching the function.
 
 ## Code
 
 ```json
-// vercel.json
+// vercel.json — extends the auto-generated minimum with regions + headers.
+// The adapter regenerates buildCommand/installCommand from your lockfile,
+// so keep them aligned (or let the build rewrite them).
 {
-  "$schema": "https://openapi.vercel.sh/vercel.json",
-  "framework": null,
-  "buildCommand": "frontmcp build --target vercel",
-  "outputDirectory": "dist",
-  "rewrites": [
-    {
-      "source": "/(.*)",
-      "destination": "/api/frontmcp"
-    }
-  ],
-  "functions": {
-    "api/frontmcp.js": {
-      "memory": 512,
-      "maxDuration": 30
-    }
-  },
+  "version": 2,
+  "buildCommand": "yarn build",
+  "installCommand": "yarn install",
   "regions": ["iad1"],
   "headers": [
     {
-      "source": "/health",
-      "headers": [
-        {
-          "key": "Cache-Control",
-          "value": "no-store"
-        }
-      ]
+      "source": "/healthz",
+      "headers": [{ "key": "Cache-Control", "value": "no-store" }]
     },
     {
       "source": "/mcp",
       "headers": [
-        {
-          "key": "Cache-Control",
-          "value": "no-store"
-        },
-        {
-          "key": "X-Content-Type-Options",
-          "value": "nosniff"
-        }
+        { "key": "Cache-Control", "value": "no-store" },
+        { "key": "X-Content-Type-Options", "value": "nosniff" }
       ]
     },
     {
       "source": "/(.*)",
       "headers": [
-        {
-          "key": "X-Frame-Options",
-          "value": "DENY"
-        },
-        {
-          "key": "X-Content-Type-Options",
-          "value": "nosniff"
-        },
-        {
-          "key": "Referrer-Policy",
-          "value": "strict-origin-when-cross-origin"
-        }
+        { "key": "X-Frame-Options", "value": "DENY" },
+        { "key": "X-Content-Type-Options", "value": "nosniff" },
+        { "key": "Referrer-Policy", "value": "strict-origin-when-cross-origin" }
       ]
     }
   ]
@@ -82,11 +58,12 @@ A complete `vercel.json` with per-route security headers for health, MCP, and al
 
 ## What This Demonstrates
 
-- Per-route header configuration: `/health` and `/mcp` get `Cache-Control: no-store` to prevent caching
-- Global security headers (`X-Frame-Options`, `X-Content-Type-Options`, `Referrer-Policy`) applied to all routes
-- Setting `framework: null` to tell Vercel this is not a framework project
+- Adding `regions` to constrain function placement (e.g., `iad1` for US East)
+- Per-route `Cache-Control: no-store` on `/healthz` and `/mcp` to prevent caching
+- Global security headers applied to all routes via the catch-all `source: "/(.*)"`
 
 ## Related
 
-- See `deploy-to-vercel-config` for the full reference configuration
+- See `deploy-to-vercel-config` for the full reference and what NOT to do
 - See `deploy-to-vercel` for the complete deployment guide
+- Security hardening (CSP, HSTS, rate limits) belongs in `frontmcp-production-readiness`

package/catalog/frontmcp-deployment/examples/mcp-client-integration/http-remote.md

@@ -53,6 +53,8 @@ my-server serve -p 3005
 
 ### Background daemon on port
 
+`daemon` subcommands are generated INTO your CLI binary by `frontmcp build --target cli` — they are not subcommands of the global `frontmcp` CLI. The block below assumes `my-server` is the binary you built and installed.
+
 ```bash
 # Start as a background daemon on port 4000
 my-server daemon start -p 4000
@@ -68,6 +70,13 @@ my-server daemon logs
 my-server daemon stop
 ```
 
+If you haven't built a CLI binary, use the framework-level alternative:
+
+```bash
+# Start an entry file as a backgrounded socket daemon (Unix socket by default)
+frontmcp socket ./src/main.ts -b
+```
+
 ```json Claude Code (.mcp.json)
 {
   "mcpServers": {