kadins-personal-mcp 1.0.0 → 1.0.1

package/PUBLISHING.md

@@ -1,43 +0,0 @@
-# Publishing Kadins Personal MCP
-
-## Prerequisites
-
-1. Make sure you have an npm account at https://www.npmjs.com/
-2. Ensure you're logged in to npm: `npm login`
-
-## To Publish
-
-1. Update the version in package.json if needed: `npm version patch` (or minor/major)
-2. Run tests to make sure everything works: `npm test`
-3. Build the project: `npm run build`
-4. Publish to npm: `npm publish`
-
-## Local Installation for Testing
-
-To install locally for testing:
-
-```bash
-npm install -g .
-```
-
-Or to link for development:
-
-```bash
-npm link
-```
-
-## Verification
-
-After publishing, you can install your package globally:
-
-```bash
-npm install -g kadins-personal-mcp
-```
-
-And then run it:
-
-```bash
-kadins-personal-mcp
-```
-
-The server will start and be available for MCP-compatible clients.

package/gitignore

@@ -1,7 +0,0 @@
-dist/
-node_modules/
-
-# System
-.DS_Store
-.idea/
-.vscode/

package/src/index.ts

@@ -1,63 +0,0 @@
-#!/usr/bin/env node
-
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-import { loadTools } from "./toolLoader.js";
-
-const packageJson = require("../package.json") as any;
-
-// Create a new MCP server
-const server = new McpServer(
-  {
-    name: packageJson.name,
-    version: packageJson.version,
-  },
-  {
-    instructions:
-      "These tools communicate with a reference Model Context Protocol (MCP) server.",
-  }
-);
-
-// Implement the ping_pong tool
-server.tool(
-  "ping_pong",
-  "Ping the server and receive a pong back",
-  {},
-  async () => {
-    return {
-      content: [{ type: "text", text: "pong" }],
-    };
-  }
-);
-
-// Implement the echo tool
-server.tool(
-  "echo",
-  "Send a message to the server and receive the message back",
-  { message: z.string() },
-  async (params) => {
-    return {
-      content: [{ type: "text", text: params.message }],
-    };
-  }
-);
-
-// Start the server
-async function run() {
-  try {
-    // Load tools from the tools directory
-    await loadTools(server);
-
-    // Use stdio for transport
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    // Since stdout is used for MCP messages, use stderr for logging
-    console.error("MCP server connected via stdio");
-  } catch (error) {
-    console.error("Error starting MCP server:", error);
-    process.exit(1);
-  }
-}
-
-run();

package/src/simple.test.ts

@@ -1,9 +0,0 @@
-import { test } from '@jest/globals';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-
-// Simple test to verify the tool loader can be imported without errors
-test('toolLoader can be imported', async () => {
-  // We'll just check that the module can be imported without errors
-  // Since the actual loading depends on the file system, we'll do a basic import test
-  expect(typeof (await import('./toolLoader.js'))).toBe('object');
-});

package/src/toolLoader.ts

@@ -1,59 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-
-// Define the interface for tool files
-interface ToolDefinition {
-  name: string;
-  description: string;
-  parameters: Record<string, any>;
-  handler: (params: any) => Promise<any>;
-}
-
-// Validates that a loaded module has the required tool properties
-function isValidTool(module: any): module is ToolDefinition {
-  return (
-    typeof module.name === 'string' &&
-    typeof module.description === 'string' &&
-    typeof module.parameters === 'object' &&
-    typeof module.handler === 'function'
-  );
-}
-
-// Load and register all tools from the tools directory
-export async function loadTools(server: McpServer) {
-  const toolsDir = path.join(process.cwd(), 'tools');
-  
-  if (!fs.existsSync(toolsDir)) {
-    console.error(`Tools directory does not exist: ${toolsDir}`);
-    return;
-  }
-
-  const files = fs.readdirSync(toolsDir);
-  
-  for (const file of files) {
-    if (file.endsWith('.ts') || file.endsWith('.js')) {
-      try {
-        // Use dynamic import to load the tool file
-        const modulePath = path.join(toolsDir, file);
-        const module = await import(modulePath);
-        
-        if (isValidTool(module)) {
-          // Register the tool with the MCP server
-          server.tool(
-            module.name,
-            module.description,
-            module.parameters,
-            module.handler
-          );
-          
-          console.error(`Registered tool: ${module.name}`);
-        } else {
-          console.error(`Invalid tool format in file: ${file}. Required exports: name, description, parameters, handler`);
-        }
-      } catch (error) {
-        console.error(`Error loading tool from file ${file}:`, error);
-      }
-    }
-  }
-}

