recommended-by-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 simple bytes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,114 @@
+# recommended-by-mcp
+
+Stdio MCP server for managing your recommended.by lists from agents like OpenClaw, Codex, Claude Desktop, Claude Code, Cursor, and Windsurf.
+
+The package talks to the recommended.by REST API and exposes MCP tools over stdio. This is useful for clients that do not support remote HTTP MCP headers consistently: the agent launches this package locally, and the package handles recommended.by authentication.
+
+## Quick Start
+
+Create an API key in `Dashboard -> Profile & URL -> API Keys`, then authenticate the package once:
+
+```bash
+npx recommended-by-mcp@latest login rb_live_your_key_here
+```
+
+Then configure your MCP client to run:
+
+```bash
+npx -y recommended-by-mcp@latest
+```
+
+You can also avoid local storage and pass the key through an environment variable:
+
+```bash
+RECOMMENDED_BY_API_KEY=rb_live_your_key_here npx -y recommended-by-mcp@latest
+```
+
+## Authentication
+
+The server resolves auth in this order:
+
+1. `--api-key rb_live_...`
+2. `RECOMMENDED_BY_API_KEY`
+3. saved config from `recommended-by-mcp login`
+
+The saved config lives at:
+
+- macOS: `~/Library/Application Support/recommended-by-mcp/config.json`
+- Linux: `~/.config/recommended-by-mcp/config.json`
+- Windows: `%APPDATA%\recommended-by-mcp\config.json`
+
+Remove the saved key with:
+
+```bash
+npx recommended-by-mcp@latest logout
+```
+
+Check which account the key can access:
+
+```bash
+npx recommended-by-mcp@latest whoami
+```
+
+## MCP Tools
+
+- `recommended_list_lists`
+- `recommended_create_list`
+- `recommended_get_list`
+- `recommended_update_list`
+- `recommended_delete_list`
+- `recommended_list_items`
+- `recommended_add_item`
+- `recommended_update_item`
+- `recommended_delete_item`
+
+## Client Examples
+
+### Codex
+
+Add this to `~/.codex/config.toml`:
+
+```toml
+[mcp_servers.recommended_by]
+command = "npx"
+args = ["-y", "recommended-by-mcp@latest"]
+env = { RECOMMENDED_BY_API_KEY = "rb_live_your_key_here" }
+```
+
+### OpenClaw
+
+```bash
+openclaw mcp add recommended-by \
+  --command npx \
+  --arg -y \
+  --arg recommended-by-mcp@latest \
+  --env RECOMMENDED_BY_API_KEY=rb_live_your_key_here
+
+openclaw mcp doctor recommended-by --probe
+```
+
+### Claude Desktop
+
+Add this to `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "recommended-by": {
+      "command": "npx",
+      "args": ["-y", "recommended-by-mcp@latest"],
+      "env": {
+        "RECOMMENDED_BY_API_KEY": "rb_live_your_key_here"
+      }
+    }
+  }
+}
+```
+
+## Development
+
+```bash
+pnpm install
+pnpm --filter recommended-by-mcp build
+pnpm --filter recommended-by-mcp test
+```

package/dist/auth.d.ts

@@ -0,0 +1,16 @@
+export type StoredConfig = {
+    apiKey?: string;
+    apiBaseUrl?: string;
+};
+export declare function getConfigPath(): string;
+export declare function loadStoredConfig(): Promise<StoredConfig>;
+export declare function saveApiKey(apiKey: string, apiBaseUrl?: string): Promise<string>;
+export declare function clearStoredConfig(): Promise<string>;
+export declare function assertApiKey(apiKey: string): void;
+export declare function resolveAuth(options: {
+    apiKey?: string;
+    apiBaseUrl?: string;
+}): Promise<{
+    apiKey: string;
+    apiBaseUrl: string;
+}>;

package/dist/auth.js

