@zoobbe/cli 1.2.1 → 1.2.3

package/README.md

@@ -365,6 +365,48 @@ zoobbe t start <cardId>  # Same as: zoobbe timer start <cardId>
 zoobbe n ls --unread     # Same as: zoobbe notification list --unread
 ```
 
+## MCP Server (AI Integration)
+
+The CLI includes a built-in [MCP](https://modelcontextprotocol.io) server that lets AI agents like Claude interact with your Zoobbe workspace directly.
+
+### Setup
+
+```bash
+# Install the CLI (includes MCP server)
+npm install -g @zoobbe/cli
+
+# Make sure you're logged in
+zoobbe auth login
+
+# Connect to Claude Code
+claude mcp add zoobbe -- zoobbe-mcp
+```
+
+### What Claude can do
+
+Once connected, Claude can read and manage your workspace through natural language:
+
+- "What cards are assigned to me?"
+- "Show overdue tasks on the Sprint board"
+- "Create a high-priority card for the login bug"
+- "Move card abc123 to Done"
+- "What happened on the board this week?"
+
+### Source Attribution
+
+All changes made through the MCP server are automatically tagged in activity logs as **(via AI Agent)**, and CLI commands are tagged as **(via CLI)**. This lets your team distinguish between manual and automated actions when reviewing card or board history.
+
+### Available tools (28)
+
+| Category | Tools |
+|----------|-------|
+| Boards | `list_boards`, `get_board`, `list_lists`, `board_members`, `board_activities`, `board_labels`, `board_analytics` |
+| Cards | `list_cards`, `get_card`, `card_comments`, `card_checklists`, `card_activities` |
+| Actions | `create_card`, `update_card`, `move_card`, `assign_card`, `add_comment`, `mark_card_done`, `mark_card_undone`, `set_due_date`, `set_priority`, `archive_card` |
+| General | `my_status`, `search`, `list_notifications`, `mark_notifications_read`, `create_board`, `create_list` |
+
+Zero extra dependencies — the MCP server implements the protocol natively over stdio.
+
 ## License
 
 MIT

package/bin/zoobbe-mcp

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+'use strict';
+
+require('../src/mcp-server.js');

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@zoobbe/cli",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "Zoobbe CLI - Manage boards, cards, and projects from the terminal",
   "main": "src/index.js",
   "bin": {
-    "zoobbe": "bin/zoobbe"
+    "zoobbe": "bin/zoobbe",
+    "zoobbe-mcp": "bin/zoobbe-mcp"
   },
   "scripts": {
     "start": "node bin/zoobbe",
@@ -19,7 +20,9 @@
     "task-management",
     "boards",
     "cards",
-    "ai-agent"
+    "ai-agent",
+    "mcp",
+    "model-context-protocol"
   ],
   "license": "MIT",
   "author": {

package/src/index.js

@@ -1,6 +1,10 @@
 const { Command } = require('commander');
 const chalk = require('chalk');
 const pkg = require('../package.json');
+const client = require('./lib/client');
+
+// Mark all requests from CLI as CLI actions
+client.setSource('cli');
 
 const program = new Command();
 

package/src/lib/client.js

@@ -1,6 +1,14 @@
 const config = require('./config');
 
 class ZoobbeClient {
+  constructor() {
+    this._source = null;
+  }
+
+  setSource(source) {
+    this._source = source;
+  }
+
   get baseUrl() {
     return config.get('apiUrl');
   }
@@ -10,11 +18,15 @@ class ZoobbeClient {
   }
 
   get headers() {
-    return {
+    const h = {
       'Authorization': `Bearer ${this.apiKey}`,
       'Content-Type': 'application/json',
       'User-Agent': 'Zoobbe-CLI/1.0',
     };
+    if (this._source) {
+      h['X-Zoobbe-Source'] = this._source;
+    }
+    return h;
   }
 
   ensureAuth() {
@@ -96,13 +108,18 @@ class ZoobbeClient {
 
     const body = Buffer.concat([Buffer.from(header), fileBuffer, Buffer.from(footer)]);
 
+    const uploadHeaders = {
+      'Authorization': `Bearer ${this.apiKey}`,
+      'User-Agent': 'Zoobbe-CLI/1.0',
+      'Content-Type': `multipart/form-data; boundary=${boundary}`,
+    };
+    if (this._source) {
+      uploadHeaders['X-Zoobbe-Source'] = this._source;
+    }
+
     const response = await fetch(url, {
       method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${this.apiKey}`,