package/tools/calculator.ts

@@ -1,40 +0,0 @@
-import { z } from "zod";
-
-export const name = "calculator";
-export const description = "Perform basic mathematical calculations";
-export const parameters = {
-  operation: z.enum(["add", "subtract", "multiply", "divide"]).describe("The mathematical operation to perform"),
-  a: z.number().describe("The first operand"),
-  b: z.number().describe("The second operand")
-};
-export const handler = async (params: { operation: string; a: number; b: number }) => {
-  let result: number;
-  
-  switch (params.operation) {
-    case "add":
-      result = params.a + params.b;
-      break;
-    case "subtract":
-      result = params.a - params.b;
-      break;
-    case "multiply":
-      result = params.a * params.b;
-      break;
-    case "divide":
-      if (params.b === 0) {
-        return {
-          content: [{ type: "text", text: "Error: Division by zero is not allowed" }]
-        };
-      }
-      result = params.a / params.b;
-      break;
-    default:
-      return {
-        content: [{ type: "text", text: `Error: Unknown operation ${params.operation}` }]
-      };
-  }
-  
-  return {
-    content: [{ type: "text", text: `Result: ${params.a} ${params.operation} ${params.b} = ${result}` }]
-  };
-};

package/tools/currentTime.ts

@@ -1,11 +0,0 @@
-import { z } from "zod";
-
-export const name = "get_current_time";
-export const description = "Get the current date and time";
-export const parameters = {};
-export const handler = async () => {
-  const now = new Date();
-  return {
-    content: [{ type: "text", text: `Current date and time: ${now.toString()}` }]
-  };
-};

package/tools/directoryCreate.ts

@@ -1,43 +0,0 @@
-import { z } from "zod";
-
-export const name = "directory_create";
-export const description = "Create a new directory";
-export const parameters = {
-  path: z.string().describe("The path to the directory to create"),
-  recursive: z.boolean().describe("Whether to create parent directories if they don't exist").optional().default(true)
-};
-export const handler = async (params: { path: string; recursive: boolean }) => {
-  try {
-    const fs = await import("fs");
-    const path = await import("path");
-    
-    // Resolve the path relative to the current working directory
-    const resolvedPath = path.resolve(params.path);
-    
-    // Check if the path is within the current working directory to prevent path traversal
-    const cwd = process.cwd();
-    if (!resolvedPath.startsWith(cwd)) {
-      return {
-        content: [{ type: "text", text: "Error: Path traversal is not allowed" }]
-      };
-    }
-    
-    // Check if directory already exists
-    if (fs.existsSync(resolvedPath)) {
-      return {
-        content: [{ type: "text", text: `Error: Directory already exists: ${params.path}` }]
-      };
-    }
-    
-    // Create the directory
-    fs.mkdirSync(resolvedPath, { recursive: params.recursive });
-    
-    return {
-      content: [{ type: "text", text: `Successfully created directory: ${params.path}` }]
-    };
-  } catch (error) {
-    return {
-      content: [{ type: "text", text: `Error creating directory: ${(error as Error).message}` }]
-    };
-  }
-};

package/tools/directoryList.ts

