@niroai/mcp-server 1.0.0

package/index.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+
+/**
+ * Niro MCP Server — stdio-to-SSE bridge.
+ *
+ * Reads MCP JSON-RPC messages from stdin, forwards them to the
+ * Niro ai-assistant SSE transport, and writes responses to stdout.
+ *
+ * Required env vars:
+ *   NIRO_API_KEY         — Your Niro API key (from console.niroai.dev)
+ *   NIRO_PROJECT_ID  — Project ID to query
+ *   NIRO_API_URL         — API base URL (https://api.niroai.dev or http://localhost:8098)
+ */
+
+const http = require("http");
+const https = require("https");
+const readline = require("readline");
+
+const API_KEY = process.env.NIRO_API_KEY;
+const PROJECT_ID = process.env.NIRO_PROJECT_ID;
+const API_URL = process.env.NIRO_API_URL || "https://api.niroai.dev";
+
+function fatal(message) {
+  const error = {
+    jsonrpc: "2.0",
+    id: null,
+    error: { code: -32603, message },
+  };
+  process.stdout.write(JSON.stringify(error) + "\n");
+  process.stderr.write(`[niro-mcp] ERROR: ${message}\n`);
+  process.exit(1);
+}
+
+if (!API_KEY) fatal("NIRO_API_KEY is required. Get it from console.niroai.dev > Settings > Account.");
+if (!PROJECT_ID) fatal("NIRO_PROJECT_ID is required. Find it on the Projects page at console.niroai.dev.");
+
+const parsedUrl = new URL(API_URL);
+const httpModule = parsedUrl.protocol === "https:" ? https : http;
+
+let sessionId = null;
+
+/**
+ * Connect to the SSE endpoint and listen for responses.
+ */
+function connectSse() {
+  return new Promise((resolve, reject) => {
+    const sseUrl = `${API_URL}/mcp/sse`;
+    process.stderr.write(`[niro-mcp] Connecting to ${sseUrl}\n`);
+
+    const req = httpModule.get(sseUrl, {
+      headers: { "Accept": "text/event-stream" },
+    }, (res) => {
+      if (res.statusCode !== 200) {
+        reject(new Error(`SSE connection failed: HTTP ${res.statusCode}`));
+        return;
+      }
+
+      let buffer = "";
+
+      res.on("data", (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop(); // Keep incomplete line in buffer
+
+        let eventName = null;
+        for (const line of lines) {
+          if (line.startsWith("event:")) {
+            eventName = line.slice(6).trim();
+          } else if (line.startsWith("data:")) {
+            const data = line.slice(5).trim();
+
+            if (eventName === "endpoint") {
+              // First event: receive the message endpoint URL with sessionId
+              const match = data.match(/sessionId=([a-f0-9-]+)/);
+              if (match) {
+                sessionId = match[1];
+                process.stderr.write(`[niro-mcp] Session established: ${sessionId}\n`);
+                resolve();
+              }
+            } else if (eventName === "message") {
+              // Response from the server — write to stdout
+              process.stdout.write(data + "\n");
+            }
+            eventName = null;
+          }
+        }
+      });
+
+      res.on("error", (err) => {
+        process.stderr.write(`[niro-mcp] SSE error: ${err.message}\n`);
+      });
+
+      res.on("end", () => {
+        process.stderr.write("[niro-mcp] SSE connection closed\n");
+        process.exit(0);
+      });
+    });
+
+    req.on("error", (err) => {
+      reject(new Error(`Failed to connect to ${sseUrl}: ${err.message}`));
+    });
+  });
+}
+
+/**
+ * Send a JSON-RPC message to the server via HTTP POST.
+ */
+function sendMessage(message) {
+  return new Promise((resolve, reject) => {
+    const url = `${API_URL}/mcp/messages?sessionId=${sessionId}`;
+    const postData = JSON.stringify(injectProjectId(message));
+    const parsed = new URL(url);
+
+    const options = {
+      hostname: parsed.hostname,
+      port: parsed.port,
+      path: parsed.pathname + parsed.search,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(postData),
+      },
+    };
+
+    const req = (parsed.protocol === "https:" ? https : http).request(options, (res) => {
+      res.resume(); // Drain response
+      resolve();
+    });
+
+    req.on("error", (err) => {
+      process.stderr.write(`[niro-mcp] POST error: ${err.message}\n`);
+      reject(err);
+    });
+
+    req.write(postData);
+    req.end();
+  });
+}
+
+/**
+ * Inject project_id into tools/call arguments so the server knows which project to query.
+ */
+function injectProjectId(message) {
+  if (message.method === "tools/call" && message.params) {
+    const args = message.params.arguments || {};
+    if (!args.project_id) {
+      message.params.arguments = { ...args, project_id: PROJECT_ID };
+    }
+  }
+  return message;
+}
+
+/**
+ * Main: connect SSE, then read stdin line by line and forward to server.
+ */
+async function main() {
+  try {
+    await connectSse();
+  } catch (err) {
+    fatal(`Connection failed: ${err.message}`);
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    terminal: false,
+  });
+
+  rl.on("line", async (line) => {
+    line = line.trim();
+    if (!line) return;
+
+    try {
+      const message = JSON.parse(line);
+      await sendMessage(message);
+    } catch (err) {
+      process.stderr.write(`[niro-mcp] Failed to process message: ${err.message}\n`);
+    }
+  });
+
+  rl.on("close", () => {
+    process.exit(0);
+  });
+}
+
+main();

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@niroai/mcp-server",
+  "version": "1.0.0",
+  "description": "Niro MCP Server — code intelligence for AI coding assistants",
+  "bin": {
+    "mcp-server": "index.js"
+  },
+  "main": "index.js",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "code-intelligence",
+    "claude",
+    "cursor",
+    "windsurf",
+    "niro"
+  ],
+  "author": "Niro AI <support@niroai.dev>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/niroai/mcp-server.git"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "index.js",
+    "README.md",
+    "LICENSE"
+  ]
+}