@naganpm/snowflake-mcp-server 1.0.2 → 1.0.6

package/README.md

@@ -22,6 +22,26 @@ npm install
 
 ## Configuration
 
+#### Approach1
+
+Note: If you are trying to configure MCP using continue.dev
+
+```
+mcpServers:
+  - name: snowflake MCP
+    command: npx
+    args:
+      - -y
+      - "@naganpm/snowflake-mcp-server@latest"
+    env:
+      SNOWFLAKE_ACCOUNT: <account-id>.us-east-2.aws
+      SNOWFLAKE_USERNAME: <your-username>
+      SNOWFLAKE_PASSWORD: <your-password>
+      SNOWFLAKE_WAREHOUSE: <warehouse-name>
+      SNOWFLAKE_DATABASE: <database-name>
+      SNOWFLAKE_SCHEMA: <schema-name>
+```
+#### Approach2
 1. Copy `.env.example` to `.env`:
 ```bash
 cp .env.example .env

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naganpm/snowflake-mcp-server",
-  "version": "1.0.2",
+  "version": "1.0.6",
   "description": "MCP server for Snowflake database integration",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -23,6 +23,11 @@
     "express",
     "typescript"
   ],
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "author": "",
   "license": "MIT",
   "dependencies": {
@@ -42,4 +47,4 @@
   "engines": {
     "node": ">=18.0.0"
   }
-}
+}

package/.continue/prompts/new-prompt.md

@@ -1,14 +0,0 @@
----
-name: Snowflake MCP
-description: Create a snowflake MCP
-invokable: true
----
-
-URL: https://bd50859.us-east-2.aws.snowflakecomputing.com/
-USERNAME: DEP_QA2
-PASSWORD: Depqa2222$
-
-### Instructions
-- Create a snowflake mcp server in current folder and I want to configure this MCP as npm package.
-- Use express.js and typescript preferrably.
-- You can refer to @naganpm/mysql-mcp-server npm package for reference.

package/.env.example

@@ -1,7 +0,0 @@
-SNOWFLAKE_ACCOUNT=your-account.region.cloud
-SNOWFLAKE_USERNAME=your-username
-SNOWFLAKE_PASSWORD=your-password
-SNOWFLAKE_WAREHOUSE=
-SNOWFLAKE_DATABASE=
-SNOWFLAKE_SCHEMA=
-PORT=3000

package/Dockerfile

@@ -1,21 +0,0 @@
-FROM node:18-alpine
-
-WORKDIR /app
-
-# Copy package files
-COPY package*.json ./
-
-# Install dependencies
-RUN npm ci --only=production
-
-# Copy built files
-COPY dist ./dist
-
-# Expose port
-EXPOSE 3000
-
-# Set environment variable
-ENV NODE_ENV=production
-
-# Start the server
-CMD ["node", "dist/index.js"]

package/QUICKSTART.md

@@ -1,174 +0,0 @@
-# Snowflake MCP Server - Quick Start Guide
-
-## 🚀 Getting Started
-
-### 1. Install Dependencies
-```bash
-npm install
-```
-
-### 2. Configure Environment
-Edit `.env` file with your Snowflake credentials:
-```env
-SNOWFLAKE_ACCOUNT=your-account.region.cloud
-SNOWFLAKE_USERNAME=your-username
-SNOWFLAKE_PASSWORD=your-password
-SNOWFLAKE_WAREHOUSE=YOUR_WAREHOUSE    # Optional
-SNOWFLAKE_DATABASE=YOUR_DATABASE      # Optional
-SNOWFLAKE_SCHEMA=YOUR_SCHEMA          # Optional
-PORT=3000
-```
-
-### 3. Run the Server
-
-**Development Mode:**
-```bash
-npm run dev
-```
-
-**Production Mode:**
-```bash
-npm run build
-npm start
-```
-
-## 📡 API Endpoints
-
-| Method | Endpoint | Description |
-|--------|----------|-------------|
-| GET | `/health` | Health check |
-| GET | `/api/snowflake/status` | Connection status |
-| POST | `/api/snowflake/query` | Execute SQL query |
-| GET | `/api/snowflake/databases` | List databases |
-| GET | `/api/snowflake/schemas` | List schemas |
-| GET | `/api/snowflake/tables` | List tables |
-| GET | `/api/snowflake/tables/:name/describe` | Describe table |
-| GET | `/api/snowflake/warehouses` | List warehouses |
-| GET | `/api/snowflake/session` | Current session info |
-
-## 🧪 Testing
-
-### Using cURL
-```bash
-# Health check
-curl http://localhost:3000/health
-
-# Execute query
-curl -X POST http://localhost:3000/api/snowflake/query \
-  -H "Content-Type: application/json" \
-  -d '{"query": "SELECT CURRENT_DATE()"}'
-```
-
-### Using the test script
-```bash
-./test-api.sh
-```
-
-### Import Postman Collection
-Import `postman_collection.json` into Postman for easy testing.
-
-## 📦 NPM Package Usage
-
-After publishing to NPM, users can install:
-```bash
-npm install @naganpm/snowflake-mcp-server
-```
-
-Then use programmatically:
-```typescript
-import { SnowflakeService } from '@naganpm/snowflake-mcp-server';
-
-const service = SnowflakeService.getInstance();
-const result = await service.executeQuery('SELECT 1');
-```
-
-## 🐳 Docker Deployment
-
-```bash
-# Build and run with Docker Compose
-docker-compose up -d
-
-# Or build manually
-docker build -t snowflake-mcp .
-docker run -p 3000:3000 --env-file .env snowflake-mcp
-```
-
-## 📁 Project Structure
-
-```
-snowflake-mcp-server/
-├── src/
-│   ├── index.ts                    # Main server entry
-│   ├── services/
-│   │   └── snowflake.service.ts    # Snowflake SDK wrapper
-│   ├── routes/
-│   │   └── snowflake.routes.ts     # API routes
-│   └── middleware/
-│       └── error.middleware.ts     # Error handling
-├── dist/                           # Compiled JavaScript
-├── examples/                       # Usage examples
-├── package.json
-├── tsconfig.json
-├── .env                           # Environment config
-├── Dockerfile
-├── docker-compose.yml
-└── README.md
-```
-
-## 🔒 Security Notes
-
-- Never commit `.env` file to version control
-- Use environment variables for sensitive data
-- Consider using Snowflake key-pair authentication for production
-- Implement rate limiting for production use
-- Add authentication/authorization middleware
-
-## 🛠️ Development Commands
-
-| Command | Description |
-|---------|-------------|
-| `npm run dev` | Run in development mode |
-| `npm run build` | Build TypeScript to JavaScript |
-| `npm start` | Run production build |
-| `npm run watch` | Watch mode for development |
-| `npm run clean` | Clean dist folder |
-
-## 📝 Publishing to NPM
-
-1. Update version in `package.json`
-2. Build the project: `npm run build`
-3. Login to NPM: `npm login`
-4. Publish: `npm publish --access public`
-
-## 🤝 Contributing
-
-1. Fork the repository
-2. Create a feature branch
-3. Make your changes
-4. Submit a pull request
-
-## 📄 License
-
-MIT License - see LICENSE file for details
-
-## 🆘 Troubleshooting
-
-### Connection Issues
-- Verify Snowflake credentials in `.env`
-- Check network connectivity to Snowflake
-- Ensure account format is correct (account.region.cloud)
-
-### Build Issues
-- Clear node_modules: `rm -rf node_modules && npm install`
-- Clear dist: `npm run clean && npm run build`
-
-### Runtime Issues
-- Check logs for error messages
-- Verify environment variables are loaded
-- Test with simple queries first
-
-## 📚 Additional Resources
-
-- [Snowflake SDK Documentation](https://docs.snowflake.com/en/user-guide/nodejs-driver)
-- [Express.js Documentation](https://expressjs.com/)
-- [TypeScript Documentation](https://www.typescriptlang.org/)

package/SETUP_COMPLETE.md

@@ -1,226 +0,0 @@
-# Snowflake MCP Server - Complete Setup ✅
-
-## ✨ What Has Been Created
-
-A production-ready Snowflake MCP (Model Context Protocol) server configured as an NPM package with the following features:
-
-### 🎯 Core Features
-- **Express.js REST API** with TypeScript
-- **Snowflake SDK Integration** for database operations
-- **Singleton Pattern** for connection management
-- **Error Handling Middleware**
-- **CORS Support**
-- **Environment Configuration**
-- **Health Monitoring**
-
-### 📂 Project Structure
-```
-snowflake-mcp-server/
-├── src/
-│   ├── index.ts                      # Main server (Express app)
-│   ├── services/
-│   │   └── snowflake.service.ts      # Snowflake connection & queries
-│   ├── routes/
-│   │   └── snowflake.routes.ts       # API endpoints
-│   └── middleware/
-│       └── error.middleware.ts       # Error handling
-├── dist/                             # Compiled JavaScript
-├── examples/
-│   └── usage.ts                      # Usage examples
-├── node_modules/                     # Dependencies
-├── .env                              # Your Snowflake credentials
-├── .env.example                      # Template
-├── package.json                      # NPM configuration
-├── tsconfig.json                     # TypeScript config
-├── Dockerfile                        # Docker image
-├── docker-compose.yml                # Docker compose
-├── postman_collection.json           # API testing
-├── test-api.sh                       # Bash test script
-├── README.md                         # Full documentation
-├── QUICKSTART.md                     # Quick start guide
-└── LICENSE                           # MIT license
-```
-
-### 🔌 Available API Endpoints
-
-| Endpoint | Method | Description |
-|----------|--------|-------------|
-| `/health` | GET | Health check |
-| `/api/snowflake/status` | GET | Connection status |
-| `/api/snowflake/query` | POST | Execute SQL query |
-| `/api/snowflake/databases` | GET | List all databases |
-| `/api/snowflake/schemas` | GET | List schemas |
-| `/api/snowflake/tables` | GET | List tables |
-| `/api/snowflake/tables/:name/describe` | GET | Describe table structure |
-| `/api/snowflake/warehouses` | GET | List warehouses |
-| `/api/snowflake/session` | GET | Current session info |
-
-### 🔧 Configuration
-
-**Port:** 3000
-
-All credentials should be stored in `.env` file (not committed to git).
-
-See `.env.example` for configuration template.
-
-## 🚀 Quick Start Commands
-
-### 1. Development Mode
-```bash
-npm run dev
-# Server runs at: http://localhost:3000
-```
-
-### 2. Build for Production
-```bash
-npm run build
-```
-
-### 3. Run Production Build
-```bash
-npm start
-```
-
-### 4. Test the API
-```bash
-# Using curl
-curl http://localhost:3000/health
-
-# Using the test script
-./test-api.sh
-
-# Using Postman
-# Import postman_collection.json into Postman
-```
-
-## 📦 NPM Package Details
-
-- **Package Name:** `@naganpm/snowflake-mcp-server`
-- **Version:** 1.0.0
-- **Main Entry:** `dist/index.js`
-- **TypeScript Definitions:** `dist/index.d.ts`
-- **Binary:** `snowflake-mcp-server`
-
-### To Publish to NPM:
-```bash
-npm login
-npm publish --access public
-```
-
-## 🧪 Testing Examples
-
-### Test Health Check
-```bash
-curl http://localhost:3000/health
-```
-
-### Execute a Query
-```bash
-curl -X POST http://localhost:3000/api/snowflake/query \
-  -H "Content-Type: application/json" \
-  -d '{
-    "query": "SELECT CURRENT_DATE(), CURRENT_USER(), CURRENT_ROLE()"
-  }'
-```
-
-### List Databases
-```bash
-curl http://localhost:3000/api/snowflake/databases
-```
-
-### Get Session Info
-```bash
-curl http://localhost:3000/api/snowflake/session
-```
-
-## 🐳 Docker Deployment
-
-### Build and Run
-```bash
-docker-compose up -d
-```
-
-### Manual Docker Build
-```bash
-docker build -t snowflake-mcp .
-docker run -p 3000:3000 --env-file .env snowflake-mcp
-```
-
-## 📚 Key Dependencies
-
-- **express** ^4.18.2 - Web framework
-- **snowflake-sdk** ^1.11.0 - Snowflake database driver
-- **typescript** ^5.3.3 - Type safety
-- **dotenv** ^16.4.1 - Environment configuration
-- **cors** ^2.8.5 - CORS support
-
-## 🎓 Usage as NPM Package
-
-After installation:
-```typescript
-import { SnowflakeService } from '@naganpm/snowflake-mcp-server';
-
-// Get singleton instance
-const service = SnowflakeService.getInstance();
-
-// Execute queries
-const result = await service.executeQuery('SELECT * FROM my_table LIMIT 10');
-console.log(result.rows);
-
-// List databases
-const databases = await service.listDatabases();
-
-// Describe table
-const tableInfo = await service.describeTable('my_table');
-```
-
-## ✅ Verified Working
-
-- ✅ Server starts successfully
-- ✅ Health endpoint responds
-- ✅ Status endpoint works
-- ✅ TypeScript compiles without errors
-- ✅ All dependencies installed
-- ✅ Environment configuration loaded
-
-## 📖 Documentation Files
-
-- **README.md** - Comprehensive documentation
-- **QUICKSTART.md** - Quick start guide
-- **postman_collection.json** - Postman API collection
-- **examples/usage.ts** - Code examples
-- **test-api.sh** - Automated testing script
-
-## 🔐 Security Notes
-
-- `.env` file is in `.gitignore` (not committed)
-- Password stored only locally
-- Add authentication middleware for production
-- Consider using Snowflake key-pair auth for production
-- Implement rate limiting
-
-## 🛠️ Development Workflow
-
-1. **Make changes** in `src/` directory
-2. **Test** with `npm run dev`
-3. **Build** with `npm run build`
-4. **Deploy** with `npm start` or Docker
-
-## 📝 Next Steps
-
-1. Add your Snowflake warehouse, database, and schema to `.env` (optional)
-2. Start the server: `npm run dev`
-3. Test with Postman or curl
-4. Deploy to production or publish to NPM
-5. Add authentication/authorization if needed
-6. Set up CI/CD pipeline
-
-## 🎉 Success!
-
-Your Snowflake MCP server is ready to use! It's configured as a proper NPM package following the structure of `@naganpm/mysql-mcp-server`.
-
-Start the server with `npm run dev` and visit:
-- Health: http://localhost:3000/health
-- API Docs: See README.md for all endpoints
-
-Happy coding! 🚀

package/docker-compose.yml

@@ -1,16 +0,0 @@
-version: '3.8'
-
-services:
-  snowflake-mcp:
-    build: .
-    ports:
-      - "3000:3000"
-    environment:
-      - SNOWFLAKE_ACCOUNT=${SNOWFLAKE_ACCOUNT}
-      - SNOWFLAKE_USERNAME=${SNOWFLAKE_USERNAME}
-      - SNOWFLAKE_PASSWORD=${SNOWFLAKE_PASSWORD}
-      - SNOWFLAKE_WAREHOUSE=${SNOWFLAKE_WAREHOUSE}
-      - SNOWFLAKE_DATABASE=${SNOWFLAKE_DATABASE}
-      - SNOWFLAKE_SCHEMA=${SNOWFLAKE_SCHEMA}
-      - PORT=3000
-    restart: unless-stopped

package/examples/usage.ts

@@ -1,84 +0,0 @@
-/**
- * Example usage of Snowflake MCP Server
- */
-
-const BASE_URL = 'http://localhost:3000';
-
-// Example 1: Execute a simple query
-async function executeQuery() {
-  const response = await fetch(`${BASE_URL}/api/snowflake/query`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify({
-      query: 'SELECT CURRENT_DATE() as today, CURRENT_USER() as user',
-    }),
-  });
-
-  const result = await response.json();
-  console.log('Query Result:', result);
-}
-
-// Example 2: List all databases
-async function listDatabases() {
-  const response = await fetch(`${BASE_URL}/api/snowflake/databases`);
-  const result = await response.json();
-  console.log('Databases:', result);
-}
-
-// Example 3: List tables in a specific database and schema
-async function listTables(database: string, schema: string) {
-  const response = await fetch(
-    `${BASE_URL}/api/snowflake/tables?database=${database}&schema=${schema}`
-  );
-  const result = await response.json();
-  console.log('Tables:', result);
-}
-
-// Example 4: Describe a table
-async function describeTable(tableName: string) {
-  const response = await fetch(
-    `${BASE_URL}/api/snowflake/tables/${tableName}/describe`
-  );
-  const result = await response.json();
-  console.log('Table Description:', result);
-}
-
-// Example 5: Get current session info
-async function getSessionInfo() {
-  const response = await fetch(`${BASE_URL}/api/snowflake/session`);
-  const result = await response.json();
-  console.log('Session Info:', result);
-}
-
-// Example 6: Execute query with parameters
-async function executeQueryWithBinds() {
-  const response = await fetch(`${BASE_URL}/api/snowflake/query`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify({
-      query: 'SELECT * FROM table_name WHERE id = ? AND status = ?',
-      binds: [123, 'active'],
-    }),
-  });
-
-  const result = await response.json();
-  console.log('Query Result with Binds:', result);
-}
-
-// Run examples
-async function main() {
-  try {
-    await executeQuery();
-    await listDatabases();
-    await getSessionInfo();
-  } catch (error) {
-    console.error('Error:', error);
-  }
-}
-
-// Uncomment to run
-// main();

package/postman_collection.json

@@ -1,148 +0,0 @@
-{
-  "info": {
-    "name": "Snowflake MCP Server",
-    "description": "API collection for Snowflake MCP Server",
-    "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
-  },
-  "item": [
-    {
-      "name": "Health Check",
-      "request": {
-        "method": "GET",
-        "header": [],
-        "url": {
-          "raw": "{{base_url}}/health",
-          "host": ["{{base_url}}"],
-          "path": ["health"]
-        }
-      }
-    },
-    {
-      "name": "Connection Status",
-      "request": {
-        "method": "GET",
-        "header": [],
-        "url": {
-          "raw": "{{base_url}}/api/snowflake/status",
-          "host": ["{{base_url}}"],
-          "path": ["api", "snowflake", "status"]
-        }
-      }
-    },
-    {
-      "name": "Execute Query",
-      "request": {
-        "method": "POST",
-        "header": [
-          {
-            "key": "Content-Type",
-            "value": "application/json"
-          }
-        ],
-        "body": {
-          "mode": "raw",
-          "raw": "{\n  \"query\": \"SELECT CURRENT_DATE(), CURRENT_USER(), CURRENT_ROLE()\"\n}"
-        },
-        "url": {
-          "raw": "{{base_url}}/api/snowflake/query",
-          "host": ["{{base_url}}"],
-          "path": ["api", "snowflake", "query"]
-        }
-      }
-    },
-    {
-      "name": "List Databases",
-      "request": {
-        "method": "GET",
-        "header": [],
-        "url": {
-          "raw": "{{base_url}}/api/snowflake/databases",
-          "host": ["{{base_url}}"],
-          "path": ["api", "snowflake", "databases"]
-        }
-      }
-    },
-    {
-      "name": "List Schemas",
-      "request": {
-        "method": "GET",
-        "header": [],
-        "url": {
-          "raw": "{{base_url}}/api/snowflake/schemas?database=YOUR_DATABASE",
-          "host": ["{{base_url}}"],
-          "path": ["api", "snowflake", "schemas"],
-          "query": [
-            {
-              "key": "database",
-              "value": "YOUR_DATABASE"
-            }
-          ]
-        }
-      }
-    },
-    {
-      "name": "List Tables",
-      "request": {
-        "method": "GET",
-        "header": [],
-        "url": {
-          "raw": "{{base_url}}/api/snowflake/tables?database=YOUR_DATABASE&schema=PUBLIC",
-          "host": ["{{base_url}}"],
-          "path": ["api", "snowflake", "tables"],
-          "query": [
-            {
-              "key": "database",
-              "value": "YOUR_DATABASE"
-            },
-            {
-              "key": "schema",
-              "value": "PUBLIC"
-            }
-          ]
-        }
-      }
-    },
-    {
-      "name": "Describe Table",
-      "request": {
-        "method": "GET",
-        "header": [],
-        "url": {
-          "raw": "{{base_url}}/api/snowflake/tables/YOUR_TABLE/describe",
-          "host": ["{{base_url}}"],
-          "path": ["api", "snowflake", "tables", "YOUR_TABLE", "describe"]
-        }
-      }
-    },
-    {
-      "name": "List Warehouses",
-      "request": {
-        "method": "GET",
-        "header": [],
-        "url": {
-          "raw": "{{base_url}}/api/snowflake/warehouses",
-          "host": ["{{base_url}}"],
-          "path": ["api", "snowflake", "warehouses"]
-        }
-      }
-    },
-    {
-      "name": "Get Current Session",
-      "request": {
-        "method": "GET",
-        "header": [],
-        "url": {
-          "raw": "{{base_url}}/api/snowflake/session",
-          "host": ["{{base_url}}"],
-          "path": ["api", "snowflake", "session"]
-        }
-      }
-    }
-  ],
-  "variable": [
-    {
-      "key": "base_url",
-      "value": "http://localhost:3000"
-    }
-  ]
-}

package/src/index.ts

@@ -1,51 +0,0 @@
-#!/usr/bin/env node
-import express, { Express, Request, Response } from 'express';
-import cors from 'cors';
-import dotenv from 'dotenv';
-import { SnowflakeService } from './services/snowflake.service';
-import { errorHandler } from './middleware/error.middleware';
-import { snowflakeRoutes } from './routes/snowflake.routes';
-
-dotenv.config();
-
-const app: Express = express();
-const port = process.env.PORT || 3000;
-
-// Middleware
-app.use(cors());
-app.use(express.json());
-app.use(express.urlencoded({ extended: true }));
-
-// Health check
-app.get('/health', (req: Request, res: Response) => {
-  res.json({ status: 'ok', timestamp: new Date().toISOString() });
-});
-
-// Snowflake routes
-app.use('/api/snowflake', snowflakeRoutes);
-
-// Error handler
-app.use(errorHandler);
-
-// Initialize Snowflake connection
-const snowflakeService = SnowflakeService.getInstance();
-
-app.listen(port, () => {
-  console.log(`🚀 Snowflake MCP Server running on port ${port}`);
-  console.log(`📊 Health check: http://localhost:${port}/health`);
-});
-
-// Graceful shutdown
-process.on('SIGINT', async () => {
-  console.log('\n🛑 Shutting down gracefully...');
-  await snowflakeService.disconnect();
-  process.exit(0);
-});
-
-process.on('SIGTERM', async () => {
-  console.log('\n🛑 Shutting down gracefully...');
-  await snowflakeService.disconnect();
-  process.exit(0);
-});
-
-export default app;