@@ -0,0 +1,63 @@
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { homedir, platform } from "node:os";
+const configFileName = "config.json";
+export function getConfigPath() {
+    const appDir = "recommended-by-mcp";
+    if (process.env.RECOMMENDED_BY_MCP_CONFIG) {
+        return process.env.RECOMMENDED_BY_MCP_CONFIG;
+    }
+    if (platform() === "darwin") {
+        return join(homedir(), "Library", "Application Support", appDir, configFileName);
+    }
+    if (platform() === "win32") {
+        return join(process.env.APPDATA ?? join(homedir(), "AppData", "Roaming"), appDir, configFileName);
+    }
+    return join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), appDir, configFileName);
+}
+export async function loadStoredConfig() {
+    try {
+        const raw = await readFile(getConfigPath(), "utf8");
+        const parsed = JSON.parse(raw);
+        return {
+            apiKey: typeof parsed.apiKey === "string" ? parsed.apiKey : undefined,
+            apiBaseUrl: typeof parsed.apiBaseUrl === "string" ? parsed.apiBaseUrl : undefined,
+        };
+    }
+    catch {
+        return {};
+    }
+}
+export async function saveApiKey(apiKey, apiBaseUrl) {
+    assertApiKey(apiKey);
+    const configPath = getConfigPath();
+    await mkdir(dirname(configPath), { recursive: true });
+    await writeFile(configPath, `${JSON.stringify({ apiKey, apiBaseUrl }, null, 2)}\n`, { mode: 0o600 });
+    return configPath;
+}
+export async function clearStoredConfig() {
+    const configPath = getConfigPath();
+    await rm(configPath, { force: true });
+    return configPath;
+}
+export function assertApiKey(apiKey) {
+    if (!apiKey.startsWith("rb_live_") && !apiKey.startsWith("rb_test_")) {
+        throw new Error("recommended.by API keys must start with rb_live_ or rb_test_");
+    }
+}
+export async function resolveAuth(options) {
+    const stored = await loadStoredConfig();
+    const apiKey = options.apiKey ?? process.env.RECOMMENDED_BY_API_KEY ?? stored.apiKey;
+    const apiBaseUrl = options.apiBaseUrl ??
+        process.env.RECOMMENDED_BY_API_BASE_URL ??
+        stored.apiBaseUrl ??
+        "https://api.recommended.by/api/v1";
+    if (!apiKey) {
+        throw new Error("Missing recommended.by API key. Run `recommended-by-mcp login rb_live_...` or set RECOMMENDED_BY_API_KEY.");
+    }
+    assertApiKey(apiKey);
+    return {
+        apiKey,
+        apiBaseUrl: apiBaseUrl.replace(/\/+$/, ""),
+    };
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+import { clearStoredConfig, resolveAuth, saveApiKey } from "./auth.js";
+import { RecommendedByClient } from "./client.js";
+import { runMcpServer } from "./server.js";
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.help || args.command === "help") {
+        printHelp();
+        return;
+    }
+    if (args.command === "login") {
+        const apiKey = args.apiKey ?? args.rest[0];
+        if (!apiKey) {
+            throw new Error("Usage: recommended-by-mcp login rb_live_...");
+        }
+        const configPath = await saveApiKey(apiKey, args.apiBaseUrl);
+        process.stdout.write(`Saved recommended.by API key to ${configPath}\n`);
+        return;
+    }
+    if (args.command === "logout") {
+        const configPath = await clearStoredConfig();
+        process.stdout.write(`Removed recommended.by MCP config at ${configPath}\n`);
+        return;
+    }
+    if (args.command === "whoami") {
+        const auth = await resolveAuth(args);
+        const client = new RecommendedByClient(auth);
+        const lists = await client.request("GET", "/lists");
+        process.stdout.write(`${JSON.stringify({ ok: true, apiBaseUrl: auth.apiBaseUrl, lists }, null, 2)}\n`);
+        return;
+    }
+    if (args.command === "config-path") {
+        const { getConfigPath } = await import("./auth.js");
+        process.stdout.write(`${getConfigPath()}\n`);
+        return;
+    }
+    if (args.command && args.command !== "serve") {
+        throw new Error(`Unknown command: ${args.command}`);
+    }
+    const auth = await resolveAuth(args);
+    await runMcpServer(auth);
+}
+function parseArgs(argv) {
+    const result = { rest: [] };
+    const commands = new Set(["serve", "login", "logout", "whoami", "config-path", "help"]);
+    for (let index = 0; index < argv.length; index += 1) {
+        const value = argv[index];
+        if (value === "--help" || value === "-h") {
+            result.help = true;
+        }
+        else if (value === "--api-key") {
+            result.apiKey = requireNext(argv, ++index, "--api-key");
+        }
+        else if (value === "--api-base-url") {
+            result.apiBaseUrl = requireNext(argv, ++index, "--api-base-url");
+        }
+        else if (!result.command && commands.has(value)) {
+            result.command = value;
+        }
+        else {
+            result.rest.push(value);
+        }
+    }
+    return result;
+}
+function requireNext(argv, index, flag) {
+    const value = argv[index];
+    if (!value) {
+        throw new Error(`${flag} requires a value`);
+    }
+    return value;
+}
+function printHelp() {
+    process.stdout.write(`recommended-by-mcp
+
+Usage:
+  recommended-by-mcp                    Start the stdio MCP server
+  recommended-by-mcp serve              Start the stdio MCP server
+  recommended-by-mcp login <api-key>    Save an API key locally
+  recommended-by-mcp logout             Remove the saved API key
+  recommended-by-mcp whoami             Validate auth by listing your lists
+  recommended-by-mcp config-path        Print the local config path
+
+Options:
+  --api-key <key>         Use a key for this invocation
+  --api-base-url <url>    Override the API base URL
+
+Environment:
+  RECOMMENDED_BY_API_KEY       API key used by the MCP server
+  RECOMMENDED_BY_API_BASE_URL  Defaults to https://api.recommended.by/api/v1
+`);
+}
+main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+});

