kadins-personal-mcp 1.0.0

package/PUBLISHING.md

@@ -0,0 +1,43 @@
+# 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/README.md

@@ -0,0 +1,101 @@
+# Kadins Personal MCP Server
+
+Kadin's Personal Model Context Protocol (MCP) Server with comprehensive file system and command tools.
+
+## Overview
+
+This MCP server provides a wide range of tools to interact with your system, including:
+- File system operations (search, read, write, copy, move, delete, etc.)
+- Command execution capabilities
+- System information tools
+- And more!
+
+## Installation
+
+```bash
+npm install -g kadins-personal-mcp
+```
+
+## Usage
+
+To start the MCP server:
+
+```bash
+kadins-personal-mcp
+```
+
+Or for development:
+
+```bash
+npm run dev
+```
+
+## Available Tools
+
+### File System Tools
+- `file_search`: Search for files by name or content
+- `file_write`: Write content to a file
+- `file_list`: List files in a directory
+- `file_delete`: Delete a specified file
+- `file_copy`: Copy a file from one location to another
+- `file_move`: Move or rename a file
+- `file_permissions`: Change file permissions
+- `directory_create`: Create a new directory
+- `directory_list`: List directory contents with details
+
+### System Tools
+- `run_command`: Execute shell commands on the system
+- `read_file`: Read the contents of a file
+- `calculator`: Perform basic mathematical calculations
+- `get_current_time`: Get the current date and time
+- `file_echo`: Echo messages back
+
+## Configuration
+
+The server can be configured to work with various MCP-compatible clients like Cursor, Claude Desktop, and Windsurf.
+
+To configure your MCP client, add the following entry to your MCP configuration file (e.g., `~/.cursor/mcp.json`, `~/.codeium/windsurf/mcp_config.json`, or Claude Desktop config):
+
+```json
+{
+  "mcpServers": {
+    "kadins-personal-mcp": {
+      "command": "node",
+      "args": ["/path/to/kadins-personal-mcp/dist/index.js"]
+    }
+  }
+}
+```
+
+Replace `/path/to/kadins-personal-mcp/dist/index.js` with the actual path to the built index.js file in your installation.
+
+For Claude Desktop, the configuration file is typically located at:
+`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS
+
+For Cursor, the configuration file is typically located at:
+`~/.cursor/mcp.json`
+
+For Windsurf, the configuration file is typically located at:
+`~/.codeium/windsurf/mcp_config.json`
+
+## Security
+
+This server includes security measures to prevent path traversal and other potential security issues. However, please be cautious when using tools that execute commands or modify files.
+
+## Development
+
+To build the server:
+
+```bash
+npm run build
+```
+
+To run tests:
+
+```bash
+npm run test
+```
+
+## License
+
+MIT

package/dist/chunk-T6KZEVGN.js

@@ -0,0 +1,45 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// src/toolLoader.ts
+import fs from "fs";
+import path from "path";
+function isValidTool(module) {
+  return typeof module.name === "string" && typeof module.description === "string" && typeof module.parameters === "object" && typeof module.handler === "function";
+}
+async function loadTools(server) {
+  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 {
+        const modulePath = path.join(toolsDir, file);
+        const module = await import(modulePath);
+        if (isValidTool(module)) {
+          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);
+      }
+    }
+  }
+}
+
+export {
+  __commonJS,
+  loadTools
+};

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+import {
+  __commonJS,
+  loadTools
+} from "./chunk-T6KZEVGN.js";
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports, module) {
+    module.exports = {
+      name: "kadins-personal-mcp",
+      version: "1.0.0",
+      description: "Kadin's Personal MCP Server with comprehensive file system and command tools",
+      author: "Kadin",
+      license: "MIT",
+      type: "module",
+      bin: {
+        "kadins-personal-mcp": "./kadins-personal-mcp.js"
+      },
+      scripts: {
+        dev: "node --loader ts-node/esm src/index.ts",
+        build: "tsup src/index.ts src/toolLoader.ts --format esm --dts --clean",
+        test: "NODE_OPTIONS=--experimental-vm-modules jest",
+        "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch"
+      },
+      dependencies: {
+        "@modelcontextprotocol/sdk": "^1.8.0",
+        zod: "^3.24.2"
+      },
+      devDependencies: {
+        "@types/jest": "^29.5.14",
+        "@types/node": "^22.13.13",
+        jest: "^29.7.0",
+        "ts-jest": "^29.3.1",
+        "ts-node": "^10.9.2",
+        tsup: "^8.4.0",
+        typescript: "^5.8.2"
+      },
+      jest: {
+        preset: "ts-jest/presets/default-esm",
+        testEnvironment: "node",
+        extensionsToTreatAsEsm: [".ts"],
+        moduleNameMapper: {
+          "^(\\.{1,2}/.*)\\.js$": "$1"
+        },
+        transform: {
+          "^.+\\.tsx?$": [
+            "ts-jest",
+            {
+              useESM: true
+            }
+          ]
+        }
+      }
+    };
+  }
+});
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+var packageJson = require_package();
+var server = new McpServer(
+  {
+    name: packageJson.name,
+    version: packageJson.version
+  },
+  {
+    instructions: "These tools communicate with a reference Model Context Protocol (MCP) server."
+  }
+);
+server.tool(
+  "ping_pong",
+  "Ping the server and receive a pong back",
+  {},
+  async () => {
+    return {
+      content: [{ type: "text", text: "pong" }]
+    };
+  }
+);
+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 }]
+    };
+  }
+);
+async function run() {
+  try {
+    await loadTools(server);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("MCP server connected via stdio");
+  } catch (error) {
+    console.error("Error starting MCP server:", error);
+    process.exit(1);
+  }
+}
+run();

package/dist/toolLoader.d.ts

@@ -0,0 +1,5 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+declare function loadTools(server: McpServer): Promise<void>;
+
+export { loadTools };

package/dist/toolLoader.js

@@ -0,0 +1,6 @@
+import {
+  loadTools
+} from "./chunk-T6KZEVGN.js";
+export {
+  loadTools
+};

package/gitignore

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

package/kadins-personal-mcp.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+// kadins-personal-mcp.js - Entry point for Kadins Personal MCP Server
+
+import './dist/index.js';

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "kadins-personal-mcp",
+  "version": "1.0.0",
+  "description": "Kadin's Personal MCP Server with comprehensive file system and command tools",
+  "author": "Kadin",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "kadins-personal-mcp": "./kadins-personal-mcp.js"
+  },
+  "scripts": {
+    "dev": "node --loader ts-node/esm src/index.ts",
+    "build": "tsup src/index.ts src/toolLoader.ts --format esm --dts --clean",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest",
+    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.8.0",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.13.13",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.3.1",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.2"
+  },
+  "jest": {
+    "preset": "ts-jest/presets/default-esm",
+    "testEnvironment": "node",
+    "extensionsToTreatAsEsm": [".ts"],
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.js$": "$1"
+    },
+    "transform": {
+      "^.+\\.tsx?$": [
+        "ts-jest",
+        {
+          "useESM": true
+        }
+      ]
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,63 @@
+#!/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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,70 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,88 @@
+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

@@ -0,0 +1,62 @@
+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

@@ -0,0 +1,50 @@
+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}` }]
+    };
+  }
+};