@@ -1,70 +0,0 @@
-import { z } from "zod";
-
-export const name = "directory_list";
-export const description = "List directory contents with details (size, type, etc.)";
-export const parameters = {
-  directory: z.string().describe("The directory to list").optional().default("."),
-  showHidden: z.boolean().describe("Whether to show hidden files/directories").optional().default(false)
-};
-export const handler = async (params: { directory: string; showHidden?: boolean }) => {
-  try {
-    const fs = await import("fs");
-    const path = await import("path");
-    
-    const searchDir = params.directory || ".";
-    const resolvedDir = path.resolve(searchDir);
-    
-    // Check if the directory is within the current working directory to prevent path traversal
-    const cwd = process.cwd();
-    if (!resolvedDir.startsWith(cwd)) {
-      return {
-        content: [{ type: "text", text: "Error: Directory traversal is not allowed" }]
-      };
-    }
-    
-    if (!fs.existsSync(resolvedDir)) {
-      return {
-        content: [{ type: "text", text: `Error: Directory does not exist: ${resolvedDir}` }]
-      };
-    }
-    
-    if (!fs.statSync(resolvedDir).isDirectory()) {
-      return {
-        content: [{ type: "text", text: `Error: Path is not a directory: ${resolvedDir}` }]
-      };
-    }
-    
-    const items = fs.readdirSync(resolvedDir);
-    const results: string[] = [];
-    
-    for (const item of items) {
-      // Skip hidden files if showHidden is false
-      if (!params.showHidden && item.startsWith('.')) {
-        continue;
-      }
-      
-      const itemPath = path.join(resolvedDir, item);
-      const stat = fs.statSync(itemPath);
-      
-      let type = stat.isDirectory() ? "DIR" : "FILE";
-      let size = stat.isDirectory() ? "-" : `${stat.size} bytes`;
-      let permissions = stat.mode.toString(8).slice(-3);
-      
-      results.push(`${type} ${permissions} ${size} ${item}`);
-    }
-    
-    if (results.length === 0) {
-      return {
-        content: [{ type: "text", text: `Directory is empty: ${params.directory || "."}` }]
-      };
-    }
-    
-    return {
-      content: [{ type: "text", text: `Contents of ${params.directory || "."}:\n${results.join("\n")}` }]
-    };
-  } catch (error) {
-    return {
-      content: [{ type: "text", text: `Error listing directory: ${(error as Error).message}` }]
-    };
-  }
-};

package/tools/echo.ts

@@ -1,12 +0,0 @@
-import { z } from "zod";
-
-export const name = "file_echo";
-export const description = "Send a message to the server and receive the message back (file-based tool)";
-export const parameters = {
-  message: z.string().describe("The message to echo back")
-};
-export const handler = async (params: { message: string }) => {
-  return {
-    content: [{ type: "text", text: params.message }]
-  };
-};

package/tools/fileCopy.ts

@@ -1,55 +0,0 @@
-import { z } from "zod";
-
-export const name = "file_copy";
-export const description = "Copy a file from one location to another";
-export const parameters = {
-  source: z.string().describe("The path to the source file"),
-  destination: z.string().describe("The path to the destination file")
-};
-export const handler = async (params: { source: string; destination: string }) => {
-  try {
-    const fs = await import("fs");
-    const path = await import("path");
-    
-    // Resolve paths relative to the current working directory
-    const resolvedSource = path.resolve(params.source);
-    const resolvedDestination = path.resolve(params.destination);
-    
-    // Check if paths are within the current working directory to prevent path traversal
-    const cwd = process.cwd();
-    if (!resolvedSource.startsWith(cwd) || !resolvedDestination.startsWith(cwd)) {
-      return {
-        content: [{ type: "text", text: "Error: Path traversal is not allowed" }]
-      };
-    }
-    
-    if (!fs.existsSync(resolvedSource)) {
-      return {
-        content: [{ type: "text", text: `Error: Source file does not exist: ${params.source}` }]
-      };
-    }
-    
-    if (fs.statSync(resolvedSource).isDirectory()) {
-      return {
-        content: [{ type: "text", text: `Error: Source path is a directory, not a file: ${params.source}` }]
-      };
-    }
-    
-    // Create destination directory if it doesn't exist
-    const destDir = path.dirname(resolvedDestination);
-    if (!fs.existsSync(destDir)) {
-      fs.mkdirSync(destDir, { recursive: true });
-    }
-    
-    // Copy the file
-    fs.copyFileSync(resolvedSource, resolvedDestination);
-    
-    return {
-      content: [{ type: "text", text: `Successfully copied file from ${params.source} to ${params.destination}` }]
-    };
-  } catch (error) {
-    return {
-      content: [{ type: "text", text: `Error copying file: ${(error as Error).message}` }]
-    };
-  }
-};

package/tools/fileDelete.ts

