@vicinitysoftware/mcp-sql 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import * as sql from "mssql";
+import * as fs from "fs";
+import * as path from "path";
+import * as url from "url";
+import * as dotenv from "dotenv";
+dotenv.config();
+// ── Database config ───────────────────────────────────────────────────────────
+const dbConfig = {
+    server: process.env.VICINITY_SQL_SERVER,
+    database: process.env.VICINITY_SQL_DATABASE,
+    user: process.env.VICINITY_SQL_USER,
+    password: process.env.VICINITY_SQL_PASSWORD,
+    port: parseInt(process.env.VICINITY_SQL_PORT || "1433"),
+    options: {
+        encrypt: process.env.VICINITY_SQL_ENCRYPT === "true",
+        trustServerCertificate: process.env.VICINITY_SQL_TRUST_SERVER_CERT !== "false",
+        connectTimeout: 15000,
+        requestTimeout: parseInt(process.env.VICINITY_SQL_TIMEOUT || "30000"),
+    },
+    pool: { max: 5, min: 0, idleTimeoutMillis: 30000 },
+};
+const MAX_ROWS = parseInt(process.env.VICINITY_SQL_MAX_ROWS || "500");
+let pool;
+async function getPool() {
+    if (!pool) {
+        pool = await sql.connect(dbConfig);
+    }
+    return pool;
+}
+async function runQuery(querySql, maxRows = 100) {
+    const trimmed = querySql.trim().toUpperCase();
+    if (!trimmed.startsWith("SELECT") && !trimmed.startsWith("WITH")) {
+        throw new Error("Only SELECT queries are permitted.");
+    }
+    const limit = Math.min(maxRows, MAX_ROWS);
+    const p = await getPool();
+    const result = await p.request().query(querySql);
+    const rows = result.recordset.slice(0, limit);
+    if (rows.length === 0)
+        return "Query returned no results.";
+    const columns = Object.keys(rows[0]);
+    const colWidths = columns.map(c => Math.max(c.length, ...rows.map(r => String(r[c] ?? "NULL").length)));
+    const fmt = (vals) => vals.map((v, i) => v.padEnd(colWidths[i])).join("  ");
+    const lines = [
+        fmt(columns),
+        colWidths.map(w => "-".repeat(w)).join("--"),
+        ...rows.map(r => fmt(columns.map(c => String(r[c] ?? "NULL")))),
+        `\n(${rows.length} rows${result.recordset.length > limit ? " — truncated" : ""})`,
+    ];
+    return lines.join("\n");
+}
+// ── Schema context loader ─────────────────────────────────────────────────────
+function loadSchemaContext() {
+    const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+    const schemaFile = path.join(__dirname, "../resources/vicinity-schema-context.md");
+    const clientFile = path.join(__dirname, "../resources/vicinity-client-context.md");
+    if (!fs.existsSync(schemaFile)) {
+        return "Schema context file not found.";
+    }
+    let content = fs.readFileSync(schemaFile, "utf-8");
+    if (fs.existsSync(clientFile)) {
+        const clientContent = fs.readFileSync(clientFile, "utf-8");
+        content += "\n\n---\n\n## Client-Specific Context\n\n" + clientContent;
+    }
+    return content;
+}
+// ── MCP Server ────────────────────────────────────────────────────────────────
+const server = new Server({ name: "vicinity-mcp-sql", version: "1.0.0" }, { capabilities: { tools: {}, resources: {} } });
+// Resources
+server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+    resources: [
+        {
+            uri: "vicinity://schema-context",
+            name: "Vicinity Database Schema & Business Context",
+            description: "Table relationships, business terminology, and query patterns for Vicinity manufacturing databases",
+            mimeType: "text/markdown",
+        },
+    ],
+}));
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    if (request.params.uri === "vicinity://schema-context") {
+        return {
+            contents: [{
+                    uri: request.params.uri,
+                    mimeType: "text/markdown",
+                    text: loadSchemaContext(),
+                }],
+        };
+    }
+    throw new Error(`Unknown resource: ${request.params.uri}`);
+});
+// Tools
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        {
+            name: "list_tables",
+            description: "List all user tables in the Vicinity database.",
+            inputSchema: { type: "object", properties: {} },
+        },
+        {
+            name: "list_views",
+            description: "List all views in the Vicinity database.",
+            inputSchema: { type: "object", properties: {} },
+        },
+        {
+            name: "describe_table",
+            description: "Return column names, types, and nullability for a table or view.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    table_name: { type: "string", description: "Table or view name" },
+                    schema: { type: "string", description: "Schema name (default: dbo)" },
+                },
+                required: ["table_name"],
+            },
+        },
+        {
+            name: "run_query",
+            description: "Execute a read-only SELECT query against the Vicinity database.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    sql: { type: "string", description: "SQL SELECT statement to execute" },
+                    max_rows: { type: "number", description: "Maximum rows to return (default 100, max 500)" },
+                },
+                required: ["sql"],
+            },
+        },
+    ],
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        let result = "";
+        if (name === "list_tables") {
+            const p = await getPool();
+            const res = await p.request().query(`
+        SELECT TABLE_SCHEMA, TABLE_NAME
+        FROM INFORMATION_SCHEMA.TABLES
+        WHERE TABLE_TYPE = 'BASE TABLE'
+        ORDER BY TABLE_SCHEMA, TABLE_NAME
+      `);
+            result = res.recordset.map((r) => `${r.TABLE_SCHEMA}.${r.TABLE_NAME}`).join("\n");
+        }
+        else if (name === "list_views") {
+            const p = await getPool();
+            const res = await p.request().query(`
+        SELECT TABLE_SCHEMA, TABLE_NAME
+        FROM INFORMATION_SCHEMA.VIEWS
+        ORDER BY TABLE_SCHEMA, TABLE_NAME
+      `);
+            result = res.recordset.map((r) => `${r.TABLE_SCHEMA}.${r.TABLE_NAME}`).join("\n") || "No views found.";
+        }
+        else if (name === "describe_table") {
+            const p = await getPool();
+            const res = await p.request()
+                .input("table", sql.NVarChar, args?.table_name)
+                .input("schema", sql.NVarChar, args?.schema ?? "dbo")
+                .query(`
+          SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE, CHARACTER_MAXIMUM_LENGTH
+          FROM INFORMATION_SCHEMA.COLUMNS
+          WHERE TABLE_NAME = @table AND TABLE_SCHEMA = @schema
+          ORDER BY ORDINAL_POSITION
+        `);
+            if (res.recordset.length === 0) {
+                result = `Table '${args?.schema ?? "dbo"}.${args?.table_name}' not found.`;
+            }
+            else {
+                const lines = [`${"Column".padEnd(40)} ${"Type".padEnd(20)} ${"Nullable".padEnd(10)} MaxLen`, "-".repeat(80)];
+                for (const r of res.recordset) {
+                    lines.push(`${String(r.COLUMN_NAME).padEnd(40)} ${String(r.DATA_TYPE).padEnd(20)} ${String(r.IS_NULLABLE).padEnd(10)} ${r.CHARACTER_MAXIMUM_LENGTH ?? ""}`);
+                }
+                result = lines.join("\n");
+            }
+        }
+        else if (name === "run_query") {
+            result = await runQuery(String(args?.sql), args?.max_rows);
+        }
+        else {
+            throw new Error(`Unknown tool: ${name}`);
+        }
+        return { content: [{ type: "text", text: result }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+});
+// ── Start ─────────────────────────────────────────────────────────────────────
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@vicinitysoftware/mcp-sql",
+  "version": "1.0.0",
+  "description": "MCP server for Vicinity Software SQL databases",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "vicinity-mcp-sql": "dist/index.js"
+  },
+  "files": [
+    "dist/",
+    "resources/",
+    "README.md"
+  ],
+  "engines": { "node": ">=18.0.0" },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "dotenv": "^16.0.0",
+    "mssql": "^11.0.0"
+  },
+  "devDependencies": {
+    "@types/mssql": "^9.0.0",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  }
+}