package/tools/fileSearch.ts

@@ -0,0 +1,88 @@
+import { z } from "zod";
+
+export const name = "file_search";
+export const description = "Search for files by name, content, or pattern in a directory";
+export const parameters = {
+  pattern: z.string().describe("The pattern to search for (file name or content)"),
+  directory: z.string().describe("The directory to search in").optional().default("."),
+  searchInContent: z.boolean().describe("Whether to search in file content (true) or just filenames (false)").optional().default(false)
+};
+export const handler = async (params: { pattern: string; directory: string; searchInContent: 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 searchRecursive(dir: string) {
+      const items = fs.readdirSync(dir);
+      
+      for (const item of items) {
+        const itemPath = path.join(dir, item);
+        const stat = fs.statSync(itemPath);
+        
+        if (stat.isDirectory()) {
+          // Skip node_modules and other common directories that shouldn't be searched
+          if (item !== "node_modules" && !item.startsWith(".")) {
+            searchRecursive(itemPath);
+          }
+        } else {
+          // Check filename match
+          if (item.includes(params.pattern)) {
+            results.push(itemPath);
+          }
+          // Check content match if requested
+          else if (params.searchInContent) {
+            try {
+              const content = fs.readFileSync(itemPath, "utf-8");
+              if (content.includes(params.pattern)) {
+                results.push(itemPath);
+              }
+            } catch (e) {
+              // Skip binary files or files that can't be read
+            }
+          }
+        }
+      }
+    }
+    
+    searchRecursive(resolvedDir);
+    
+    if (results.length === 0) {
+      return {
+        content: [{ type: "text", text: `No files found matching pattern: ${params.pattern}` }]
+      };
+    }
+    
+    return {
+      content: [{ type: "text", text: `Found ${results.length} file(s):\n${results.join("\n")}` }]
+    };
+  } catch (error) {
+    return {
+      content: [{ type: "text", text: `Error searching files: ${(error as Error).message}` }]
+    };
+  }
+};