@@ -1,48 +0,0 @@
-import { z } from "zod";
-
-export const name = "file_delete";
-export const description = "Delete a specified file";
-export const parameters = {
-  path: z.string().describe("The path to the file to delete")
-};
-export const handler = async (params: { path: string }) => {
-  try {
-    const fs = await import("fs");
-    const path = await import("path");
-    
-    // Resolve the path relative to the current working directory
-    const resolvedPath = path.resolve(params.path);
-    
-    // Check if the path is within the current working directory to prevent path traversal
-    const cwd = process.cwd();
-    if (!resolvedPath.startsWith(cwd)) {
-      return {
-        content: [{ type: "text", text: "Error: Path traversal is not allowed" }]
-      };
-    }
-    
-    if (!fs.existsSync(resolvedPath)) {
-      return {
-        content: [{ type: "text", text: `Error: File does not exist: ${params.path}` }]
-      };
-    }
-    
-    const stat = fs.statSync(resolvedPath);
-    if (stat.isDirectory()) {
-      return {
-        content: [{ type: "text", text: `Error: Path is a directory, not a file: ${params.path}` }]
-      };
-    }
-    
-    // Delete the file
-    fs.unlinkSync(resolvedPath);
-    
-    return {
-      content: [{ type: "text", text: `Successfully deleted file: ${params.path}` }]
-    };
-  } catch (error) {
-    return {
-      content: [{ type: "text", text: `Error deleting file: ${(error as Error).message}` }]
-    };
-  }
-};

package/tools/fileList.ts

@@ -1,88 +0,0 @@
-import { z } from "zod";
-
-export const name = "file_list";
-export const description = "List files in a directory with optional filtering";
-export const parameters = {
-  directory: z.string().describe("The directory to list").optional().default("."),
-  filter: z.string().describe("Optional filter pattern to match files").optional(),
-  recursive: z.boolean().describe("Whether to list files recursively").optional().default(false)
-};
-export const handler = async (params: { directory: string; filter?: string; recursive?: boolean }) => {
-  try {
-    const fs = await import("fs");
-    const path = await import("path");
-    
-    const searchDir = params.directory || ".";
-    const resolvedDir = path.resolve(searchDir);
-    
-    // Check if the directory is within the current working directory to prevent path traversal
-    const cwd = process.cwd();
-    if (!resolvedDir.startsWith(cwd)) {
-      return {
-        content: [{ type: "text", text: "Error: Directory traversal is not allowed" }]
-      };
-    }
-    
-    if (!fs.existsSync(resolvedDir)) {
-      return {
-        content: [{ type: "text", text: `Error: Directory does not exist: ${resolvedDir}` }]
-      };
-    }
-    
-    if (!fs.statSync(resolvedDir).isDirectory()) {
-      return {
-        content: [{ type: "text", text: `Error: Path is not a directory: ${resolvedDir}` }]
-      };
-    }
-    
-    const results: string[] = [];
-    
-    function listDirectory(dir: string, isRoot: boolean = true) {
-      const items = fs.readdirSync(dir);
-      
-      for (const item of items) {
-        const itemPath = path.join(dir, item);
-        const relativePath = path.relative(resolvedDir, itemPath);
-        
-        // Apply filter if provided
-        if (params.filter && !item.includes(params.filter)) {
-          continue;
-        }
-        
-        // Skip node_modules and other common directories when not in recursive mode
-        if (!params.recursive && !isRoot && (item === "node_modules" || item.startsWith("."))) {
-          continue;
-        }
-        
-        const stat = fs.statSync(itemPath);
-        
-        if (stat.isDirectory()) {
-          if (params.recursive && item !== "node_modules" && !item.startsWith(".")) {
-            results.push(`${relativePath}/ (directory)`);
-            listDirectory(itemPath, false);
-          } else if (!params.recursive) {
-            results.push(`${relativePath}/ (directory)`);
-          }
-        } else {
-          results.push(`${relativePath} (${stat.size} bytes)`);
-        }
-      }
-    }
-    
-    listDirectory(resolvedDir);
-    
-    if (results.length === 0) {
-      return {
-        content: [{ type: "text", text: `No files found in directory: ${resolvedDir}` }]
-      };
-    }
-    
-    return {
-      content: [{ type: "text", text: `Files in ${params.directory || "."}:\n${results.join("\n")}` }]
-    };
-  } catch (error) {
-    return {
-      content: [{ type: "text", text: `Error listing files: ${(error as Error).message}` }]
-    };
-  }
-};

