@majkapp/majk-chat-mcp 1.0.0

package/dist/tools/permission-handler.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPPermissionHandler = void 0;
+const parser_1 = require("../config/parser");
+class MCPPermissionHandler {
+    constructor(mcpClient, permissionToolName, quiet = false) {
+        this.quiet = quiet;
+        this.permissionTool = null;
+        this.mcpClient = mcpClient;
+        if (permissionToolName) {
+            this.permissionTool = parser_1.MCPConfigParser.parsePermissionTool(permissionToolName);
+            if (!this.permissionTool) {
+                throw new Error(`Invalid permission tool format: ${permissionToolName}`);
+            }
+        }
+    }
+    async requestPermission(toolName, args, context) {
+        const result = await this.requestPermissionWithUpdate(toolName, args, context);
+        return result.allowed;
+    }
+    async requestPermissionWithUpdate(toolName, args, context) {
+        if (!this.permissionTool) {
+            return { allowed: true };
+        }
+        const connection = this.mcpClient.getConnection(this.permissionTool.serverName);
+        if (!connection) {
+            if (!this.quiet) {
+                console.warn(`Permission server "${this.permissionTool.serverName}" not connected`);
+            }
+            return { allowed: false };
+        }
+        try {
+            // Generate a unique tool use ID
+            const toolUseId = `tool-use-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+            // Create the permission request in the required format
+            const permissionRequest = {
+                tool_name: toolName,
+                input: args,
+                tool_use_id: toolUseId,
+                // Add optional context fields
+                user_id: context.userId,
+                request_id: context.requestId,
+                metadata: context.metadata
+            };
+            const result = await connection.client.callTool({
+                name: this.permissionTool.toolName,
+                arguments: permissionRequest
+            });
+            if (result.isError) {
+                if (!this.quiet) {
+                    console.error(`Permission check failed: ${result.text}`);
+                }
+                return { allowed: false };
+            }
+            const response = result.content?.[0];
+            if (response?.type === 'text') {
+                try {
+                    // Parse the JSON response
+                    const permissionResponse = JSON.parse(response.text);
+                    return {
+                        allowed: permissionResponse.behavior === 'allow',
+                        updatedInput: permissionResponse.updatedInput
+                    };
+                }
+                catch (parseError) {
+                    // Fallback to simple text parsing for backward compatibility
+                    const text = response.text.toLowerCase();
+                    const allowed = text === 'true' || text === 'yes' || text === 'allow' || text === 'granted';
+                    return { allowed };
+                }
+            }
+            return { allowed: false };
+        }
+        catch (error) {
+            if (!this.quiet) {
+                console.error('Permission check error:', error);
+            }
+            return { allowed: false };
+        }
+    }
+    setPermissionTool(toolName) {
+        this.permissionTool = parser_1.MCPConfigParser.parsePermissionTool(toolName);
+        if (!this.permissionTool) {
+            throw new Error(`Invalid permission tool format: ${toolName}`);
+        }
+    }
+    getPermissionTool() {
+        return this.permissionTool?.originalName || null;
+    }
+}
+exports.MCPPermissionHandler = MCPPermissionHandler;

package/dist/tools/tool-filter.d.ts

@@ -0,0 +1,20 @@
+export declare class ToolFilter {
+    private allowedPatterns;
+    private disallowedPatterns;
+    private allowedExact;
+    private disallowedExact;
+    constructor(allowedTools?: string[], disallowedTools?: string[]);
+    private parsePatterns;
+    private matchesPatterns;
+    isAllowed(toolName: string): boolean;
+    filterTools<T extends {
+        name: string;
+    }>(tools: T[]): T[];
+    addAllowed(toolName: string): void;
+    addDisallowed(toolName: string): void;
+    removeAllowed(toolName: string): void;
+    removeDisallowed(toolName: string): void;
+    getAllowedList(): string[] | null;
+    getDisallowedList(): string[];
+}
+//# sourceMappingURL=tool-filter.d.ts.map

package/dist/tools/tool-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-filter.d.ts","sourceRoot":"","sources":["../../src/tools/tool-filter.ts"],"names":[],"mappings":"AAAA,qBAAa,UAAU;IACrB,OAAO,CAAC,eAAe,CAAW;IAClC,OAAO,CAAC,kBAAkB,CAAW;IACrC,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,eAAe,CAAc;gBAEzB,YAAY,CAAC,EAAE,MAAM,EAAE,EAAE,eAAe,CAAC,EAAE,MAAM,EAAE;IAW/D,OAAO,CAAC,aAAa;IAqBrB,OAAO,CAAC,eAAe;IAUvB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAepC,WAAW,CAAC,CAAC,SAAS;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE;IAIxD,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAWlC,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAWrC,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAKrC,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAKxC,cAAc,IAAI,MAAM,EAAE,GAAG,IAAI;IAKjC,iBAAiB,IAAI,MAAM,EAAE;CAG9B"}

package/dist/tools/tool-filter.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolFilter = void 0;
+class ToolFilter {
+    constructor(allowedTools, disallowedTools) {
+        // Separate wildcards from exact matches for performance
+        const allowed = this.parsePatterns(allowedTools || []);
+        const disallowed = this.parsePatterns(disallowedTools || []);
+        this.allowedPatterns = allowed.patterns;
+        this.allowedExact = allowed.exact;
+        this.disallowedPatterns = disallowed.patterns;
+        this.disallowedExact = disallowed.exact;
+    }
+    parsePatterns(tools) {
+        const patterns = [];
+        const exact = new Set();
+        for (const tool of tools) {
+            if (tool.includes('*')) {
+                // Convert wildcard pattern to regex
+                const regexPattern = tool
+                    .replace(/[.+?^${}()|[\]\\]/g, '\\$&') // Escape special regex chars
+                    .replace(/\*/g, '.*'); // Convert * to .*
+                patterns.push(new RegExp(`^${regexPattern}$`, 'i'));
+            }
+            else {
+                // Exact match
+                exact.add(tool);
+            }
+        }
+        return { patterns, exact };
+    }
+    matchesPatterns(toolName, patterns, exact) {
+        // Check exact matches first (faster)
+        if (exact.has(toolName)) {
+            return true;
+        }
+        // Check wildcard patterns
+        return patterns.some(pattern => pattern.test(toolName));
+    }
+    isAllowed(toolName) {
+        // Disallowed patterns take precedence
+        if (this.matchesPatterns(toolName, this.disallowedPatterns, this.disallowedExact)) {
+            return false;
+        }
+        // If no allowed patterns specified, allow all (except disallowed)
+        if (this.allowedPatterns.length === 0 && this.allowedExact.size === 0) {
+            return true;
+        }
+        // Check if matches any allowed pattern
+        return this.matchesPatterns(toolName, this.allowedPatterns, this.allowedExact);
+    }
+    filterTools(tools) {
+        return tools.filter(tool => this.isAllowed(tool.name));
+    }
+    addAllowed(toolName) {
+        if (toolName.includes('*')) {
+            const regexPattern = toolName
+                .replace(/[.+?^${}()|[\]\\]/g, '\\$&')
+                .replace(/\*/g, '.*');
+            this.allowedPatterns.push(new RegExp(`^${regexPattern}$`, 'i'));
+        }
+        else {
+            this.allowedExact.add(toolName);
+        }
+    }
+    addDisallowed(toolName) {
+        if (toolName.includes('*')) {
+            const regexPattern = toolName
+                .replace(/[.+?^${}()|[\]\\]/g, '\\$&')
+                .replace(/\*/g, '.*');
+            this.disallowedPatterns.push(new RegExp(`^${regexPattern}$`, 'i'));
+        }
+        else {
+            this.disallowedExact.add(toolName);
+        }
+    }
+    removeAllowed(toolName) {
+        this.allowedExact.delete(toolName);
+        // Note: Can't easily remove regex patterns, would need to track original strings
+    }
+    removeDisallowed(toolName) {
+        this.disallowedExact.delete(toolName);
+        // Note: Can't easily remove regex patterns, would need to track original strings
+    }
+    getAllowedList() {
+        const allowed = Array.from(this.allowedExact);
+        return allowed.length > 0 || this.allowedPatterns.length > 0 ? allowed : null;
+    }
+    getDisallowedList() {
+        return Array.from(this.disallowedExact);
+    }
+}
+exports.ToolFilter = ToolFilter;

package/dist/types/config.d.ts

@@ -0,0 +1,56 @@
+export interface MCPServerConfig {
+    command: string;
+    args: string[];
+    env?: Record<string, string | undefined>;
+}
+export interface DynamicCommandExec {
+    path: string;
+    args: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+    expect?: 'json' | 'text';
+    stream?: boolean;
+}
+export interface DynamicCommand {
+    name: string;
+    description: string;
+    parameters: {
+        type: 'object';
+        properties: Record<string, any>;
+        required?: string[];
+    };
+    exec: DynamicCommandExec;
+}
+export interface DynamicServerConfig {
+    commands: DynamicCommand[];
+}
+export type MCPServerConfigType = MCPServerConfig | DynamicServerConfig;
+export interface MCPConfig {
+    mcpServers: Record<string, MCPServerConfigType>;
+}
+export interface MCPPluginOptions {
+    configPath?: string;
+    configString?: string;
+    servers?: Record<string, MCPServerConfigType>;
+    allowedTools?: string[];
+    disallowedTools?: string[];
+    permissionPromptTool?: string;
+    quiet?: boolean;
+}
+export interface ParsedPermissionTool {
+    serverName: string;
+    toolName: string;
+    originalName: string;
+}
+export interface PermissionRequest {
+    tool_name: string;
+    input: any;
+    tool_use_id: string;
+    [key: string]: any;
+}
+export interface PermissionResponse {
+    behavior: 'allow' | 'deny';
+    updatedInput?: any;
+}
+//# sourceMappingURL=config.d.ts.map

package/dist/types/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/types/config.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;CAC1C;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE;QACV,IAAI,EAAE,QAAQ,CAAC;QACf,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAChC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KACrB,CAAC;IACF,IAAI,EAAE,kBAAkB,CAAC;CAC1B;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,cAAc,EAAE,CAAC;CAC5B;AAED,MAAM,MAAM,mBAAmB,GAAG,eAAe,GAAG,mBAAmB,CAAC;AAExE,MAAM,WAAW,SAAS;IACxB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;CACjD;AAED,MAAM,WAAW,gBAAgB;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IAC9C,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,GAAG,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,OAAO,GAAG,MAAM,CAAC;IAC3B,YAAY,CAAC,EAAE,GAAG,CAAC;CACpB"}

package/dist/types/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@majkapp/majk-chat-mcp",
+  "version": "1.0.0",
+  "description": "MCP (Model Context Protocol) plugin for majk-chat",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "majk-mcp-server": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src --ext .ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "majk-chat",
+    "ai",
+    "llm",
+    "tools"
+  ],
+  "author": "Jules White",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.17.4",
+    "@majkapp/majk-chat-core": "file:../majk-chat-core",
+    "commander": "^12.0.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.19",
+    "@typescript-eslint/eslint-plugin": "^7.0.1",
+    "@typescript-eslint/parser": "^7.0.1",
+    "eslint": "^8.56.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
+  },
+  "peerDependencies": {
+    "@majkapp/majk-chat-core": "^1.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/**/*",
+    "README.md"
+  ]
+}