package/src/mcp-server.ts

@@ -1,137 +0,0 @@
-#!/usr/bin/env node
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from '@modelcontextprotocol/sdk/types.js';
-import { SnowflakeService } from './services/snowflake.service';
-import dotenv from 'dotenv';
-
-dotenv.config();
-
-const snowflakeService = SnowflakeService.getInstance();
-
-const server = new Server(
-  {
-    name: 'snowflake-mcp-server',
-    version: '1.0.0',
-  },
-  {
-    capabilities: {
-      tools: {},
-    },
-  }
-);
-
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-  return {
-    tools: [
-      {
-        name: 'execute_query',
-        description: 'Execute a SQL query on Snowflake database',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            query: { type: 'string', description: 'SQL query to execute' },
-            binds: { type: 'array', description: 'Optional bind parameters' },
-          },
-          required: ['query'],
-        },
-      },
-      {
-        name: 'list_databases',
-        description: 'List all databases',
-        inputSchema: { type: 'object', properties: {} },
-      },
-      {
-        name: 'list_schemas',
-        description: 'List schemas',
-        inputSchema: {
-          type: 'object',
-          properties: { database: { type: 'string' } },
-        },
-      },
-      {
-        name: 'list_tables',
-        description: 'List tables',
-        inputSchema: {
-          type: 'object',
-          properties: { database: { type: 'string' }, schema: { type: 'string' } },
-        },
-      },
-      {
-        name: 'describe_table',
-        description: 'Describe table structure',
-        inputSchema: {
-          type: 'object',
-          properties: { tableName: { type: 'string' } },
-          required: ['tableName'],
-        },
-      },
-      {
-        name: 'list_warehouses',
-        description: 'List warehouses',
-        inputSchema: { type: 'object', properties: {} },
-      },
-      {
-        name: 'get_session_info',
-        description: 'Get session info',
-        inputSchema: { type: 'object', properties: {} },
-      },
-    ],
-  };
-});
-
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  try {
-    const { name, arguments: args } = request.params;
-    let result;
-
-    switch (name) {
-      case 'execute_query':
-        result = await snowflakeService.executeQuery((args?.query as string) || '', args?.binds as any);
-        break;
-      case 'list_databases':
-        result = await snowflakeService.listDatabases();
-        break;
-      case 'list_schemas':
-        result = await snowflakeService.listSchemas(args?.database as string);
-        break;
-      case 'list_tables':
-        result = await snowflakeService.listTables(args?.database as string, args?.schema as string);
-        break;
-      case 'describe_table':
-        result = await snowflakeService.describeTable((args?.tableName as string) || '');
-        break;
-      case 'list_warehouses':
-        result = await snowflakeService.listWarehouses();
-        break;
-      case 'get_session_info':
-        result = await snowflakeService.getCurrentSession();
-        break;
-      default:
-        throw new Error(`Unknown tool: ${name}`);
-    }
-
-    return {
-      content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-    };
-  } catch (error: any) {
-    return {
-      content: [{ type: 'text', text: `Error: ${error.message}` }],
-      isError: true,
-    };
-  }
-});
-
-async function main() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  console.error('Snowflake MCP server running on stdio');
-}
-
-main().catch((error) => {
-  console.error('Failed to start MCP server:', error);
-  process.exit(1);
-});