package/dist/client.d.ts

@@ -0,0 +1,8 @@
+export declare class RecommendedByClient {
+    private readonly options;
+    constructor(options: {
+        apiKey: string;
+        apiBaseUrl: string;
+    });
+    request(method: string, path: string, body?: unknown): Promise<unknown>;
+}

package/dist/client.js

@@ -0,0 +1,43 @@
+export class RecommendedByClient {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async request(method, path, body) {
+        const response = await fetch(`${this.options.apiBaseUrl}${path}`, {
+            method,
+            headers: {
+                Authorization: `Bearer ${this.options.apiKey}`,
+                "Content-Type": "application/json",
+                "User-Agent": "recommended-by-mcp/0.1.0",
+            },
+            body: body === undefined ? undefined : JSON.stringify(body),
+        });
+        const text = await response.text();
+        const data = text ? parseJson(text) : null;
+        if (!response.ok) {
+            throw new Error(formatApiError(response.status, data));
+        }
+        return data;
+    }
+}
+function parseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function formatApiError(status, data) {
+    if (data && typeof data === "object" && "error" in data) {
+        const error = data.error;
+        if (typeof error === "string") {
+            return `recommended.by API error ${status}: ${error}`;
+        }
+    }
+    if (typeof data === "string" && data) {
+        return `recommended.by API error ${status}: ${data}`;
+    }
+    return `recommended.by API error ${status}`;
+}

package/dist/protocol.d.ts

@@ -0,0 +1,36 @@
+export type JsonRpcId = string | number | null;
+export type JsonRpcRequest = {
+    jsonrpc?: string;
+    id?: JsonRpcId;
+    method?: string;
+    params?: unknown;
+};
+export type ToolDefinition = {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: Record<string, unknown>;
+        required?: string[];
+        additionalProperties?: boolean;
+    };
+};
+export declare function jsonRpcResult(id: JsonRpcId | undefined, result: unknown): {
+    jsonrpc: string;
+    id: string | number | null;
+    result: unknown;
+};
+export declare function jsonRpcError(id: JsonRpcId | undefined, code: number, message: string): {
+    jsonrpc: string;
+    id: string | number | null;
+    error: {
+        code: number;
+        message: string;
+    };
+};
+export declare function textResult(value: unknown): {
+    content: {
+        type: string;
+        text: string;
+    }[];
+};

package/dist/protocol.js

@@ -0,0 +1,16 @@
+export function jsonRpcResult(id, result) {
+    return { jsonrpc: "2.0", id: id ?? null, result };
+}
+export function jsonRpcError(id, code, message) {
+    return { jsonrpc: "2.0", id: id ?? null, error: { code, message } };
+}
+export function textResult(value) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: typeof value === "string" ? value : JSON.stringify(value, null, 2),
+            },
+        ],
+    };
+}

package/dist/server.d.ts

@@ -0,0 +1,7 @@
+export declare function runMcpServer(options: {
+    apiKey: string;
+    apiBaseUrl: string;
+    stdin?: NodeJS.ReadableStream;
+    stdout?: NodeJS.WritableStream;
+    stderr?: NodeJS.WritableStream;
+}): Promise<void>;

package/dist/server.js