package/tools/fileMove.ts

@@ -1,62 +0,0 @@
-import { z } from "zod";
-
-export const name = "file_move";
-export const description = "Move/rename a file";
-export const parameters = {
-  source: z.string().describe("The path to the source file"),
-  destination: z.string().describe("The path to the destination file")
-};
-export const handler = async (params: { source: string; destination: string }) => {
-  try {
-    const fs = await import("fs");
-    const path = await import("path");
-    
-    // Resolve paths relative to the current working directory
-    const resolvedSource = path.resolve(params.source);
-    const resolvedDestination = path.resolve(params.destination);
-    
-    // Check if paths are within the current working directory to prevent path traversal
-    const cwd = process.cwd();
-    if (!resolvedSource.startsWith(cwd) || !resolvedDestination.startsWith(cwd)) {
-      return {
-        content: [{ type: "text", text: "Error: Path traversal is not allowed" }]
-      };
-    }
-    
-    if (!fs.existsSync(resolvedSource)) {
-      return {
-        content: [{ type: "text", text: `Error: Source file does not exist: ${params.source}` }]
-      };
-    }
-    
-    if (fs.statSync(resolvedSource).isDirectory()) {
-      return {
-        content: [{ type: "text", text: `Error: Source path is a directory, not a file: ${params.source}` }]
-      };
-    }
-    
-    // Check if destination already exists
-    if (fs.existsSync(resolvedDestination)) {
-      return {
-        content: [{ type: "text", text: `Error: Destination file already exists: ${params.destination}` }]
-      };
-    }
-    
-    // Create destination directory if it doesn't exist
-    const destDir = path.dirname(resolvedDestination);
-    if (!fs.existsSync(destDir)) {
-      fs.mkdirSync(destDir, { recursive: true });
-    }
-    
-    // Move the file (rename it)
-    fs.renameSync(resolvedSource, resolvedDestination);
-    
-    return {
-      content: [{ type: "text", text: `Successfully moved file from ${params.source} to ${params.destination}` }]
-    };
-  } catch (error) {
-    return {
-      content: [{ type: "text", text: `Error moving file: ${(error as Error).message}` }]
-    };
-  }
-};

package/tools/filePermissions.ts

@@ -1,50 +0,0 @@
-import { z } from "zod";
-
-export const name = "file_permissions";
-export const description = "Change file permissions";
-export const parameters = {
-  path: z.string().describe("The path to the file"),
-  permissions: z.string().describe("The new permissions in octal format (e.g., '755', '644')")
-};
-export const handler = async (params: { path: string; permissions: string }) => {
-  try {
-    const fs = await import("fs");
-    const path = await import("path");
-    
-    // Resolve the path relative to the current working directory
-    const resolvedPath = path.resolve(params.path);
-    
-    // Check if the path is within the current working directory to prevent path traversal
-    const cwd = process.cwd();
-    if (!resolvedPath.startsWith(cwd)) {
-      return {
-        content: [{ type: "text", text: "Error: Path traversal is not allowed" }]
-      };
-    }
-    
-    if (!fs.existsSync(resolvedPath)) {
-      return {
-        content: [{ type: "text", text: `Error: File does not exist: ${params.path}` }]
-      };
-    }
-    
-    // Validate permissions format (should be 3 or 4 digits)
-    if (!/^[0-7]{3,4}$/.test(params.permissions)) {
-      return {
-        content: [{ type: "text", text: `Error: Invalid permissions format. Use octal format like '755' or '644'.` }]
-      };
-    }
-    
-    // Change file permissions
-    const permissionsNum = parseInt(params.permissions, 8);
-    fs.chmodSync(resolvedPath, permissionsNum);
-    
-    return {
-      content: [{ type: "text", text: `Successfully changed permissions of ${params.path} to ${params.permissions}` }]
-    };
-  } catch (error) {
-    return {
-      content: [{ type: "text", text: `Error changing permissions: ${(error as Error).message}` }]
-    };
-  }
-};