package/src/middleware/error.middleware.ts

@@ -1,22 +0,0 @@
-import { Request, Response, NextFunction } from 'express';
-
-export const errorHandler = (
-  err: any,
-  req: Request,
-  res: Response,
-  next: NextFunction
-) => {
-  console.error('❌ Error:', err);
-
-  const statusCode = err.statusCode || 500;
-  const message = err.message || 'Internal Server Error';
-
-  res.status(statusCode).json({
-    success: false,
-    error: {
-      message,
-      code: err.code || 'INTERNAL_ERROR',
-      ...(process.env.NODE_ENV === 'development' && { stack: err.stack }),
-    },
-  });
-};

package/src/routes/snowflake.routes.ts

@@ -1,123 +0,0 @@
-import { Router, Request, Response, NextFunction } from 'express';
-import { SnowflakeService } from '../services/snowflake.service';
-
-const router = Router();
-const snowflakeService = SnowflakeService.getInstance();
-
-// Execute query
-router.post('/query', async (req: Request, res: Response, next: NextFunction) => {
-  try {
-    const { query, binds } = req.body;
-
-    if (!query) {
-      return res.status(400).json({ error: 'Query is required' });
-    }
-
-    const result = await snowflakeService.executeQuery(query, binds);
-    res.json({
-      success: true,
-      data: result,
-    });
-  } catch (error: any) {
-    next(error);
-  }
-});
-
-// List databases
-router.get('/databases', async (req: Request, res: Response, next: NextFunction) => {
-  try {
-    const result = await snowflakeService.listDatabases();
-    res.json({
-      success: true,
-      data: result,
-    });
-  } catch (error: any) {
-    next(error);
-  }
-});
-
-// List schemas
-router.get('/schemas', async (req: Request, res: Response, next: NextFunction) => {
-  try {
-    const { database } = req.query;
-    const result = await snowflakeService.listSchemas(database as string);
-    res.json({
-      success: true,
-      data: result,
-    });
-  } catch (error: any) {
-    next(error);
-  }
-});
-
-// List tables
-router.get('/tables', async (req: Request, res: Response, next: NextFunction) => {
-  try {
-    const { database, schema } = req.query;
-    const result = await snowflakeService.listTables(
-      database as string,
-      schema as string
-    );
-    res.json({
-      success: true,
-      data: result,
-    });
-  } catch (error: any) {
-    next(error);
-  }
-});
-
-// Describe table
-router.get('/tables/:tableName/describe', async (req: Request, res: Response, next: NextFunction) => {
-  try {
-    const { tableName } = req.params;
-    const result = await snowflakeService.describeTable(tableName);
-    res.json({
-      success: true,
-      data: result,
-    });
-  } catch (error: any) {
-    next(error);
-  }
-});
-
-// List warehouses
-router.get('/warehouses', async (req: Request, res: Response, next: NextFunction) => {
-  try {
-    const result = await snowflakeService.listWarehouses();
-    res.json({
-      success: true,
-      data: result,
-    });
-  } catch (error: any) {
-    next(error);
-  }
-});
-
-// Get current session
-router.get('/session', async (req: Request, res: Response, next: NextFunction) => {
-  try {
-    const result = await snowflakeService.getCurrentSession();
-    res.json({
-      success: true,
-      data: result,
-    });
-  } catch (error: any) {
-    next(error);
-  }
-});
-
-// Connection status
-router.get('/status', async (req: Request, res: Response, next: NextFunction) => {
-  try {
-    const isConnected = snowflakeService.isConnected();
-    res.json({
-      success: true,
-      connected: isConnected,
-    });
-  } catch (error: any) {
-    next(error);
-  }
-});
-
-export { router as snowflakeRoutes };

