kibbutz-mcp 1.0.0

package/build/index.js

@@ -0,0 +1,298 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { v4 as uuidv4 } from 'uuid';
+import { WebSocketServer, WebSocket } from 'ws';
+import { createServer } from 'http';
+import { z } from 'zod';
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+let wss;
+let extensionSocket = null;
+let token = null;
+const map = new Map();
+const server = new McpServer({
+    name: 'kibbutz-mcp',
+    version: '1.0.0',
+});
+function findChromeExecutable() {
+    const platform = process.platform;
+    if (platform === 'linux') {
+        return '/opt/google/chrome/chrome';
+    }
+    if (platform === 'darwin') {
+        return '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
+    }
+    if (platform === 'win32') {
+        const suffix = '\\Google\\Chrome\\Application\\chrome.exe';
+        const bases = [
+            process.env.LOCALAPPDATA,
+            process.env.PROGRAMFILES,
+            process.env['PROGRAMFILES(X86)'],
+            process.env.HOMEDRIVE && path.join(process.env.HOMEDRIVE, 'Program Files'),
+            process.env.HOMEDRIVE && path.join(process.env.HOMEDRIVE, 'Program Files (x86)'),
+        ].filter(Boolean);
+        for (const base of bases) {
+            const candidate = path.join(base, suffix);
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    throw new Error(`Chrome executable not found for platform: ${platform}`);
+}
+function openChromeWithExtension(wsPort) {
+    const executablePath = findChromeExecutable();
+    const url = new URL('chrome-extension://bpfjmggaaiigpfahhmpmacfhlemnhhip/kibbutz-mcp.html');
+    token = uuidv4();
+    url.searchParams.set('wsPort', String(wsPort));
+    url.searchParams.set('token', token);
+    const child = spawn(executablePath, [url.toString()], {
+        detached: true,
+        windowsHide: true,
+        shell: false,
+        stdio: 'ignore',
+    });
+    child.unref();
+}
+const sendAndWaitForReply = (message, args) => {
+    if (!extensionSocket || extensionSocket.readyState !== WebSocket.OPEN) {
+        return Promise.resolve({
+            content: [
+                {
+                    type: 'text',
+                    text: `Connection failed: The MCP server cannot reach the Chrome extension.
+
+Please check the following:
+1. Is the browser open?
+2. Is the MCP switch inside the extension popup turned ON?
+
+If the issue persists, copy and paste this URL into your browser address bar:
+chrome-extension://bpfjmggaaiigpfahhmpmacfhlemnhhip/kibbutz-mcp.html`,
+                },
+            ],
+            isError: true,
+        });
+    }
+    return new Promise((resolve, reject) => {
+        const id = uuidv4();
+        map.set(id, {
+            resolve: (result) => {
+                resolve({
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                    isError: false,
+                });
+            },
+            reject,
+        });
+        extensionSocket?.send(JSON.stringify({
+            id,
+            message,
+            args,
+        }));
+    });
+};
+server.registerTool('SNAPSHOT_MCP', {
+    title: 'Get window snapshot',
+    description: 'Get the current window tabs organized as a nested tree structure. Returns groups and their child tabs, along with standalone tabs, titles, and URLs.',
+}, (args) => sendAndWaitForReply('SNAPSHOT_MCP', args));
+server.registerTool('CLOSE_GROUPS_MCP', {
+    title: 'Close groups',
+    description: 'Close specific browser groups and all their contained tabs.',
+    inputSchema: {
+        groupIds: z
+            .array(z.number())
+            .min(1)
+            .describe('List of group identifiers (integers) to close.'),
+    },
+}, (args) => sendAndWaitForReply('CLOSE_GROUPS_MCP', args));
+server.registerTool('UNGROUPS_MCP', {
+    title: 'Ungroup groups',
+    description: 'Ungroup specific browser groups using their group IDs. The tabs will become standalone.',
+    inputSchema: {
+        groupIds: z
+            .array(z.number())
+            .min(1)
+            .describe('List of group identifiers (integers) to ungroup.'),
+    },
+}, (args) => sendAndWaitForReply('UNGROUPS_MCP', args));
+server.registerTool('CLOSE_TABS_MCP', {
+    title: 'Close tabs',
+    description: 'Close specific browser tabs using their unique IDs.',
+    inputSchema: {
+        tabIds: z
+            .array(z.number())
+            .min(1)
+            .describe('List of specific tab identifiers (integers) to close.'),
+    },
+}, (args) => sendAndWaitForReply('CLOSE_TABS_MCP', args));
+server.registerTool('UNGROUP_TABS_MCP', {
+    title: 'Ungroup tabs',
+    description: 'Remove specific tabs from their assigned groups using their tab IDs. The tabs will become standalone.',
+    inputSchema: {
+        tabIds: z
+            .array(z.number())
+            .min(1)
+            .describe('List of specific tab identifiers (integers) to remove from their groups.'),
+    },
+}, (args) => sendAndWaitForReply('UNGROUP_TABS_MCP', args));
+server.registerTool('ADD_TO_GROUP_MCP', {
+    title: 'Add tabs to group',
+    description: 'Move specific tabs into an existing browser group.',
+    inputSchema: {
+        tabIds: z
+            .array(z.number())
+            .min(1)
+            .describe('List of tab IDs to move into the target group.'),
+        groupId: z
+            .number()
+            .describe('The integer ID of an existing group to move the tabs into.'),
+    },
+}, (args) => sendAndWaitForReply('ADD_TO_GROUP_MCP', args));
+server.registerTool('MOVE_GROUP_MCP', {
+    title: 'Move group',
+    description: 'Reposition a browser group to a new index.',
+    inputSchema: {
+        groupId: z.number().describe('The ID of the group to move.'),
+        index: z
+            .number()
+            .describe('The new position index. Use 0 for the start, -1 for the end.'),
+    },
+}, (args) => sendAndWaitForReply('MOVE_GROUP_MCP', args));
+server.registerTool('MOVE_TABS_MCP', {
+    title: 'Move tabs',
+    description: 'Move one or more tabs to a specific index position. Multiple tabs will be placed contiguously starting at the target index.',
+    inputSchema: {
+        tabIds: z.array(z.number()).min(1).describe('List of tab IDs to move.'),
+        index: z
+            .number()
+            .describe('The new position index. Use 0 for the start, -1 for the end.'),
+    },
+}, (args) => sendAndWaitForReply('MOVE_TABS_MCP', args));
+server.registerTool('ADD_TO_NEW_GROUP_MCP', {
+    title: 'Create group',
+    description: 'Create a new browser group from a list of tabs, with a title and color.',
+    inputSchema: {
+        tabIds: z
+            .array(z.number())
+            .min(1)
+            .describe('List of tab IDs to group together into the new group.'),
+        title: z.string().describe('The title of the new group'),
+        color: z
+            .enum([
+            'grey',
+            'blue',
+            'red',
+            'yellow',
+            'green',
+            'pink',
+            'purple',
+            'cyan',
+            'orange',
+        ])
+            .describe('The color of the new group. Must be one of the supported Chrome colors.'),
+    },
+}, (args) => sendAndWaitForReply('ADD_TO_NEW_GROUP_MCP', args));
+server.registerTool('UPDATE_GROUP_MCP', {
+    title: 'Update group',
+    description: 'Update the title or color of an existing browser group. At least one property (title or color) should be provided.',
+    inputSchema: {
+        groupId: z.number().describe('The ID of the group to update'),
+        title: z
+            .string()
+            .optional()
+            .describe('The new title. Leave undefined to keep the current title.'),
+        color: z
+            .enum([
+            'grey',
+            'blue',
+            'red',
+            'yellow',
+            'green',
+            'pink',
+            'purple',
+            'cyan',
+            'orange',
+        ])
+            .optional()
+            .describe('The new color. Leave undefined to keep the current color.'),
+    },
+}, (args) => sendAndWaitForReply('UPDATE_GROUP_MCP', args));
+async function main() {
+    const httpServer = createServer((req, res) => {
+        try {
+            const url = new URL(req.url || '', `http://${req.headers.host}`);
+            const retToken = url.searchParams.get('token');
+            const verify = retToken === token;
+            if (verify) {
+                token = uuidv4();
+            }
+            res.writeHead(404);
+            res.end(JSON.stringify({ verify }));
+        }
+        catch (e) {
+            console.error('Failed to parse URL:', req.url, e);
+            res.writeHead(404);
+            res.end(JSON.stringify({ verify: false }));
+        }
+    });
+    wss = new WebSocketServer({ noServer: true });
+    wss.on('connection', (ws, request) => {
+        extensionSocket = ws;
+        ws.on('error', console.error);
+        ws.on('close', () => {
+            if (extensionSocket === ws) {
+                extensionSocket = null;
+            }
+            for (const { reject } of map.values()) {
+                reject(new Error('Extension WebSocket closed'));
+            }
+            map.clear();
+        });
+        ws.on('message', (data) => {
+            try {
+                const text = data.toString();
+                if (text === 'ping')
+                    return;
+                const response = JSON.parse(text);
+                if (response.id && map.has(response.id)) {
+                    const pending = map.get(response.id);
+                    pending.resolve(response.result);
+                    map.delete(response.id);
+                }
+            }
+            catch (_e) {
+                console.error('Failed to parse message from extension:', data);
+            }
+        });
+    });
+    httpServer.on('upgrade', (request, socket, head) => {
+        if (request.headers.origin !== 'chrome-extension://bpfjmggaaiigpfahhmpmacfhlemnhhip') {
+            socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
+            socket.destroy();
+            return;
+        }
+        wss.clients.forEach((ws) => ws.terminate());
+        wss.handleUpgrade(request, socket, head, (ws) => {
+            wss.emit('connection', ws, request);
+        });
+    });
+    httpServer.listen(0, () => {
+        const port = httpServer.address().port;
+        openChromeWithExtension(port);
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    process.stdin.on('end', () => {
+        try {
+            openChromeWithExtension(0);
+        }
+        catch (err) {
+            console.error('Failed to open Chrome with extension:', err);
+        }
+    });
+}
+main().catch((error) => {
+    console.error('Server error:', error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,31 @@
+{
+    "name": "kibbutz-mcp",
+    "version": "1.0.0",
+    "description": "",
+    "main": "index.js",
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1",
+        "build": "tsc && chmod 755 build/index.js"
+    },
+    "keywords": [],
+    "author": "",
+    "license": "ISC",
+    "type": "module",
+    "bin": {
+        "kibbutz-mcp": "build/index.js"
+    },
+    "files": [
+        "build"
+    ],
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.24.3",
+        "uuid": "^13.0.0",
+        "ws": "^8.18.3",
+        "zod": "^4.1.13"
+    },
+    "devDependencies": {
+        "@types/node": "^24.10.2",
+        "@types/ws": "^8.18.1",
+        "typescript": "^5.9.3"
+    }
+}