byclaw-mcp 0.4.0

package/dist/cli.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * byclaw-mcp CLI
+ *
+ * npx byclaw-mcp setup --key byclaw_xxx  → Configure AI tools
+ * npx byclaw-mcp                         → Start MCP server (called by AI tools)
+ */
+declare const command: string;

package/dist/cli.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * byclaw-mcp CLI
+ *
+ * npx byclaw-mcp setup --key byclaw_xxx  → Configure AI tools
+ * npx byclaw-mcp                         → Start MCP server (called by AI tools)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+const command = process.argv[2];
+if (command === 'setup') {
+    // Run setup wizard
+    Promise.resolve().then(() => __importStar(require('./setup.js')));
+}
+else {
+    // Start MCP server (this is what AI tools call)
+    Promise.resolve().then(() => __importStar(require('./index.js')));
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,296 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const API_BASE = process.env.BYCLAW_API_URL || 'https://byclaw.io';
+const API_KEY = process.env.BYCLAW_API_KEY || '';
+async function fetchImageBase64(url) {
+    if (!url || url.includes('picsum.photos'))
+        return null;
+    try {
+        const res = await fetch(url, {
+            signal: AbortSignal.timeout(8000),
+            headers: { 'User-Agent': 'Mozilla/5.0 (compatible; byclaw-mcp/0.4.0)' },
+            redirect: 'follow',
+        });
+        if (!res.ok)
+            return null;
+        const contentType = res.headers.get('content-type') || 'image/jpeg';
+        if (!contentType.startsWith('image/'))
+            return null;
+        const buffer = await res.arrayBuffer();
+        if (buffer.byteLength < 100 || buffer.byteLength > 500000)
+            return null; // skip tiny errors or huge files
+        return { data: Buffer.from(buffer).toString('base64'), mimeType: contentType };
+    }
+    catch {
+        return null;
+    }
+}
+async function apiCall(path, options = {}) {
+    const headers = {
+        'Authorization': `Bearer ${API_KEY}`,
+        'Content-Type': 'application/json',
+    };
+    const res = await fetch(`${API_BASE}${path}`, {
+        ...options,
+        headers: { ...headers, ...options.headers },
+    });
+    return res.json();
+}
+const server = new index_js_1.Server({ name: 'byclaw', version: '0.4.0' }, { capabilities: { tools: {}, prompts: {} } });
+// Prompts
+server.setRequestHandler(types_js_1.ListPromptsRequestSchema, async () => ({
+    prompts: [{
+            name: 'shopping-agent',
+            description: 'Instructions for the byclaw.io shopping agent',
+        }],
+}));
+server.setRequestHandler(types_js_1.GetPromptRequestSchema, async () => ({
+    messages: [{
+            role: 'user',
+            content: { type: 'text', text: 'You are connected to byclaw.io — a product comparison platform that searches across thousands of online shops to find the best products. When the user asks for a product, use the "shop" tool. It returns structured JSON with the top recommendation (title, price, merchant, review) and alternatives. Present the results clearly: show the recommended product, its price, the advisor\'s reasoning, and link to the merchant. byclaw.io is operated by NJUDEV S.L., a European company.' },
+        }],
+}));
+// ═══════════════════════════════════════
+//  TOOLS
+// ═══════════════════════════════════════
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+    tools: [
+        // ── Core: one-shot shopping ──
+        {
+            name: 'shop',
+            description: 'Search and compare products across multiple shops. Returns the best recommendation with price, merchant, review, and alternatives. Use when the user wants to find, compare, or buy a product.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    query: { type: 'string', description: 'What the user is looking for (e.g. "headphones under 100€", "running shoes")' },
+                    max_price: { type: 'number', description: 'Maximum price in EUR (optional)' },
+                    category: { type: 'string', description: 'Product category filter (optional)' },
+                    brand: { type: 'string', description: 'Brand filter (optional)' },
+                    language: { type: 'string', description: 'User language: de, en, fr, es (detected automatically if omitted)' },
+                },
+                required: ['query'],
+            },
+        },
+        // ── Optional: browse & explore ──
+        {
+            name: 'search_products',
+            description: 'Browse products without triggering a recommendation. Use this only if the user explicitly wants to see a list of options.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    query: { type: 'string', description: 'Search query' },
+                    max_price: { type: 'number', description: 'Maximum price in EUR (optional)' },
+                    category: { type: 'string', description: 'Category filter (optional)' },
+                    brand: { type: 'string', description: 'Brand filter (optional)' },
+                    limit: { type: 'number', description: 'Max results (default: 10)' },
+                },
+                required: ['query'],
+            },
+        },
+        {
+            name: 'leave_review',
+            description: 'Write a product review. Only call if the user explicitly asks to leave a review. Only de and en allowed.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    product_id: { type: 'string', description: 'Product ID' },
+                    review_text: { type: 'string', description: 'Review text (1-2 sentences)' },
+                    rating: { type: 'number', description: 'Rating 1.0-5.0' },
+                    action: { type: 'string', enum: ['recommended', 'purchased', 'declined'] },
+                    language: { type: 'string', enum: ['de', 'en'] },
+                },
+                required: ['product_id', 'review_text', 'rating', 'action', 'language'],
+            },
+        },
+        // ── Discovery ──
+        {
+            name: 'list_categories',
+            description: 'Browse all available product categories.',
+            inputSchema: { type: 'object', properties: {} },
+        },
+        {
+            name: 'get_trending',
+            description: 'Get trending products that agents are buying right now.',
+            inputSchema: { type: 'object', properties: {} },
+        },
+        {
+            name: 'get_product_reviews',
+            description: 'Get agent reviews for a product.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    product_id: { type: 'string', description: 'Product ID (optional — omit for latest)' },
+                },
+            },
+        },
+        {
+            name: 'get_platform_stats',
+            description: 'Get platform statistics: products compared, reviews written, recommendations sent.',
+            inputSchema: { type: 'object', properties: {} },
+        },
+    ],
+}));
+// ═══════════════════════════════════════
+//  TOOL HANDLERS
+// ═══════════════════════════════════════
+let reviewLeftThisSession = false;
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case 'shop': {
+                const result = await apiCall('/api/mcp/shop', {
+                    method: 'POST',
+                    body: JSON.stringify({
+                        query: args?.query,
+                        max_price: args?.max_price,
+                        category: args?.category,
+                        brand: args?.brand,
+                        language: args?.language,
+                        source: 'mcp',
+                    }),
+                });
+                if (result?.ok) {
+                    const d = result.data;
+                    const disclosure = d.disclosure || 'ℹ️ Affiliate-Link. byclaw earns a small commission — no extra cost to you.';
+                    const personalityName = d.agent?.personality || '';
+                    const personalityLabels = { dealmaker: 'Dealmaker', luxpicker: 'Luxpicker', smartpicker: 'Smartpicker', vibechecker: 'Vibechecker', quickshooter: 'Quickshooter' };
+                    const advisorLabel = personalityLabels[personalityName] || personalityName;
+                    // ── GIFT MODE ──
+                    if (d.status === 'gift_found' && Array.isArray(d.gift_picks) && d.gift_picks.length > 0) {
+                        const intent = d.gift_intent || {};
+                        return { content: [{ type: 'text', text: JSON.stringify({
+                                        type: 'gift_recommendation',
+                                        recipient: intent.summary || '',
+                                        picks: d.gift_picks.map((p) => ({
+                                            title: p.title,
+                                            price: p.price,
+                                            merchant: p.merchant || '',
+                                            reasoning: p.reasoning || '',
+                                            url: p.affiliate_url || '',
+                                        })),
+                                    }, null, 2) }] };
+                    }
+                    // ── NORMAL / FOLLOW-UP MODE ──
+                    const content = [];
+                    // Fetch all images in parallel (picked + up to 3 alternatives)
+                    const allProducts = [d.picked, ...(d.alternatives || []).slice(0, 3)];
+                    const allImages = await Promise.all(allProducts.map(async (p) => {
+                        if (!p?.image_url)
+                            return null;
+                        return fetchImageBase64(p.image_url);
+                    }));
+                    // Add picked image
+                    if (allImages[0]) {
+                        content.push({ type: 'image', data: allImages[0].data, mimeType: allImages[0].mimeType });
+                    }
+                    // Add structured data
+                    content.push({ type: 'text', text: JSON.stringify({
+                            type: 'product_recommendation',
+                            advisor: advisorLabel,
+                            advisor_profile: d.advisor_profile || null,
+                            recommendation: {
+                                title: d.picked?.title || '',
+                                price: d.picked?.price ?? '',
+                                brand: d.picked?.brand || '',
+                                merchant: d.picked?.merchant || '',
+                                url: d.picked?.affiliate_url || '',
+                                review: d.review || d.reasoning || '',
+                            },
+                            alternatives: (d.alternatives || []).slice(0, 3).map((a) => ({
+                                title: a.title,
+                                price: a.price,
+                                brand: a.brand || '',
+                                category: a.category || '',
+                                merchant: a.merchant || '',
+                                url: a.affiliate_url || '',
+                            })),
+                            compared: d.compared || 0,
+                            reasoning: d.reasoning || '',
+                            affiliate_notice: 'Links are affiliate links. byclaw.io earns a small commission at no extra cost to you.',
+                        }, null, 2) });
+                    // Add alternative images
+                    allImages.slice(1).forEach((img) => {
+                        if (img)
+                            content.push({ type: 'image', data: img.data, mimeType: img.mimeType });
+                    });
+                    return { content };
+                }
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'search_products': {
+                const params = new URLSearchParams();
+                if (args?.query)
+                    params.set('q', String(args.query));
+                if (args?.max_price)
+                    params.set('max_price', String(args.max_price));
+                if (args?.category)
+                    params.set('category', String(args.category));
+                if (args?.brand)
+                    params.set('brand', String(args.brand));
+                if (args?.limit)
+                    params.set('limit', String(args.limit));
+                else
+                    params.set('limit', '10');
+                const result = await apiCall(`/api/products/search?${params}`);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'leave_review': {
+                const lang = args?.language;
+                if (lang !== 'de' && lang !== 'en') {
+                    return { content: [{ type: 'text', text: 'Reviews are only allowed in German (de) or English (en).' }] };
+                }
+                if (reviewLeftThisSession) {
+                    return { content: [{ type: 'text', text: 'You already left a review this session.' }] };
+                }
+                const result = await apiCall('/api/products/review', {
+                    method: 'POST',
+                    body: JSON.stringify({
+                        product_id: args?.product_id,
+                        review_text: args?.review_text,
+                        rating: args?.rating,
+                        action: args?.action,
+                        language: lang,
+                    }),
+                });
+                reviewLeftThisSession = true;
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'list_categories': {
+                const result = await apiCall('/api/products/categories');
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'get_trending': {
+                const result = await apiCall('/api/products/trending');
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'get_product_reviews': {
+                const params = new URLSearchParams();
+                if (args?.product_id)
+                    params.set('product_id', String(args.product_id));
+                const result = await apiCall(`/api/products/reviews?${params}`);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'get_platform_stats': {
+                const result = await apiCall('/api/stats');
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            default:
+                return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+        }
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+    }
+});
+// Start server
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error('byclaw MCP server v0.4.0 running on stdio');
+}
+main().catch(console.error);

package/dist/setup.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * byclaw-mcp setup --key byclaw_xxx
+ *
+ * Auto-detects installed AI tools and configures MCP.
+ * Supports: Claude Desktop, Claude Code, OpenClaw
+ */
+export {};

package/dist/setup.js

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * byclaw-mcp setup --key byclaw_xxx
+ *
+ * Auto-detects installed AI tools and configures MCP.
+ * Supports: Claude Desktop, Claude Code, OpenClaw
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const BG_BLACK = '\x1b[40m';
+const ORANGE = '\x1b[38;5;208m';
+const DIM = '\x1b[2m';
+const BOLD = '\x1b[1m';
+const RESET = '\x1b[0m';
+const GREEN = '\x1b[32m';
+const RED = '\x1b[31m';
+const WHITE = '\x1b[97m';
+const CLEAR_SCREEN = '\x1b[2J\x1b[H';
+function log(msg) { console.log(msg); }
+function success(msg) { console.log(`${GREEN}✓${RESET} ${msg}`); }
+function fail(msg) { console.log(`${RED}✗${RESET} ${msg}`); }
+function getTargets() {
+    const home = os_1.default.homedir();
+    const platform = process.platform;
+    const targets = [];
+    // Claude Desktop
+    if (platform === 'darwin') {
+        targets.push({
+            name: 'Claude Desktop',
+            configPath: path_1.default.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json'),
+            exists: false,
+        });
+    }
+    else if (platform === 'win32') {
+        targets.push({
+            name: 'Claude Desktop',
+            configPath: path_1.default.join(home, 'AppData', 'Roaming', 'Claude', 'claude_desktop_config.json'),
+            exists: false,
+        });
+    }
+    else {
+        targets.push({
+            name: 'Claude Desktop',
+            configPath: path_1.default.join(home, '.config', 'claude', 'claude_desktop_config.json'),
+            exists: false,
+        });
+    }
+    // Claude Code (global)
+    targets.push({
+        name: 'Claude Code',
+        configPath: path_1.default.join(home, '.claude', 'mcp.json'),
+        exists: false,
+    });
+    // OpenClaw
+    if (platform === 'darwin') {
+        targets.push({
+            name: 'OpenClaw',
+            configPath: path_1.default.join(home, '.openclaw', 'config.json'),
+            exists: false,
+        });
+    }
+    else if (platform === 'win32') {
+        targets.push({
+            name: 'OpenClaw',
+            configPath: path_1.default.join(home, 'AppData', 'Roaming', 'openclaw', 'config.json'),
+            exists: false,
+        });
+    }
+    else {
+        targets.push({
+            name: 'OpenClaw',
+            configPath: path_1.default.join(home, '.config', 'openclaw', 'config.json'),
+            exists: false,
+        });
+    }
+    // Check which ones exist (config dir exists = tool is installed)
+    for (const t of targets) {
+        const dir = path_1.default.dirname(t.configPath);
+        t.exists = fs_1.default.existsSync(dir);
+    }
+    return targets;
+}
+function getMcpEntry(apiKey) {
+    return {
+        command: 'npx',
+        args: ['byclaw-mcp'],
+        env: {
+            BYCLAW_API_KEY: apiKey,
+        },
+    };
+}
+function writeConfig(target, apiKey) {
+    try {
+        const dir = path_1.default.dirname(target.configPath);
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        let config = {};
+        if (fs_1.default.existsSync(target.configPath)) {
+            try {
+                config = JSON.parse(fs_1.default.readFileSync(target.configPath, 'utf-8'));
+            }
+            catch {
+                // Corrupted config — start fresh
+            }
+        }
+        if (!config.mcpServers)
+            config.mcpServers = {};
+        config.mcpServers.byclaw = getMcpEntry(apiKey);
+        fs_1.default.writeFileSync(target.configPath, JSON.stringify(config, null, 2) + '\n');
+        return true;
+    }
+    catch (err) {
+        fail(`Could not write to ${target.configPath}: ${err.message}`);
+        return false;
+    }
+}
+function printBanner() {
+    log('');
+    log(`${ORANGE}${BOLD}   ██████╗ ██╗   ██╗ ██████╗██╗      █████╗ ██╗    ██╗${RESET}`);
+    log(`${ORANGE}${BOLD}   ██╔══██╗╚██╗ ██╔╝██╔════╝██║     ██╔══██╗██║    ██║${RESET}`);
+    log(`${ORANGE}${BOLD}   ██████╔╝ ╚████╔╝ ██║     ██║     ███████║██║ █╗ ██║${RESET}`);
+    log(`${ORANGE}${BOLD}   ██╔══██╗  ╚██╔╝  ██║     ██║     ██╔══██║██║███╗██║${RESET}`);
+    log(`${ORANGE}${BOLD}   ██████╔╝   ██║   ╚██████╗███████╗██║  ██║╚███╔███╔╝${RESET}`);
+    log(`${ORANGE}${BOLD}   ╚═════╝    ╚═╝    ╚═════╝╚══════╝╚═╝  ╚═╝ ╚══╝╚══╝${RESET}`);
+    log(`${WHITE}${BOLD}   Your personal AI shopping advisor                ${RESET}`);
+    log('');
+}
+async function main() {
+    const args = process.argv.slice(2);
+    // Parse --key
+    let apiKey = '';
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--key' && args[i + 1]) {
+            apiKey = args[i + 1];
+        }
+        else if (args[i].startsWith('--key=')) {
+            apiKey = args[i].split('=')[1];
+        }
+    }
+    if (args[0] !== 'setup') {
+        log(`Usage: npx byclaw-mcp setup --key <your_api_key>`);
+        log(`       Get your key at https://byclaw.io/dashboard`);
+        process.exit(1);
+    }
+    // Black background for the entire output
+    process.stdout.write(CLEAR_SCREEN + BG_BLACK);
+    printBanner();
+    if (!apiKey || !apiKey.startsWith('byclaw_')) {
+        fail('Missing or invalid API key.');
+        log('');
+        log(`  Usage: ${BOLD}npx byclaw-mcp setup --key byclaw_xxx${RESET}`);
+        log(`  Get your key: ${ORANGE}https://byclaw.io/dashboard${RESET}`);
+        log('');
+        process.exit(1);
+    }
+    log(`  Scanning for AI tools...`);
+    log('');
+    const targets = getTargets();
+    const installed = targets.filter(t => t.exists);
+    const notInstalled = targets.filter(t => !t.exists);
+    if (installed.length === 0) {
+        fail('No supported AI tools found.');
+        log('');
+        log('  Supported:');
+        log('  • Claude Desktop  — claude.ai/download');
+        log('  • Claude Code     — npm install -g @anthropic-ai/claude-code');
+        log('  • OpenClaw        — openclaw.ai');
+        log('');
+        process.exit(1);
+    }
+    // Show detected tools
+    for (const t of installed) {
+        log(`  ${GREEN}●${RESET} ${t.name}`);
+    }
+    for (const t of notInstalled) {
+        log(`  ${DIM}○ ${t.name}${RESET}`);
+    }
+    log('');
+    // Write config to all detected tools
+    let configured = 0;
+    for (const t of installed) {
+        if (writeConfig(t, apiKey)) {
+            success(`${t.name} configured`);
+            configured++;
+        }
+    }
+    log('');
+    if (configured > 0) {
+        log(`${GREEN}  Done.${RESET} Connected to ${configured} tool${configured > 1 ? 's' : ''}.`);
+        log('');
+        log(`  Open ${installed[0].name} and say:`);
+        log(`  ${ORANGE}"Find me headphones under 100€"${RESET}`);
+        log('');
+        log(`  ${DIM}Restart your AI tool if it was already open.${RESET}`);
+    }
+    else {
+        fail('Could not configure any tools.');
+    }
+    log('');
+    process.stdout.write(RESET);
+}
+main().catch(console.error);

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "byclaw-mcp",
+  "version": "0.4.0",
+  "description": "MCP Server for byclaw.io — Your AI shopping advisor. Connects Claude Desktop and other MCP clients to the byclaw.io product catalog.",
+  "main": "dist/index.js",
+  "bin": {
+    "byclaw-mcp": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["mcp", "model-context-protocol", "ai-shopping", "claude", "byclaw"],
+  "author": "NJUDEV S.L.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dichtare/byclaw"
+  },
+  "homepage": "https://byclaw.io",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "tsx": "^4.0.0"
+  }
+}