package/src/services/snowflake.service.ts

@@ -1,149 +0,0 @@
-import snowflake from 'snowflake-sdk';
-
-export interface SnowflakeConfig {
-  account: string;
-  username: string;
-  password: string;
-  warehouse?: string;
-  database?: string;
-  schema?: string;
-}
-
-export interface QueryResult {
-  columns: string[];
-  rows: any[];
-  rowCount: number;
-  executionTime: number;
-}
-
-export class SnowflakeService {
-  private static instance: SnowflakeService;
-  private connection: snowflake.Connection | null = null;
-  private config: SnowflakeConfig;
-
-  private constructor() {
-    this.config = {
-      account: process.env.SNOWFLAKE_ACCOUNT || '',
-      username: process.env.SNOWFLAKE_USERNAME || '',
-      password: process.env.SNOWFLAKE_PASSWORD || '',
-      warehouse: process.env.SNOWFLAKE_WAREHOUSE,
-      database: process.env.SNOWFLAKE_DATABASE,
-      schema: process.env.SNOWFLAKE_SCHEMA,
-    };
-  }
-
-  public static getInstance(): SnowflakeService {
-    if (!SnowflakeService.instance) {
-      SnowflakeService.instance = new SnowflakeService();
-    }
-    return SnowflakeService.instance;
-  }
-
-  private async connect(): Promise<snowflake.Connection> {
-    if (this.connection) {
-      return this.connection;
-    }
-
-    return new Promise((resolve, reject) => {
-      const connectionOptions: any = {
-        account: this.config.account,
-        username: this.config.username,
-        password: this.config.password,
-      };
-
-      if (this.config.warehouse) connectionOptions.warehouse = this.config.warehouse;
-      if (this.config.database) connectionOptions.database = this.config.database;
-      if (this.config.schema) connectionOptions.schema = this.config.schema;
-
-      this.connection = snowflake.createConnection(connectionOptions);
-
-      this.connection.connect((err, conn) => {
-        if (err) {
-          console.error('❌ Failed to connect to Snowflake:', err.message);
-          reject(err);
-        } else {
-          console.log('✅ Successfully connected to Snowflake');
-          resolve(conn);
-        }
-      });
-    });
-  }
-
-  public async executeQuery(sqlText: string, binds?: any[]): Promise<QueryResult> {
-    const startTime = Date.now();
-    const conn = await this.connect();
-
-    return new Promise((resolve, reject) => {
-      conn.execute({
-        sqlText,
-        binds,
-        complete: (err, stmt, rows) => {
-          const executionTime = Date.now() - startTime;
-
-          if (err) {
-            reject(err);
-          } else {
-            const columns = stmt.getColumns().map(col => col.getName());
-            resolve({
-              columns,
-              rows: rows || [],
-              rowCount: rows?.length || 0,
-              executionTime,
-            });
-          }
-        },
-      });
-    });
-  }
-
-  public async listDatabases(): Promise<QueryResult> {
-    return this.executeQuery('SHOW DATABASES');
-  }
-
-  public async listSchemas(database?: string): Promise<QueryResult> {
-    if (database) {
-      return this.executeQuery(`SHOW SCHEMAS IN DATABASE ${database}`);
-    }
-    return this.executeQuery('SHOW SCHEMAS');
-  }
-
-  public async listTables(database?: string, schema?: string): Promise<QueryResult> {
-    if (database && schema) {
-      return this.executeQuery(`SHOW TABLES IN ${database}.${schema}`);
-    }
-    return this.executeQuery('SHOW TABLES');
-  }
-
-  public async describeTable(tableName: string): Promise<QueryResult> {
-    return this.executeQuery(`DESCRIBE TABLE ${tableName}`);
-  }
-
-  public async listWarehouses(): Promise<QueryResult> {
-    return this.executeQuery('SHOW WAREHOUSES');
-  }
-
-  public async getCurrentSession(): Promise<QueryResult> {
-    return this.executeQuery('SELECT CURRENT_USER(), CURRENT_ROLE(), CURRENT_DATABASE(), CURRENT_SCHEMA(), CURRENT_WAREHOUSE()');
-  }
-
-  public async disconnect(): Promise<void> {
-    if (this.connection) {
-      return new Promise((resolve, reject) => {
-        this.connection!.destroy((err) => {
-          if (err) {
-            console.error('❌ Error disconnecting from Snowflake:', err.message);
-            reject(err);
-          } else {
-            console.log('✅ Disconnected from Snowflake');
-            this.connection = null;
-            resolve();
-          }
-        });
-      });
-    }
-  }
-
-  public isConnected(): boolean {
-    return this.connection !== null;
-  }
-}