@@ -0,0 +1,76 @@
+import { createInterface } from "node:readline";
+import { RecommendedByClient } from "./client.js";
+import { jsonRpcError, jsonRpcResult } from "./protocol.js";
+import { callTool, tools } from "./tools.js";
+export async function runMcpServer(options) {
+    const client = new RecommendedByClient({
+        apiKey: options.apiKey,
+        apiBaseUrl: options.apiBaseUrl,
+    });
+    const input = createInterface({
+        input: options.stdin ?? process.stdin,
+        crlfDelay: Infinity,
+    });
+    const output = options.stdout ?? process.stdout;
+    const stderr = options.stderr ?? process.stderr;
+    for await (const line of input) {
+        if (!line.trim())
+            continue;
+        let request;
+        try {
+            request = JSON.parse(line);
+        }
+        catch {
+            write(output, jsonRpcError(null, -32700, "Parse error"));
+            continue;
+        }
+        if (request.jsonrpc !== "2.0" || typeof request.method !== "string") {
+            write(output, jsonRpcError(request.id, -32600, "Invalid Request"));
+            continue;
+        }
+        if (request.method.startsWith("notifications/")) {
+            continue;
+        }
+        try {
+            const result = await handleRequest(client, request);
+            write(output, jsonRpcResult(request.id, result));
+        }
+        catch (error) {
+            stderr.write(`${error instanceof Error ? error.message : "Tool call failed"}\n`);
+            write(output, jsonRpcError(request.id, -32000, error instanceof Error ? error.message : "Tool call failed"));
+        }
+    }
+}
+async function handleRequest(client, request) {
+    if (request.method === "initialize") {
+        return {
+            protocolVersion: "2024-11-05",
+            capabilities: { tools: {} },
+            serverInfo: {
+                name: "recommended.by",
+                version: "0.1.0",
+            },
+        };
+    }
+    if (request.method === "tools/list") {
+        return { tools };
+    }
+    if (request.method === "tools/call") {
+        const params = asRecord(request.params);
+        const name = typeof params.name === "string" ? params.name : undefined;
+        if (!name) {
+            throw new Error("Tool name is required");
+        }
+        return callTool(client, name, params.arguments);
+    }
+    throw new Error(`Method not found: ${request.method}`);
+}
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return {};
+    }
+    return value;
+}
+function write(output, payload) {
+    output.write(`${JSON.stringify(payload)}\n`);
+}

package/dist/tools.d.ts

