cleanhouse-mcp 1.0.0

package/index.js

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+
+const https = require('https');
+const http = require('http');
+const url = require('url');
+
+const BASE_URL = process.env.CLEANHOUSE_URL || 'https://web-production-65a7a.up.railway.app';
+const USERNAME = process.env.CLEANHOUSE_USERNAME || '';
+const PASSWORD = process.env.CLEANHOUSE_PASSWORD || '';
+
+let sessionCookie = '';
+
+function request(method, path, body) {
+  return new Promise((resolve, reject) => {
+    const parsed = url.parse(BASE_URL + path);
+    const lib = parsed.protocol === 'https:' ? https : http;
+    const data = body ? JSON.stringify(body) : null;
+    const options = {
+      hostname: parsed.hostname,
+      port: parsed.port,
+      path: parsed.path,
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        ...(sessionCookie ? { Cookie: sessionCookie } : {}),
+        ...(data ? { 'Content-Length': Buffer.byteLength(data) } : {})
+      }
+    };
+    const req = lib.request(options, res => {
+      let raw = '';
+      res.on('data', c => raw += c);
+      res.on('end', () => {
+        if (res.headers['set-cookie']) {
+          sessionCookie = res.headers['set-cookie'].map(c => c.split(';')[0]).join('; ');
+        }
+        try { resolve(JSON.parse(raw)); } catch { resolve({}); }
+      });
+    });
+    req.on('error', reject);
+    if (data) req.write(data);
+    req.end();
+  });
+}
+
+async function ensureLogin() {
+  if (sessionCookie) return true;
+  const r = await request('POST', '/api/auth/login', { username: USERNAME, password: PASSWORD });
+  return !!(r.ok || r.user);
+}
+
+const TOOLS = [
+  {
+    name: 'get_members',
+    description: 'Get all family members with points, coins and streaks',
+    inputSchema: { type: 'object', properties: {} }
+  },
+  {
+    name: 'get_tasks',
+    description: 'Get all tasks, optionally filtered by room name',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        room_name: { type: 'string', description: 'Filter by room name (optional)' }
+      }
+    }
+  },
+  {
+    name: 'add_task',
+    description: 'Add a new cleaning task',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Task name' },
+        room_name: { type: 'string', description: 'Room name' },
+        difficulty: { type: 'string', enum: ['easy', 'medium', 'hard'] },
+        freq: { type: 'string', enum: ['daily', 'every2', 'weekly', 'biweekly', 'monthly'] }
+      },
+      required: ['name']
+    }
+  },
+  {
+    name: 'complete_task',
+    description: 'Mark a task as completed by a family member',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        task_name: { type: 'string', description: 'Task name' },
+        member_name: { type: 'string', description: 'Member name' }
+      },
+      required: ['task_name']
+    }
+  },
+  {
+    name: 'get_leaderboard',
+    description: 'Get family leaderboard rankings',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        period: { type: 'string', enum: ['week', 'month', 'all'] }
+      }
+    }
+  },
+  {
+    name: 'add_room',
+    description: 'Add a new room to the household',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Room name' },
+        emoji: { type: 'string', description: 'Room emoji' }
+      },
+      required: ['name']
+    }
+  },
+  {
+    name: 'get_rooms',
+    description: 'Get all rooms with cleanliness percentage',
+    inputSchema: { type: 'object', properties: {} }
+  }
+];
+
+async function handleTool(name, args) {
+  const ok = await ensureLogin();
+  if (!ok) return 'Login failed. Check CLEANHOUSE_USERNAME and CLEANHOUSE_PASSWORD.';
+
+  const data = await request('GET', '/api/data');
+
+  if (name === 'get_members') {
+    return (data.members || [])
+      .map(m => `${m.emoji} ${m.name} — ${m.points} pts | 🪙${m.coins} | 🔥${m.streak} streak`)
+      .join('\n') || 'No members.';
+  }
+
+  if (name === 'get_rooms') {
+    return (data.rooms || [])
+      .map(r => `${r.emoji} ${r.name} — ${r.cleanliness}% clean`)
+      .join('\n') || 'No rooms.';
+  }
+
+  if (name === 'get_tasks') {
+    const rooms = Object.fromEntries((data.rooms || []).map(r => [r.id, r.name]));
+    const filter = (args.room_name || '').toLowerCase();
+    const tasks = (data.tasks || []).filter(t => !filter || (rooms[t.room_id] || '').toLowerCase().includes(filter));
+    return tasks.map(t => `• ${t.name} [${rooms[t.room_id] || '?'}] — ${t.diff} — ${t.freq}`).join('\n') || 'No tasks.';
+  }
+
+  if (name === 'add_task') {
+    const rooms = data.rooms || [];
+    const roomName = (args.room_name || '').toLowerCase();
+    const room = rooms.find(r => r.name.toLowerCase().includes(roomName)) || rooms[0];
+    const r = await request('POST', '/api/tasks', {
+      name: args.name,
+      room_id: room ? room.id : null,
+      diff: args.difficulty || 'medium',
+      freq: args.freq || 'weekly',
+      approval_needed: false,
+      one_time: false
+    });
+    return r.ok ? `Task '${args.name}' added!` : `Error: ${r.error}`;
+  }
+
+  if (name === 'complete_task') {
+    const tasks = data.tasks || [];
+    const members = data.members || [];
+    const task = tasks.find(t => t.name.toLowerCase().includes((args.task_name || '').toLowerCase()));
+    if (!task) return `Task '${args.task_name}' not found.`;
+    const member = members.find(m => m.name.toLowerCase().includes((args.member_name || '').toLowerCase())) || members[0];
+    if (!member) return 'No members found.';
+    const r = await request('POST', `/api/tasks/${task.id}/complete`, { member_id: member.id });
+    return r.ok ? `✅ '${task.name}' completed by ${member.name}! +${r.pts || '?'} pts` : `Error: ${r.error}`;
+  }
+
+  if (name === 'get_leaderboard') {
+    const period = args.period || 'week';
+    const lb = await request('GET', `/api/leaderboard?period=${period}`);
+    if (!Array.isArray(lb)) return 'Could not fetch leaderboard.';
+    const medals = ['🥇', '🥈', '🥉'];
+    return lb.map((m, i) => `${medals[i] || (i+1)+'.'} ${m.emoji} ${m.name} — ${m.period_pts || 0} pts | total: ${m.points} | 🪙${m.coins}`).join('\n');
+  }
+
+  if (name === 'add_room') {
+    const r = await request('POST', '/api/rooms', { name: args.name, emoji: args.emoji || '🏠' });
+    return r.ok ? `Room '${args.name}' added!` : `Error: ${r.error}`;
+  }
+
+  return `Unknown tool: ${name}`;
+}
+
+// MCP stdio JSON-RPC
+const readline = require('readline');
+const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+
+rl.on('line', async line => {
+  line = line.trim();
+  if (!line) return;
+  let msg;
+  try { msg = JSON.parse(line); } catch { return; }
+
+  const { id, method, params } = msg;
+  let resp;
+
+  if (method === 'initialize') {
+    resp = {
+      jsonrpc: '2.0', id,
+      result: {
+        protocolVersion: '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: { name: 'cleanhouse-mcp', version: '1.0.0' }
+      }
+    };
+  } else if (method === 'tools/list') {
+    resp = { jsonrpc: '2.0', id, result: { tools: TOOLS } };
+  } else if (method === 'tools/call') {
+    const text = await handleTool(params.name, params.arguments || {});
+    resp = { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text }] } };
+  } else if (method === 'notifications/initialized') {
+    return;
+  } else {
+    resp = { jsonrpc: '2.0', id, error: { code: -32601, message: `Method not found: ${method}` } };
+  }
+
+  process.stdout.write(JSON.stringify(resp) + '\n');
+});

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "cleanhouse-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for CleanHouse - household chore management app",
+  "main": "index.js",
+  "bin": {
+    "cleanhouse-mcp": "index.js"
+  },
+  "scripts": {
+    "start": "node index.js"
+  },
+  "keywords": ["mcp", "cleanhouse", "chores", "household", "claude"],
+  "author": "CleanHouse",
+  "license": "MIT",
+  "dependencies": {}
+}