@aiwerk/mcp-bridge 1.7.2 → 1.8.0

package/README.md

@@ -59,6 +59,26 @@ Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
 }
 ```
 
+## Recipe Spec v2
+
+Bundled servers now ship with `recipe.json` using **Universal Recipe Spec v2.0**.
+During install, MCP Bridge prefers `recipe.json` when present and falls back to legacy `config.json` (v1) for backwards compatibility.
+
+- Spec: [`docs/universal-recipe-spec.md`](docs/universal-recipe-spec.md)
+- Runtime compatibility: v1 and v2 are both supported
+- Existing v1-only servers continue to work unchanged
+
+For third-party recipe authors:
+
+1. Author `recipe.json` per the spec above.
+2. Validate your recipe before publishing:
+
+```bash
+npx @aiwerk/mcp-bridge validate-recipe ./recipe.json
+```
+
+`config.json` (v1) remains supported, but `recipe.json` (v2) is the recommended format going forward.
+
 ## Use with Cursor / Windsurf
 
 Add to your MCP config:

package/dist/bin/validate-recipe.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point for the Universal MCP Recipe Validator.
+ * Usage: npx tsx bin/validate-recipe.ts <path-to-recipe.json>
+ */
+export {};

package/dist/bin/validate-recipe.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point for the Universal MCP Recipe Validator.
+ * Usage: npx tsx bin/validate-recipe.ts <path-to-recipe.json>
+ */
+import { validateRecipeFile, formatValidationResult } from "../src/validate-recipe.js";
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+        console.log("Usage: validate-recipe <path-to-recipe.json>");
+        console.log("");
+        console.log("Validates a Universal MCP Recipe against spec v2.0.");
+        console.log("Exits 0 if valid, 1 if invalid.");
+        process.exit(0);
+    }
+    const filePath = args[0];
+    let result;
+    try {
+        result = await validateRecipeFile(filePath);
+    }
+    catch (e) {
+        console.error(`❌ Could not read file: ${filePath}`);
+        console.error(`   ${e.message}`);
+        process.exit(1);
+    }
+    const output = formatValidationResult(filePath, result);
+    console.log(output);
+    process.exit(result.valid ? 0 : 1);
+}
+main().catch((e) => {
+    console.error("Unexpected error:", e);
+    process.exit(1);
+});

package/dist/src/validate-recipe.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Universal MCP Recipe Validator (spec v2.0, §7)
+ */
+export interface RecipeTransport {
+    type: string;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    headers?: Record<string, string>;
+    framing?: string;
+}
+export interface RecipeInstall {
+    method: string;
+    package?: string;
+    image?: string;
+    repository?: string;
+    buildCommand?: string;
+    binary?: string;
+    version?: string;
+    preInstall?: string[];
+    postInstall?: string[];
+    platforms?: Record<string, unknown>;
+}
+export interface RecipeAuth {
+    required?: boolean;
+    type?: string;
+    envVars?: string[];
+    credentialsUrl?: string;
+    instructions?: string;
+    scopes?: string[];
+    bootstrap?: string;
+}
+export interface RecipeMetadata {
+    homepage?: string;
+    license?: string;
+    author?: string;
+    tags?: string[];
+    category?: string;
+    languages?: string[];
+    pricing?: string;
+    maturity?: string;
+    firstPublished?: string;
+    lastVerified?: string;
+    toolCount?: number;
+    toolExamples?: Array<{
+        name: string;
+        description: string;
+    }>;
+}
+export interface UniversalRecipe {
+    schemaVersion?: unknown;
+    id?: unknown;
+    name?: unknown;
+    description?: unknown;
+    repository?: unknown;
+    transports?: unknown;
+    auth?: RecipeAuth;
+    install?: RecipeInstall;
+    metadata?: RecipeMetadata;
+    capabilities?: unknown;
+    [key: string]: unknown;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+    /** Convenience fields for success output */
+    id?: string;
+    toolCount?: number;
+    primaryTransport?: string;
+    installMethod?: string;
+}
+export declare function validateRecipe(recipe: UniversalRecipe): ValidationResult;
+export declare function validateRecipeFile(filePath: string): Promise<ValidationResult>;
+export declare function formatValidationResult(filePath: string, result: ValidationResult): string;

package/dist/src/validate-recipe.js

@@ -0,0 +1,241 @@
+/**
+ * Universal MCP Recipe Validator (spec v2.0, §7)
+ */
+// ─── Known categories (§3.1) ─────────────────────────────────────────────────
+const KNOWN_CATEGORIES = new Set([
+    "productivity",
+    "development",
+    "communication",
+    "data",
+    "finance",
+    "infrastructure",
+    "analytics",
+    "content",
+    "search",
+    "automation",
+    "security",
+    "ai",
+    "other",
+]);
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+/** Extract all ${VAR} references from a string */
+function extractVarRefs(s) {
+    const matches = s.matchAll(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g);
+    return [...matches].map((m) => m[1]);
+}
+/** Recursively collect all ${VAR} references from an object's string values */
+function collectVarRefs(obj, refs = new Set()) {
+    if (typeof obj === "string") {
+        for (const v of extractVarRefs(obj))
+            refs.add(v);
+    }
+    else if (Array.isArray(obj)) {
+        for (const item of obj)
+            collectVarRefs(item, refs);
+    }
+    else if (obj && typeof obj === "object") {
+        for (const val of Object.values(obj)) {
+            collectVarRefs(val, refs);
+        }
+    }
+    return refs;
+}
+// ─── Core validator ───────────────────────────────────────────────────────────
+export function validateRecipe(recipe) {
+    const errors = [];
+    const warnings = [];
+    // ── §7.1 Rule 1: schemaVersion === 2 ──────────────────────────────────────
+    if (recipe.schemaVersion !== 2) {
+        errors.push(`schemaVersion must be 2, got: ${JSON.stringify(recipe.schemaVersion)}`);
+    }
+    // ── §7.1 Rule 2: id format ─────────────────────────────────────────────────
+    const id = recipe.id;
+    if (typeof id !== "string" || id.length === 0) {
+        errors.push("id is required and must be a non-empty string");
+    }
+    else {
+        if (id.length < 2 || id.length > 64) {
+            errors.push(`id must be 2-64 characters, got ${id.length}`);
+        }
+        if (!/^[a-z0-9][a-z0-9-]*[a-z0-9]$/.test(id)) {
+            errors.push(`id must match ^[a-z0-9][a-z0-9-]*[a-z0-9]$ (lowercase alphanumeric with internal hyphens only), got: "${id}"`);
+        }
+    }
+    // ── §7.1 Rule 3: name ──────────────────────────────────────────────────────
+    const name = recipe.name;
+    if (typeof name !== "string" || name.trim().length === 0) {
+        errors.push("name is required and must be a non-empty string");
+    }
+    else if (name.length > 128) {
+        errors.push(`name must be max 128 chars, got ${name.length}`);
+    }
+    // ── §7.1 Rule 4: description ───────────────────────────────────────────────
+    const desc = recipe.description;
+    if (typeof desc !== "string" || desc.trim().length === 0) {
+        errors.push("description is required and must be a non-empty string");
+    }
+    else if (desc.length > 512) {
+        errors.push(`description must be max 512 chars, got ${desc.length}`);
+    }
+    // ── §7.1 Rule 5: repository or metadata.homepage ──────────────────────────
+    const hasRepository = typeof recipe.repository === "string" && recipe.repository.trim().length > 0;
+    const hasHomepage = typeof recipe.metadata?.homepage === "string" &&
+        recipe.metadata.homepage.trim().length > 0;
+    if (!hasRepository && !hasHomepage) {
+        errors.push("At least one of repository or metadata.homepage must be present");
+    }
+    // ── §7.1 Rules 6 & 7: transports ──────────────────────────────────────────
+    const transports = recipe.transports;
+    if (!Array.isArray(transports) || transports.length === 0) {
+        errors.push("transports must be a non-empty array");
+    }
+    else {
+        let hasStdio = false;
+        let allRemote = true;
+        for (let i = 0; i < transports.length; i++) {
+            const t = transports[i];
+            if (!t || typeof t !== "object") {
+                errors.push(`transports[${i}]: must be an object`);
+                continue;
+            }
+            if (typeof t.type !== "string" || t.type.trim().length === 0) {
+                errors.push(`transports[${i}]: type is required`);
+                continue;
+            }
+            const type = t.type;
+            if (type === "stdio") {
+                hasStdio = true;
+                allRemote = false;
+                if (typeof t.command !== "string" || t.command.trim().length === 0) {
+                    errors.push(`transports[${i}] (stdio): command is required`);
+                }
+            }
+            else if (type === "sse" || type === "streamable-http") {
+                if (typeof t.url !== "string" || t.url.trim().length === 0) {
+                    errors.push(`transports[${i}] (${type}): url is required`);
+                }
+            }
+            else {
+                errors.push(`transports[${i}]: unknown type "${type}", must be "stdio", "sse", or "streamable-http"`);
+            }
+        }
+        // ── §7.1 Rule 9 & 10: install required for stdio ───────────────────────
+        if (hasStdio) {
+            if (!recipe.install) {
+                errors.push('install is required when any transport has type "stdio"');
+            }
+            else if (typeof recipe.install.method !== "string" ||
+                recipe.install.method.trim().length === 0) {
+                errors.push("install.method is required and must be a non-empty string");
+            }
+        }
+        // allRemote → install is optional, nothing to check
+        // ── §7.1 Rule 8: auth.envVars covers all ${VAR} references ────────────
+        // Collect all ${VAR} refs from transports (env, headers, args, url)
+        const transportVarRefs = new Set();
+        for (const t of transports) {
+            if (t && typeof t === "object") {
+                collectVarRefs(t.env, transportVarRefs);
+                collectVarRefs(t.headers, transportVarRefs);
+                collectVarRefs(t.args, transportVarRefs);
+                if (typeof t.url === "string")
+                    collectVarRefs(t.url, transportVarRefs);
+            }
+        }
+        if (transportVarRefs.size > 0) {
+            const declaredEnvVars = new Set(recipe.auth?.envVars ?? []);
+            const missing = [...transportVarRefs].filter((v) => !declaredEnvVars.has(v));
+            if (missing.length > 0) {
+                errors.push(`auth.envVars is missing these \${VAR} references found in transports: ${missing.join(", ")}`);
+            }
+        }
+    }
+    // ── §7.2 Warnings ──────────────────────────────────────────────────────────
+    // Warning: metadata.lastVerified older than 90 days
+    if (typeof recipe.metadata?.lastVerified === "string") {
+        const lastVerified = new Date(recipe.metadata.lastVerified);
+        if (!isNaN(lastVerified.getTime())) {
+            const ageMs = Date.now() - lastVerified.getTime();
+            const ninetyDaysMs = 90 * 24 * 60 * 60 * 1000;
+            if (ageMs > ninetyDaysMs) {
+                warnings.push(`metadata.lastVerified is >90 days old (${recipe.metadata.lastVerified})`);
+            }
+        }
+    }
+    // Warning: unknown category
+    if (typeof recipe.metadata?.category === "string" &&
+        !KNOWN_CATEGORIES.has(recipe.metadata.category)) {
+        warnings.push(`metadata.category "${recipe.metadata.category}" is not in the known category list`);
+    }
+    // Warning: non-empty preInstall / postInstall
+    if (Array.isArray(recipe.install?.preInstall) &&
+        recipe.install.preInstall.length > 0) {
+        warnings.push("Recipe contains preInstall commands - review before executing");
+    }
+    if (Array.isArray(recipe.install?.postInstall) &&
+        recipe.install.postInstall.length > 0) {
+        warnings.push("Recipe contains postInstall commands - review before executing");
+    }
+    // Warning: missing metadata.homepage when repository also absent
+    if (!hasRepository && !hasHomepage) {
+        // Already an error, skip duplicate warning
+    }
+    else if (!hasHomepage) {
+        warnings.push("metadata.homepage is missing - consider adding it for better discoverability");
+    }
+    // Warning: maturity deprecated
+    if (recipe.metadata?.maturity === "deprecated") {
+        warnings.push("metadata.maturity is set to 'deprecated'");
+    }
+    // ── Build result ───────────────────────────────────────────────────────────
+    const valid = errors.length === 0;
+    const result = { valid, errors, warnings };
+    if (valid && typeof id === "string") {
+        result.id = id;
+        result.toolCount = recipe.metadata?.toolCount ?? 0;
+        // Primary transport (first one)
+        const firstTransport = Array.isArray(recipe.transports) && recipe.transports.length > 0
+            ? recipe.transports[0].type
+            : undefined;
+        result.primaryTransport = firstTransport;
+        result.installMethod = recipe.install?.method;
+    }
+    return result;
+}
+// ─── File loader ─────────────────────────────────────────────────────────────
+export async function validateRecipeFile(filePath) {
+    const { readFile } = await import("node:fs/promises");
+    const raw = await readFile(filePath, "utf-8");
+    let recipe;
+    try {
+        recipe = JSON.parse(raw);
+    }
+    catch (e) {
+        return {
+            valid: false,
+            errors: [`Failed to parse JSON: ${e.message}`],
+            warnings: [],
+        };
+    }
+    return validateRecipe(recipe);
+}
+// ─── Output formatting ────────────────────────────────────────────────────────
+export function formatValidationResult(filePath, result) {
+    const lines = [];
+    for (const w of result.warnings) {
+        lines.push(`⚠️  Warning: ${w}`);
+    }
+    if (result.valid) {
+        const toolCount = result.toolCount ?? 0;
+        const transport = result.primaryTransport ?? "unknown";
+        const method = result.installMethod ?? "remote";
+        lines.push(`✅ Valid recipe: ${result.id} (${toolCount} tools, ${transport}, ${method})`);
+    }
+    else {
+        lines.push(`❌ Invalid recipe: ${filePath}`);
+        for (const err of result.errors) {
+            lines.push(`   - ${err}`);
+        }
+    }
+    return lines.join("\n");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwerk/mcp-bridge",
-  "version": "1.7.2",
+  "version": "1.8.0",
   "description": "Standalone MCP server that multiplexes multiple MCP servers into one interface",
   "type": "module",
   "main": "./dist/src/index.js",
@@ -44,7 +44,8 @@
     "build": "tsc",
     "test": "node --import tsx --test tests/*.test.ts",
     "typecheck": "tsc --noEmit",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "validate-recipe": "npx tsx bin/validate-recipe.ts"
   },
   "dependencies": {
     "@sinclair/typebox": "^0.34.0"

package/scripts/install-server.sh

@@ -37,9 +37,19 @@ if [[ ! -d "$SERVER_DIR" ]]; then
 fi
 
 SERVER_TITLE="$(tr '-' ' ' <<<"$SERVER_NAME" | awk '{for(i=1;i<=NF;i++){$i=toupper(substr($i,1,1))substr($i,2)};print}')"
-SERVER_CONFIG_FILE="$SERVER_DIR/config.json"
 ENV_VARS_FILE="$SERVER_DIR/env_vars"
 
+# Prefer recipe.json (v2) over config.json (v1) when both exist
+RECIPE_FILE="$SERVER_DIR/recipe.json"
+SERVER_CONFIG_FILE="$SERVER_DIR/config.json"
+RECIPE_FORMAT="v1"
+if [[ -f "$RECIPE_FILE" ]]; then
+    RECIPE_FORMAT="v2"
+elif [[ ! -f "$SERVER_CONFIG_FILE" ]]; then
+    echo "Error: No recipe.json or config.json found in $SERVER_DIR"
+    exit 1
+fi
+
 require_cmd() {
     if ! command -v "$1" >/dev/null 2>&1; then
         echo "❌ Missing required command: $1"
@@ -48,6 +58,18 @@ require_cmd() {
 }
 
 get_token_url() {
+    # For v2 recipes, prefer credentialsUrl from auth block
+    if [[ "$RECIPE_FORMAT" == "v2" ]]; then
+        local url
+        url=$(python3 -c "
+import json, sys
+with open(sys.argv[1]) as f:
+    r = json.load(f)
+print(r.get('auth', {}).get('credentialsUrl', ''))
+" "$RECIPE_FILE" 2>/dev/null)
+        [[ -n "$url" ]] && echo "$url" && return
+    fi
+    # v1 fallback: hardcoded URLs
     case "$SERVER_NAME" in
         apify)       echo "https://console.apify.com/settings/integrations" ;;
         github)      echo "https://github.com/settings/tokens" ;;
@@ -171,11 +193,22 @@ print(f'ℹ️  Server recipe kept in servers/{server_name}/ (reinstall anytime)
 " "$SERVER_NAME" "$MCP_BRIDGE_JSON" 2>/dev/null
 
     # Remove env var from .env if exists
-    if [[ -f "$ENV_VARS_FILE" ]] && [[ -s "$ENV_VARS_FILE" ]] && [[ -f "$ENV_FILE" ]]; then
-        ENV_VAR_NAME="$(head -n 1 "$ENV_VARS_FILE" | tr -d '[:space:]')"
-        if grep -q "^${ENV_VAR_NAME}=" "$ENV_FILE" 2>/dev/null; then
-            sed -i "/^${ENV_VAR_NAME}=/d" "$ENV_FILE"
-            echo "🔑 Removed ${ENV_VAR_NAME} from ${ENV_FILE}"
+    REMOVE_ENV_VAR=""
+    if [[ "$RECIPE_FORMAT" == "v2" ]]; then
+        REMOVE_ENV_VAR=$(python3 -c "
+import json, sys
+with open(sys.argv[1]) as f:
+    r = json.load(f)
+env_vars = r.get('auth', {}).get('envVars', [])
+print(env_vars[0] if env_vars else '')
+" "$RECIPE_FILE" 2>/dev/null)
+    elif [[ -f "$ENV_VARS_FILE" ]] && [[ -s "$ENV_VARS_FILE" ]]; then
+        REMOVE_ENV_VAR="$(head -n 1 "$ENV_VARS_FILE" | tr -d '[:space:]')"
+    fi
+    if [[ -n "$REMOVE_ENV_VAR" ]] && [[ -f "$ENV_FILE" ]]; then
+        if grep -q "^${REMOVE_ENV_VAR}=" "$ENV_FILE" 2>/dev/null; then
+            sed -i "/^${REMOVE_ENV_VAR}=/d" "$ENV_FILE"
+            echo "🔑 Removed ${REMOVE_ENV_VAR} from ${ENV_FILE}"
         fi
     fi
 
@@ -214,8 +247,20 @@ echo "========================================"
 
 if [[ "$DRY_RUN" == "true" ]]; then
     echo "[DRY RUN] Server: $SERVER_NAME"
-    [[ -f "$ENV_VARS_FILE" ]] && echo "[DRY RUN] Env var: $(cat "$ENV_VARS_FILE")"
-    echo "[DRY RUN] Config:"; cat "$SERVER_CONFIG_FILE"
+    echo "[DRY RUN] Recipe format: $RECIPE_FORMAT"
+    if [[ "$RECIPE_FORMAT" == "v2" ]]; then
+        ENV_VAR_LIST=$(python3 -c "
+import json, sys
+with open(sys.argv[1]) as f:
+    r = json.load(f)
+print(', '.join(r.get('auth', {}).get('envVars', [])))
+" "$RECIPE_FILE" 2>/dev/null)
+        [[ -n "$ENV_VAR_LIST" ]] && echo "[DRY RUN] Env vars (from auth.envVars): $ENV_VAR_LIST"
+        echo "[DRY RUN] Recipe (v2):"; cat "$RECIPE_FILE"
+    else
+        [[ -f "$ENV_VARS_FILE" ]] && echo "[DRY RUN] Env var: $(cat "$ENV_VARS_FILE")"
+        echo "[DRY RUN] Config (v1):"; cat "$SERVER_CONFIG_FILE"
+    fi
     exit 0
 fi
 
@@ -226,9 +271,21 @@ check_prerequisites
 install_dependencies
 
 # 3. Get API token
-if [[ -f "$ENV_VARS_FILE" ]] && [[ -s "$ENV_VARS_FILE" ]]; then
+# Determine env var name: v2 uses auth.envVars[], v1 uses env_vars file
+ENV_VAR_NAME=""
+if [[ "$RECIPE_FORMAT" == "v2" ]]; then
+    ENV_VAR_NAME=$(python3 -c "
+import json, sys
+with open(sys.argv[1]) as f:
+    r = json.load(f)
+env_vars = r.get('auth', {}).get('envVars', [])
+print(env_vars[0] if env_vars else '')
+" "$RECIPE_FILE" 2>/dev/null)
+elif [[ -f "$ENV_VARS_FILE" ]] && [[ -s "$ENV_VARS_FILE" ]]; then
     ENV_VAR_NAME="$(head -n 1 "$ENV_VARS_FILE" | tr -d '[:space:]')"
+fi
 
+if [[ -n "$ENV_VAR_NAME" ]]; then
     TOKEN_URL="$(get_token_url)"
     [[ -n "$TOKEN_URL" ]] && echo "Get your API token here: ${TOKEN_URL}"
 
@@ -268,18 +325,43 @@ cp "$MCP_BRIDGE_JSON" "$BACKUP_FILE"
 echo "Backup: ${BACKUP_FILE}"
 
 PATH_OVERRIDE="$(resolve_path_override)"
+ACTIVE_RECIPE_FILE="$RECIPE_FILE"
+ACTIVE_RECIPE_FORMAT="$RECIPE_FORMAT"
 
-python3 - "$MCP_BRIDGE_JSON" "$SERVER_CONFIG_FILE" "$SERVER_NAME" "$PATH_OVERRIDE" <<'PY'
+python3 - "$MCP_BRIDGE_JSON" "$SERVER_CONFIG_FILE" "$SERVER_NAME" "$PATH_OVERRIDE" "$ACTIVE_RECIPE_FILE" "$ACTIVE_RECIPE_FORMAT" <<'PY'
 import json, sys
 
-config_path, server_cfg_path, server_name, path_override = sys.argv[1:5]
+config_path, server_cfg_path, server_name, path_override, recipe_file, recipe_format = sys.argv[1:7]
 
 with open(config_path, "r", encoding="utf-8") as f:
     raw = f.read().strip()
     cfg = json.loads(raw) if raw else {}
 
-with open(server_cfg_path, "r", encoding="utf-8") as f:
-    server_cfg = json.load(f)
+if recipe_format == "v2":
+    # Parse v2 recipe and build v1-compatible server config for runtime
+    with open(recipe_file, "r", encoding="utf-8") as f:
+        recipe = json.load(f)
+    transport = recipe["transports"][0]
+    server_cfg = {
+        "schemaVersion": 1,
+        "name": server_name,
+        "transport": transport.get("type", "stdio"),
+        "command": transport.get("command", ""),
+        "args": transport.get("args", []),
+        "env": transport.get("env", {}),
+    }
+    # Carry over optional v1-compatible fields from recipe if present
+    auth = recipe.get("auth", {})
+    if auth.get("required"):
+        server_cfg["authRequired"] = True
+    if auth.get("credentialsUrl"):
+        server_cfg["credentialsUrl"] = auth["credentialsUrl"]
+    meta = recipe.get("metadata", {})
+    if meta.get("homepage"):
+        server_cfg["homepage"] = meta["homepage"]
+else:
+    with open(server_cfg_path, "r", encoding="utf-8") as f:
+        server_cfg = json.load(f)
 
 if path_override:
     args = server_cfg.get("args")
@@ -299,7 +381,7 @@ with open(config_path, "w", encoding="utf-8") as f:
     json.dump(cfg, f, indent=2)
     f.write("\n")
 
-print(f"✅ Configuration merged for: {server_name}")
+print(f"✅ Configuration merged for: {server_name} (recipe {recipe_format})")
 PY
 
 # 5. Gateway restart

package/servers/apify/recipe.json

@@ -0,0 +1,41 @@
+{
+  "schemaVersion": 2,
+  "id": "apify",
+  "name": "Apify",
+  "description": "Web scraping and automation platform with 3000+ ready-made actors for data extraction, browser automation, and crawling",
+  "repository": "https://github.com/apify/apify-mcp-server",
+
+  "transports": [
+    {
+      "type": "streamable-http",
+      "url": "https://mcp.apify.com/mcp",
+      "headers": {
+        "Authorization": "Bearer ${APIFY_TOKEN}"
+      }
+    }
+  ],
+
+  "auth": {
+    "required": true,
+    "type": "bearer",
+    "envVars": ["APIFY_TOKEN"],
+    "credentialsUrl": "https://console.apify.com/settings/integrations",
+    "instructions": "Copy your API token from Apify Console > Settings > Integrations."
+  },
+
+  "metadata": {
+    "homepage": "https://apify.com/",
+    "author": "Apify",
+    "tags": ["scraping", "automation", "web", "crawling", "actors"],
+    "category": "automation",
+    "pricing": "byok",
+    "maturity": "stable"
+  },
+
+  "capabilities": {
+    "tools": true,
+    "resources": false,
+    "prompts": false,
+    "sampling": false
+  }
+}

package/servers/atlassian/recipe.json

@@ -0,0 +1,60 @@
+{
+  "schemaVersion": 2,
+  "id": "atlassian",
+  "name": "Atlassian (Confluence + Jira)",
+  "description": "Confluence wiki and Jira project management — search, create, and update pages and issues",
+  "repository": "https://github.com/sooperset/mcp-atlassian",
+
+  "transports": [
+    {
+      "type": "stdio",
+      "command": "uvx",
+      "args": ["mcp-atlassian"],
+      "env": {
+        "CONFLUENCE_URL": "${CONFLUENCE_URL}",
+        "CONFLUENCE_USERNAME": "${CONFLUENCE_USERNAME}",
+        "CONFLUENCE_API_TOKEN": "${CONFLUENCE_API_TOKEN}",
+        "JIRA_URL": "${JIRA_URL}",
+        "JIRA_USERNAME": "${JIRA_USERNAME}",
+        "JIRA_API_TOKEN": "${JIRA_API_TOKEN}"
+      }
+    }
+  ],
+
+  "auth": {
+    "required": true,
+    "type": "api-key",
+    "envVars": [
+      "CONFLUENCE_URL",
+      "CONFLUENCE_USERNAME",
+      "CONFLUENCE_API_TOKEN",
+      "JIRA_URL",
+      "JIRA_USERNAME",
+      "JIRA_API_TOKEN"
+    ],
+    "credentialsUrl": "https://id.atlassian.com/manage-profile/security/api-tokens",
+    "instructions": "Create an API token at Atlassian account settings. Set CONFLUENCE_URL and JIRA_URL to your instance URLs (e.g., https://yourcompany.atlassian.net/wiki and https://yourcompany.atlassian.net)."
+  },
+
+  "install": {
+    "method": "uvx",
+    "package": "mcp-atlassian",
+    "version": "latest"
+  },
+
+  "metadata": {
+    "homepage": "https://github.com/sooperset/mcp-atlassian",
+    "author": "sooperset",
+    "tags": ["wiki", "project-management", "confluence", "jira", "atlassian"],
+    "category": "productivity",
+    "pricing": "byok",
+    "maturity": "stable"
+  },
+
+  "capabilities": {
+    "tools": true,
+    "resources": false,
+    "prompts": false,
+    "sampling": false
+  }
+}