@@ -0,0 +1,12 @@
+import { type ToolDefinition } from "./protocol.js";
+export declare const tools: ToolDefinition[];
+type ApiClient = {
+    request: (method: string, path: string, body?: unknown) => Promise<unknown>;
+};
+export declare function callTool(client: ApiClient, name: string, args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+export {};

package/dist/tools.js

@@ -0,0 +1,201 @@
+import { textResult } from "./protocol.js";
+const categories = [
+    "movies",
+    "tv-shows",
+    "books",
+    "music",
+    "podcasts",
+    "travel",
+    "restaurants",
+    "products",
+    "tools",
+    "courses",
+    "other",
+];
+const visibilities = [
+    "public",
+    "private",
+    "paid_subscription",
+    "paid_one_time",
+];
+const listInputProperties = {
+    title: { type: "string", description: "List title." },
+    description: { type: "string", description: "Optional list description." },
+    thumbnailUrl: {
+        type: "string",
+        description: "Optional cover image URL.",
+    },
+    category: { type: "string", enum: categories },
+    visibility: {
+        type: "string",
+        enum: visibilities,
+        default: "public",
+    },
+    priceInCents: {
+        type: "number",
+        description: "Required for paid list visibility.",
+    },
+    isRanked: { type: "boolean", default: false },
+    published: { type: "boolean", default: true },
+};
+const itemInputProperties = {
+    title: { type: "string", description: "Recommendation title." },
+    subtitle: { type: "string", description: "Optional subtitle or author." },
+    description: { type: "string", description: "Optional recommendation note." },
+    url: { type: "string", description: "Optional destination URL." },
+    imageUrl: { type: "string", description: "Optional image URL." },
+    metadata: {
+        type: "object",
+        description: "Optional structured metadata for the item.",
+    },
+};
+export const tools = [
+    {
+        name: "recommended_list_lists",
+        description: "List all lists owned by the API key profile, including items.",
+        inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    },
+    {
+        name: "recommended_create_list",
+        description: "Create a recommendation list for the API key profile.",
+        inputSchema: {
+            type: "object",
+            properties: listInputProperties,
+            required: ["title", "category"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "recommended_get_list",
+        description: "Fetch one owned list by id.",
+        inputSchema: {
+            type: "object",
+            properties: { listId: { type: "string" } },
+            required: ["listId"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "recommended_update_list",
+        description: "Update list metadata, visibility, pricing, or publish state.",
+        inputSchema: {
+            type: "object",
+            properties: { listId: { type: "string" }, ...listInputProperties },
+            required: ["listId"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "recommended_delete_list",
+        description: "Delete an owned list.",
+        inputSchema: {
+            type: "object",
+            properties: { listId: { type: "string" } },
+            required: ["listId"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "recommended_list_items",
+        description: "List items in an owned list.",
+        inputSchema: {
+            type: "object",
+            properties: { listId: { type: "string" } },
+            required: ["listId"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "recommended_add_item",
+        description: "Add an item to a list. Missing URL or image can be auto-enriched from the list category.",
+        inputSchema: {
+            type: "object",
+            properties: { listId: { type: "string" }, ...itemInputProperties },
+            required: ["listId", "title"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "recommended_update_item",
+        description: "Update an item in an owned list.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                listId: { type: "string" },
+                itemId: { type: "string" },
+                ...itemInputProperties,
+            },
+            required: ["listId", "itemId"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "recommended_delete_item",
+        description: "Delete an item from an owned list.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                listId: { type: "string" },
+                itemId: { type: "string" },
+            },
+            required: ["listId", "itemId"],
+            additionalProperties: false,
+        },
+    },
+];
+export async function callTool(client, name, args) {
+    const input = asRecord(args);
+    if (name === "recommended_list_lists") {
+        return textResult(await client.request("GET", "/lists"));
+    }
+    if (name === "recommended_create_list") {
+        return textResult(await client.request("POST", "/lists", withoutKeys(input)));
+    }
+    if (name === "recommended_get_list") {
+        return textResult(await client.request("GET", `/lists/${encodeURIComponent(getRequiredString(input, "listId"))}`));
+    }
+    if (name === "recommended_update_list") {
+        const listId = getRequiredString(input, "listId");
+        return textResult(await client.request("PATCH", `/lists/${encodeURIComponent(listId)}`, withoutKeys(input, "listId")));
+    }
+    if (name === "recommended_delete_list") {
+        const listId = getRequiredString(input, "listId");
+        return textResult(await client.request("DELETE", `/lists/${encodeURIComponent(listId)}`));
+    }
+    if (name === "recommended_list_items") {
+        const listId = getRequiredString(input, "listId");
+        return textResult(await client.request("GET", `/lists/${encodeURIComponent(listId)}/items`));
+    }
+    if (name === "recommended_add_item") {
+        const listId = getRequiredString(input, "listId");
+        return textResult(await client.request("POST", `/lists/${encodeURIComponent(listId)}/items`, withoutKeys(input, "listId")));
+    }
+    if (name === "recommended_update_item") {
+        const listId = getRequiredString(input, "listId");
+        const itemId = getRequiredString(input, "itemId");
+        return textResult(await client.request("PATCH", `/lists/${encodeURIComponent(listId)}/items/${encodeURIComponent(itemId)}`, withoutKeys(input, "listId", "itemId")));
+    }
+    if (name === "recommended_delete_item") {
+        const listId = getRequiredString(input, "listId");
+        const itemId = getRequiredString(input, "itemId");
+        return textResult(await client.request("DELETE", `/lists/${encodeURIComponent(listId)}/items/${encodeURIComponent(itemId)}`));
+    }
+    throw new Error(`Unknown tool: ${name}`);
+}
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return {};
+    }
+    return value;
+}
+function getRequiredString(input, key) {
+    const value = input[key];
+    if (typeof value !== "string" || !value) {
+        throw new Error(`${key} is required`);
+    }
+    return value;
+}
+function withoutKeys(input, ...keys) {
+    const blocked = new Set(keys);
+    return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined).filter(([key]) => !blocked.has(key)));
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "recommended-by-mcp",
+  "version": "0.1.0",
+  "description": "Stdio MCP server for managing recommended.by lists from agents like OpenClaw, Codex, Claude, and Cursor.",
+  "type": "module",
+  "bin": {
+    "recommended-by-mcp": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "!dist/*.test.js",
+    "!dist/*.test.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepack": "pnpm build",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node --test dist/*.test.js"
+  },
+  "keywords": [
+    "recommended.by",
+    "mcp",
+    "openclaw",
+    "codex",
+    "claude",
+    "cursor",
+    "recommendations"
+  ],
+  "author": "simple bytes",
+  "license": "MIT",
+  "homepage": "https://recommended.by/guides",
+  "bugs": {
+    "url": "https://github.com/simplebytes-com/recommended-by-mcp/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/simplebytes-com/recommended-by-mcp.git"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "typescript": "^5"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}