-        'User-Agent': 'Zoobbe-CLI/1.0',
-        'Content-Type': `multipart/form-data; boundary=${boundary}`,
-      },
+      headers: uploadHeaders,
       body,
     });
 

package/src/mcp-server.js

@@ -0,0 +1,800 @@
+#!/usr/bin/env node
+
+/**
+ * Zoobbe MCP Server
+ *
+ * Exposes Zoobbe boards, cards, and project management as MCP tools
+ * so AI agents (Claude, etc.) can interact with your workspace.
+ *
+ * Usage:
+ *   claude mcp add zoobbe -- zoobbe-mcp
+ *
+ * Protocol: JSON-RPC 2.0 over stdio (MCP standard)
+ */
+
+const readline = require('readline');
+const client = require('./lib/client');
+const config = require('./lib/config');
+
+// Mark all requests from MCP server as AI agent actions
+client.setSource('mcp');
+
+// ── Tool Definitions ──
+
+const TOOLS = [
+  // Read — Boards
+  {
+    name: 'list_boards',
+    description: 'List all boards in the active Zoobbe workspace. Returns board names, IDs, visibility, member/list counts, and archive status.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        include_archived: { type: 'boolean', description: 'Include archived boards (default false)' },
+      },
+    },
+  },
+  {
+    name: 'get_board',
+    description: 'Get details of a specific board including title, visibility, member count, list count, and creation date.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        board_id: { type: 'string', description: 'Board short ID' },
+      },
+      required: ['board_id'],
+    },
+  },
+  {
+    name: 'list_lists',
+    description: 'List all columns (action lists) on a board. Returns list titles, IDs, card counts, and status.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        board_id: { type: 'string', description: 'Board short ID' },
+      },
+      required: ['board_id'],
+    },
+  },
+  {
+    name: 'board_members',
+    description: 'List all members of a board with their names, emails, and roles.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        board_id: { type: 'string', description: 'Board short ID' },
+      },
+      required: ['board_id'],
+    },
+  },
+  {
+    name: 'board_activities',
+    description: 'Show recent activity log for a board (who did what and when).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        board_id: { type: 'string', description: 'Board short ID' },
+        limit: { type: 'number', description: 'Max activities to return (default 20)' },
+      },
+      required: ['board_id'],
+    },
+  },
+  {
+    name: 'board_labels',
+    description: 'List all labels available on a board.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        board_id: { type: 'string', description: 'Board short ID' },
+      },
+      required: ['board_id'],
+    },
+  },
+
+  // Read — Cards
+  {
+    name: 'list_cards',
+    description: 'List cards on a board. Can filter by list, assignee, due date. Returns titles, IDs, list names, due dates, members, and priority.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        board_id: { type: 'string', description: 'Board short ID' },
+        due: { type: 'string', description: 'Filter: "today", "week", or "overdue"' },
+      },
+      required: ['board_id'],
+    },
+  },
+  {
+    name: 'get_card',
+    description: 'Get full details of a card: title, description, board, list, members, due date, priority, completion status, labels.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        card_id: { type: 'string', description: 'Card short ID' },
+      },
+      required: ['card_id'],
+    },
+  },
+  {
+    name: 'card_comments',
+    description: 'List comments on a card.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        card_id: { type: 'string', description: 'Card short ID' },
+      },
+      required: ['card_id'],
+    },
+  },
+  {
+    name: 'card_checklists',
+    description: 'List checklists and their items on a card, with completion status.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        card_id: { type: 'string', description: 'Card short ID' },
+      },
+      required: ['card_id'],
+    },
+  },
+  {
+    name: 'card_activities',
+    description: 'Show recent activity log for a card.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        card_id: { type: 'string', description: 'Card short ID' },
+        limit: { type: 'number', description: 'Max activities (default 20)' },
+      },
+      required: ['card_id'],
+    },
+  },
+
+  // Read — General
+  {
+    name: 'my_status',
+    description: 'Show all cards assigned to the current user across all boards. Great for "what am I working on?" questions.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'search',
+    description: 'Search across boards, cards, and pages. Returns matching results with titles and IDs.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Search query' },
+      },
+      required: ['query'],
+    },
+  },
+  {
+    name: 'list_notifications',
+    description: 'List recent notifications. Can filter to unread only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        unread_only: { type: 'boolean', description: 'Only unread (default true)' },
+        limit: { type: 'number', description: 'Max notifications (default 20)' },
+      },
+    },
+  },
+  {
+    name: 'board_analytics',
+    description: 'Get analytics overview for a board: total cards, completed, in progress, overdue, completion rate.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        board_id: { type: 'string', description: 'Board short ID' },
+      },
+      required: ['board_id'],
+    },
+  },
+
+  // Write — Cards
+  {
+    name: 'create_card',
+    description: 'Create a new card on a board. Optionally specify list, description, due date, and priority.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'Card title' },
+        board_id: { type: 'string', description: 'Board short ID' },
+        list_id: { type: 'string', description: 'List ID (uses first list if omitted)' },
+        description: { type: 'string', description: 'Card description' },
+        due_date: { type: 'string', description: 'Due date (YYYY-MM-DD)' },
+        priority: { type: 'string', description: 'Priority: low, medium, high, critical' },
+      },
+      required: ['title', 'board_id'],
+    },
+  },
+  {
+    name: 'update_card',
+    description: 'Update a card\'s title or description.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        card_id: { type: 'string', description: 'Card short ID' },
+        title: { type: 'string', description: 'New title' },
+        description: { type: 'string', description: 'New description' },
+      },
+      required: ['card_id'],
+    },
+  },
+  {
+    name: 'move_card',
+    description: 'Move a card to a different list (column) on its board.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        card_id: { type: 'string', description: 'Card short ID' },
+        list_name: { type: 'string', description: 'Target list name or ID' },
+        board_id: { type: 'string', description: 'Board short ID (auto-detected if omitted)' },
+      },
+      required: ['card_id', 'list_name'],
+    },
+  },
+  {
+    name: 'assign_card',
+    description: 'Assign a user to a card.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        card_id: { type: 'string', description: 'Card short ID' },
+        user_id: { type: 'string', description: 'User ID to assign' },
+      },
+      required: ['card_id', 'user_id'],
+    },
+  },
+  {
+    name: 'add_comment',
+    description: 'Add a comment to a card.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        card_id: { type: 'string', description: 'Card short ID' },
+        comment: { type: 'string', description: 'Comment text' },
+      },
+      required: ['card_id', 'comment'],
+    },
+  },
+  {
+    name: 'mark_card_done',
+    description: 'Mark a card as complete.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        card_id: { type: 'string', description: 'Card short ID' },
+      },
+      required: ['card_id'],
+    },
+  },
+  {
+    name: 'mark_card_undone',
+    description: 'Mark a card as incomplete.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        card_id: { type: 'string', description: 'Card short ID' },
+      },
+      required: ['card_id'],
+    },
+  },
+  {
+    name: 'set_due_date',
+    description: 'Set or remove a due date on a card.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        card_id: { type: 'string', description: 'Card short ID' },
+        due_date: { type: 'string', description: 'Due date (YYYY-MM-DD), or empty to remove' },
+      },
+      required: ['card_id'],
+    },
+  },
+  {
+    name: 'set_priority',
+    description: 'Set card priority level.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        card_id: { type: 'string', description: 'Card short ID' },
+        priority: { type: 'string', description: 'Priority: low, medium, high, critical' },
+      },
+      required: ['card_id', 'priority'],
+    },
+  },
+  {
+    name: 'archive_card',
+    description: 'Archive a card.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        card_id: { type: 'string', description: 'Card short ID' },
+      },
+      required: ['card_id'],
+    },
+  },
+
+  // Write — Board/List
+  {
+    name: 'create_board',
+    description: 'Create a new board in the active workspace.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Board name' },
+        visibility: { type: 'string', description: 'Private, Public, or Workspace (default Private)' },
+      },
+      required: ['name'],
+    },
+  },
+  {
+    name: 'create_list',
+    description: 'Create a new list (column) on a board.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'List title' },
+        board_id: { type: 'string', description: 'Board short ID' },
+      },
+      required: ['title', 'board_id'],
+    },
+  },
+  {
+    name: 'mark_notifications_read',
+    description: 'Mark all notifications as read.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+];
+
+// ── Tool Handlers ──
+
+async function executeTool(name, args = {}) {
+  const workspaceId = config.get('activeWorkspace');
+
+  switch (name) {
+    // ── Read: Boards ──
+    case 'list_boards': {
+      const data = await client.get(`/boards?workspaceId=${encodeURIComponent(workspaceId)}`);
+      let boards = data.data || data;
+      if (!args.include_archived) {
+        boards = boards.filter(b => !b.isArchived);
+      }
+      return boards.map(b => ({
+        name: b.name || b.title,
+        id: b.shortId,
+        visibility: b.visibility || 'Private',
+        lists: b.actionLists?.length || 0,
+        members: b.members?.length || 0,
+        archived: !!b.isArchived,
+      }));
+    }
+
+    case 'get_board': {
+      const data = await client.get(`/boards/${args.board_id}`);
+      const b = data.board || data.data || data;
+      return {
+        name: b.title || b.name,
+        id: b.shortId,
+        visibility: b.visibility || 'Private',
+        members: b.members?.length || 0,
+        lists: b.actionLists?.length || 0,
+        created: b.createdAt,
+      };
+    }
+
+    case 'list_lists': {
+      const data = await client.get(`/${args.board_id}/actionLists/`);
+      let lists = data.lists || data.data || data;
+      lists = Array.isArray(lists) ? lists : Object.values(lists);
+      return lists.filter(l => !l.archived).map(l => ({
+        title: l.title || 'Untitled',
+        id: l._id,
+        cards: l.cards?.length || 0,
+      }));
+    }
+
+    case 'board_members': {
+      const data = await client.get(`/boards/${args.board_id}/members`);
+      const members = data.members || data.data || data;
+      return (Array.isArray(members) ? members : []).map(m => {
+        const u = m.user || m;
+        return { name: u.userName || u.name, email: u.email, role: m.role || 'member', id: u._id };
+      });
+    }
+
+    case 'board_activities': {
+      const data = await client.get(`/boards/${args.board_id}/activities`);
+      const acts = data.activities || data.data || data;
+      return (Array.isArray(acts) ? acts : []).slice(0, args.limit || 20).map(a => ({
+        action: a.action || a.type,
+        user: a.user?.userName || a.user?.name,
+        target: a.target || a.card?.title || '',
+        time: a.createdAt,
+      }));
+    }
+
+    case 'board_labels': {
+      const data = await client.get(`/boards/${args.board_id}/labels`);
+      const labels = data.labels || data.data || data;
+      return (Array.isArray(labels) ? labels : []).map(l => ({
+        text: l.text || '', color: l.color || '', id: l._id,
+      }));
+    }
+
+    // ── Read: Cards ──
+    case 'list_cards': {
+      const listsData = await client.get(`/boards/${args.board_id}/lists`);
+      const lists = listsData.lists || listsData.data || listsData;
+      const listArr = Array.isArray(lists) ? lists : Object.values(lists);
+
+      const cardRefs = [];
+      for (const list of listArr) {
+        if (list.cards && Array.isArray(list.cards)) {
+          for (const c of list.cards) {
+            cardRefs.push({ id: c.shortId || c._id, listName: list.title || '' });
+          }
+        }
+      }
+
+      const results = await Promise.allSettled(
+        cardRefs.map(ref => client.get(`/cards/${ref.id}`).then(d => ({ ...d, _listName: ref.listName })))
+      );
+
+      let cards = results.filter(r => r.status === 'fulfilled').map(r => r.value);
+
+      if (args.due) {
+        const now = new Date();
+        cards = cards.filter(c => {
+          if (!c.dueDate) return false;
+          const due = new Date(c.dueDate?.date || c.dueDate);
+          if (args.due === 'today') return due.toDateString() === now.toDateString();
+          if (args.due === 'week') return due <= new Date(now.getTime() + 7 * 86400000);
+          if (args.due === 'overdue') return due < now;
+          return true;
+        });
+      }
+
+      return cards.map(c => ({
+        title: c.title || c.name,
+        id: c.shortId || c._id,
+        list: c._listName || c.actionListTitle || '',
+        due: c.dueDate?.date || c.dueDate || null,
+        members: c.members?.length || 0,
+        priority: c.priority || null,
+        complete: !!c.completed,
+      }));
+    }
+
+    case 'get_card': {
+      const data = await client.get(`/cards/${args.card_id}`);
+      const c = data.card || data.data || data;
+      return {
+        title: c.title || c.name,
+        id: c.shortId || c._id,
+        board: c.boardTitle || c.board,
+        list: c.actionListTitle || c.actionList?.name,
+        description: c.description || '',
+        members: c.members?.length || 0,
+        due: c.dueDate?.date || c.dueDate || null,
+        priority: c.priority || null,
+        complete: !!c.completed,
+        labels: c.labels || [],
+        created: c.createdAt,
+      };
+    }
+
+    case 'card_comments': {
+      const data = await client.get(`/cards/${args.card_id}/comments`);
+      const comments = data.comments || data.data || data;
+      return (Array.isArray(comments) ? comments : []).map(c => ({
+        user: c.member?.userName || c.user?.userName,
+        comment: c.comment,
+        time: c.createdAt,
+        id: c._id,
+      }));
+    }
+
+    case 'card_checklists': {
+      const data = await client.get(`/cards/${args.card_id}/checklists`);
+      const cls = data.checklists || data.data || data;
+      return (Array.isArray(cls) ? cls : []).map(cl => ({
+        title: cl.title,
+        id: cl._id,
+        items: (cl.items || []).map(i => ({
+          title: i.title, checked: !!i.checked, id: i._id,
+        })),
+      }));
+    }
+
+    case 'card_activities': {
+      const data = await client.get(`/cards/${args.card_id}/activities`);
+      const acts = data.activities || data.data || data;
+      return (Array.isArray(acts) ? acts : []).slice(0, args.limit || 20).map(a => ({
+        action: a.action || a.type,
+        user: a.user?.userName || a.user?.name,
+        detail: a.detail || a.description || '',
+        time: a.createdAt,
+      }));
+    }
+
+    // ── Read: General ──
+    case 'my_status': {
+      const userId = config.get('userId');
+      const data = await client.get(`/${userId}/cards`);
+      const cards = data.data || data;
+      return (Array.isArray(cards) ? cards : []).map(c => ({
+        title: c.title || c.name,
+        id: c.shortId || c._id,
+        board: c.boardTitle || '',
+        list: c.actionListTitle || '',
+        due: c.dueDate?.date || c.dueDate || null,
+        priority: c.priority || null,
+        complete: !!c.completed,
+      }));
+    }
+
+    case 'search': {
+      const data = await client.get(`/search?q=${encodeURIComponent(args.query)}&workspaceId=${encodeURIComponent(workspaceId)}`);
+      return data.data || data;
+    }
+
+    case 'list_notifications': {
+      const limit = args.limit || 20;
+      let url = `/notifications?limit=${limit}`;
+      if (args.unread_only !== false) url += '&unread=true';
+      const data = await client.get(url);
+      const notifs = data.notifications || data.data || data;
+      return (Array.isArray(notifs) ? notifs : []).map(n => ({
+        type: n.type || n.action,
+        message: n.message || n.text || '',
+        read: !!n.read,
+        time: n.createdAt,
+        id: n._id,
+      }));
+    }
+
+    case 'board_analytics': {
+      const data = await client.get(`/analytics/board/${args.board_id}`);
+      return data.analytics || data.data || data;
+    }
+
+    // ── Write: Cards ──
+    case 'create_card': {
+      let listId = args.list_id;
+      if (!listId) {
+        const listsData = await client.get(`/boards/${args.board_id}/lists`);
+        const lists = listsData.lists || listsData.data || listsData;
+        const listArr = Array.isArray(lists) ? lists : Object.values(lists);
+        if (listArr.length === 0) throw new Error('Board has no lists');
+        listId = listArr[0]._id;
+      }
+
+      const body = { title: args.title, actionListId: listId };
+      if (args.description) body.description = args.description;
+
+      const data = await client.post('/cards', body);
+      const c = data.card || data.data || data;
+      const cardId = c.shortId || c._id;
+
+      if (args.due_date) {
+        await client.post(`/cards/${cardId}/duedate`, { dueDate: args.due_date });
+      }
+      if (args.priority) {
+        await client.post(`/cards/${cardId}/priority`, { priority: args.priority });
+      }
+
+      return { created: true, title: args.title, id: cardId, changed_by: 'AI Agent (via MCP)' };
+    }
+
+    case 'update_card': {
+      const body = {};
+      if (args.title) body.title = args.title;
+      if (args.description) body.description = args.description;
+      if (Object.keys(body).length === 0) throw new Error('Provide title or description to update');
+      await client.post(`/cards/update/${args.card_id}`, body);
+      return { updated: true, card_id: args.card_id, changed_by: 'AI Agent (via MCP)' };
+    }
+
+    case 'move_card': {
+      const cardData = await client.get(`/cards/${args.card_id}`);
+      const c = cardData.card || cardData.data || cardData;
+      const boardId = args.board_id || c.boardShortId || c.board;
+
+      const listsData = await client.get(`/boards/${boardId}/lists`);
+      const lists = listsData.lists || listsData.data || listsData;
+      const listArr = Array.isArray(lists) ? lists : Object.values(lists);
+
+      const sourceListId = c.actionList?._id || c.actionListId;
+      const sourceList = listArr.find(l => l._id === sourceListId || l._id?.toString() === sourceListId?.toString());
+      const targetList = listArr.find(l =>
+        l._id === args.list_name ||
+        (l.title || '').toLowerCase() === args.list_name.toLowerCase()
+      );
+
+      if (!targetList) throw new Error(`List "${args.list_name}" not found. Available: ${listArr.map(l => l.title).join(', ')}`);
+      if (!sourceList) throw new Error('Could not determine current list');
+
+      await client.put(`/boards/${boardId}/cards/order`, {
+        sourceListId: sourceList._id,
+        cardId: c._id,
+        targetListId: targetList._id,
+        targetPosition: 0,
+      });
+      return { moved: true, card_id: args.card_id, to: targetList.title, changed_by: 'AI Agent (via MCP)' };
+    }
+
+    case 'assign_card': {
+      await client.post(`/cards/${args.card_id}/addMember`, { memberId: args.user_id });
+      return { assigned: true, card_id: args.card_id, user_id: args.user_id, changed_by: 'AI Agent (via MCP)' };
+    }
+
+    case 'add_comment': {
+      const userId = config.get('userId');
+      await client.post(`/cards/${args.card_id}/comments`, {
+        comment: args.comment, member: userId, mentionedIds: [],
+      });
+      return { commented: true, card_id: args.card_id, changed_by: 'AI Agent (via MCP)' };
+    }
+
+    case 'mark_card_done': {
+      await client.post(`/cards/update/${args.card_id}`, { isComplete: true });
+      return { done: true, card_id: args.card_id, changed_by: 'AI Agent (via MCP)' };
+    }
+
+    case 'mark_card_undone': {
+      await client.post(`/cards/update/${args.card_id}`, { isComplete: false });
+      return { undone: true, card_id: args.card_id, changed_by: 'AI Agent (via MCP)' };
+    }
+
+    case 'set_due_date': {
+      if (!args.due_date) {
+        await client.delete(`/cards/${args.card_id}/duedate`);
+        return { removed: true, card_id: args.card_id, changed_by: 'AI Agent (via MCP)' };
+      }
+      await client.post(`/cards/${args.card_id}/duedate`, { dueDate: args.due_date });
+      return { set: true, card_id: args.card_id, due_date: args.due_date, changed_by: 'AI Agent (via MCP)' };
+    }
+
+    case 'set_priority': {
+      await client.post(`/cards/${args.card_id}/priority`, { priority: args.priority });
+      return { set: true, card_id: args.card_id, priority: args.priority, changed_by: 'AI Agent (via MCP)' };
+    }
+
+    case 'archive_card': {
+      await client.post(`/cards/archive/${args.card_id}`);
+      return { archived: true, card_id: args.card_id, changed_by: 'AI Agent (via MCP)' };
+    }
+
+    // ── Write: Board/List ──
+    case 'create_board': {
+      const wsData = await client.get('/workspaces/me');
+      const workspaces = wsData.data || wsData;
+      const ws = workspaces.find(w => w.shortId === workspaceId);
+      if (!ws) throw new Error('Active workspace not found');
+
+      const data = await client.post('/boards', {
+        title: args.name,
+        workspaceId: ws._id,
+        visibility: args.visibility || 'Private',
+      });
+      const b = data.board || data.data || data;
+      return { created: true, name: args.name, id: b.shortId, changed_by: 'AI Agent (via MCP)' };
+    }
+
+    case 'create_list': {
+      const data = await client.post('/actionLists', { title: args.title, boardId: args.board_id });
+      const l = data.actionList || data.data || data;
+      return { created: true, title: args.title, id: l._id, changed_by: 'AI Agent (via MCP)' };
+    }
+
+    case 'mark_notifications_read': {
+      await client.put('/notifications/mark-all-read');
+      return { done: true };
+    }
+
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}
+
+// ── MCP Protocol Handler (JSON-RPC 2.0 over stdio) ──
+
+const SERVER_INFO = {
+  name: 'zoobbe',
+  version: '1.2.2',
+};
+
+function makeResponse(id, result) {
+  return JSON.stringify({ jsonrpc: '2.0', id, result }) + '\n';
+}
+
+function makeError(id, code, message) {
+  return JSON.stringify({ jsonrpc: '2.0', id, error: { code, message } }) + '\n';
+}
+
+async function handleMessage(msg) {
+  const { id, method, params } = msg;
+
+  switch (method) {
+    case 'initialize':
+      return makeResponse(id, {
+        protocolVersion: '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: SERVER_INFO,
+      });
+
+    case 'notifications/initialized':
+      return null; // no response for notifications
+
+    case 'tools/list':
+      return makeResponse(id, { tools: TOOLS });
+
+    case 'tools/call': {
+      const toolName = params?.name;
+      const toolArgs = params?.arguments || {};
+
+      try {
+        const result = await executeTool(toolName, toolArgs);
+        return makeResponse(id, {
+          content: [{
+            type: 'text',
+            text: typeof result === 'string' ? result : JSON.stringify(result, null, 2),
+          }],
+        });
+      } catch (err) {
+        return makeResponse(id, {
+          content: [{ type: 'text', text: `Error: ${err.message}` }],
+          isError: true,
+        });
+      }
+    }
+
+    case 'ping':
+      return makeResponse(id, {});
+
+    default:
+      if (id) {
+        return makeError(id, -32601, `Method not found: ${method}`);
+      }
+      return null;
+  }
+}
+
+// ── Main: stdio loop ──
+
+const rl = readline.createInterface({ input: process.stdin, terminal: false });
+
+let buffer = '';
+
+process.stdin.on('data', (chunk) => {
+  buffer += chunk.toString();
+
+  let newlineIdx;
+  while ((newlineIdx = buffer.indexOf('\n')) !== -1) {
+    const line = buffer.slice(0, newlineIdx).trim();
+    buffer = buffer.slice(newlineIdx + 1);
+
+    if (!line) continue;
+
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      process.stderr.write(`[zoobbe-mcp] Invalid JSON: ${line}\n`);
+      continue;
+    }
+
+    handleMessage(msg).then((response) => {
+      if (response) {
+        process.stdout.write(response);
+      }
+    }).catch((err) => {
+      process.stderr.write(`[zoobbe-mcp] Error: ${err.message}\n`);
+      if (msg.id) {
+        process.stdout.write(makeError(msg.id, -32603, err.message));
+      }
+    });
+  }
+});
+
+process.stderr.write('[zoobbe-mcp] Server started\n');