package/tools/fileWrite.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+
+export const name = "file_write";
+export const description = "Write content to a file (with safety checks to prevent overwrites)";
+export const parameters = {
+  path: z.string().describe("The path to the file to write"),
+  content: z.string().describe("The content to write to the file"),
+  overwrite: z.boolean().describe("Whether to overwrite an existing file").optional().default(false)
+};
+export const handler = async (params: { path: string; content: string; overwrite: 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 file exists and overwrite is not allowed
+    if (fs.existsSync(resolvedPath) && !params.overwrite) {
+      return {
+        content: [{ type: "text", text: `Error: File already exists at ${params.path}. Use overwrite=true to overwrite.` }]
+      };
+    }
+    
+    // Create directory if it doesn't exist
+    const dir = path.dirname(resolvedPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    
+    // Write the content to the file
+    fs.writeFileSync(resolvedPath, params.content, "utf-8");
+    
+    return {
+      content: [{ type: "text", text: `Successfully wrote ${params.content.length} characters to ${params.path}` }]
+    };
+  } catch (error) {
+    return {
+      content: [{ type: "text", text: `Error writing file: ${(error as Error).message}` }]
+    };
+  }
+};

package/tools/readFile.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+
+export const name = "read_file";
+export const description = "Read the contents of a file";
+export const parameters = {
+  path: z.string().describe("The path to the file to read")
+};
+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 content = fs.readFileSync(resolvedPath, "utf-8");
+    return {
+      content: [{ type: "text", text: content }]
+    };
+  } catch (error) {
+    return {
+      content: [{ type: "text", text: `Error reading file: ${error.message}` }]
+    };
+  }
+};

package/tools/runCommand.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+
+export const name = "run_command";
+export const description = "Execute a shell command on the system";
+export const parameters = {
+  command: z.string().describe("The shell command to execute")
+};
+export const handler = async (params: { command: string }) => {
+  try {
+    // Dynamically import child_process
+    const { exec } = await import("child_process");
+    const util = await import("util");
+    
+    // Use util.promisify to convert exec to a promise-based function
+    const execPromise = util.promisify(exec);
+    
+    // Execute the command with a timeout for safety
+    const { stdout, stderr } = await Promise.race([
+      execPromise(params.command),
+      new Promise((_, reject) => 
+        setTimeout(() => reject(new Error('Command timed out after 10 seconds')), 10000)
+      )
+    ]);
+    
+    // Return both stdout and stderr
+    return {
+      content: [
+        { type: "text", text: `Command: ${params.command}\n\nOutput:\n${stdout || stderr || 'Command executed successfully with no output'}` }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        { type: "text", text: `Error executing command: ${params.command}\n\nError: ${(error as Error).message}` }
+      ]
+    };
+  }
+};

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "esModuleInterop": true,
+    "isolatedModules": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "exclude": ["node_modules", "dist"],
+  "include": ["src/**/*", "package.json"]
+}