package/test-api.sh

@@ -1,39 +0,0 @@
-#!/bin/bash
-
-echo "🧪 Testing Snowflake MCP Server..."
-
-# Base URL
-BASE_URL="http://localhost:3000"
-
-# Colors
-GREEN='\033[0;32m'
-RED='\033[0;31m'
-NC='\033[0m' # No Color
-
-# Health check
-echo -e "\n📊 Testing Health Check..."
-curl -s ${BASE_URL}/health | jq .
-
-# Connection status
-echo -e "\n🔌 Testing Connection Status..."
-curl -s ${BASE_URL}/api/snowflake/status | jq .
-
-# Current session
-echo -e "\n👤 Testing Current Session..."
-curl -s ${BASE_URL}/api/snowflake/session | jq .
-
-# List databases
-echo -e "\n🗄️  Testing List Databases..."
-curl -s ${BASE_URL}/api/snowflake/databases | jq .
-
-# List warehouses
-echo -e "\n🏭 Testing List Warehouses..."
-curl -s ${BASE_URL}/api/snowflake/warehouses | jq .
-
-# Execute query
-echo -e "\n⚡ Testing Execute Query..."
-curl -s -X POST ${BASE_URL}/api/snowflake/query \
-  -H "Content-Type: application/json" \
-  -d '{"query": "SELECT CURRENT_DATE(), CURRENT_TIME(), CURRENT_TIMESTAMP()"}' | jq .
-
-echo -e "\n${GREEN}✅ Tests completed!${NC}"

package/tsconfig.json

@@ -1,28 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "commonjs",
-    "lib": [
-      "ES2020"
-    ],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "moduleResolution": "node"
-  },
-  "include": [
-    "src/**/*",
-    "src/mcp-server.ts"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist"
-  ]
-}