nova-control-mcp-server 0.0.3 → 0.0.4

package/README.md

@@ -67,6 +67,49 @@ Add the same block under `mcpServers` in `~/.cursor/mcp.json`.
 |---|---|---|---|
 | `--port <path>` | `-p` | *(required)* | serial port path (e.g. `/dev/ttyACM0`, `COM3`) |
 | `--baud <rate>` | `-b` | `9600` | baud rate |
+| `--transport <mode>` | `-t` | `stdio` | transport: `stdio` or `http` |
+| `--listen <port>` | `-l` | `3000` | HTTP listen port (only used when `--transport http`) |
+
+## HTTP transport (Docker / remote)
+
+Use `--transport http` to expose the MCP server over HTTP instead of stdio. This is the recommended mode when the server runs in a Docker container or on a remote machine.
+
+The server listens on the given port and accepts MCP requests at `POST /mcp`.
+
+```bash
+nova-control-mcp-server --port /dev/ttyACM0 --transport http --listen 3000
+```
+
+### Docker example
+
+```dockerfile
+FROM node:22-slim
+RUN npm install -g nova-control-mcp-server
+EXPOSE 3000
+CMD ["nova-control-mcp-server", "--port", "/dev/ttyACM0", \
+     "--transport", "http", "--listen", "3000"]
+```
+
+Run the container with the serial device passed through:
+
+```bash
+docker run --device /dev/ttyACM0 -p 3000:3000 nova-mcp
+```
+
+### Connecting an MCP client to the HTTP transport
+
+Point your MCP client at `http://<host>:3000/mcp`. For Claude Desktop with a remote server, use the `url` transport type:
+
+```json
+{
+  "mcpServers": {
+    "nova-control": {
+      "type": "http",
+      "url": "http://localhost:3000/mcp"
+    }
+  }
+}
+```
 
 ## Tools
 

package/dist/nova-control-mcp-server.js

@@ -1,15 +1,17 @@
 #!/usr/bin/env node
 import { fileURLToPath as e } from "node:url";
 import { realpathSync as t } from "node:fs";
-import { parseArgs as n } from "node:util";
-import { Server as r } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport as i } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema as a, ListToolsRequestSchema as o } from "@modelcontextprotocol/sdk/types.js";
-import { openNova as s } from "nova-control-node";
+import { createServer as n } from "node:http";
+import { parseArgs as r } from "node:util";
+import { Server as i } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport as a } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport as o } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { CallToolRequestSchema as s, ListToolsRequestSchema as c } from "@modelcontextprotocol/sdk/types.js";
+import { openNova as l } from "nova-control-node";
 //#region src/nova-control-mcp-server.ts
-function c() {
+function u() {
 	try {
-		let { values: e } = n({
+		let { values: e } = r({
 			args: process.argv.slice(2),
 			options: {
 				port: {
@@ -19,33 +21,45 @@ function c() {
 				baud: {
 					type: "string",
 					short: "b"
+				},
+				transport: {
+					type: "string",
+					short: "t"
+				},
+				listen: {
+					type: "string",
+					short: "l"
 				}
 			},
 			strict: !0,
 			allowPositionals: !1
 		});
-		return e.port ?? (process.stderr.write("nova-control-mcp: --port is required\n"), process.exit(1)), {
+		e.port ?? (process.stderr.write("nova-control-mcp: --port is required\n"), process.exit(1));
+		let t = e.transport ?? "stdio";
+		return t !== "stdio" && t !== "http" && (process.stderr.write(`nova-control-mcp: --transport must be 'stdio' or 'http', got '${t}'\n`), process.exit(1)), {
 			Port: e.port,
-			BaudRate: Number(e.baud ?? "9600")
+			BaudRate: Number(e.baud ?? "9600"),
+			Transport: t,
+			ListenPort: Number(e.listen ?? "3000")
 		};
 	} catch (e) {
 		process.stderr.write(`nova-control-mcp: ${e.message ?? e}\n`), process.exit(1);
 	}
 }
-var l = "", u = 9600, d;
-async function f() {
-	return d ??= await s(l, u), d;
+var d = "", f = 9600, p;
+async function m() {
+	return p ??= await l(d, f), p;
 }
-function p() {
-	d != null && (d.destroy(), d = void 0);
+function h() {
+	p != null && (p.destroy(), p = void 0);
 }
-function m(e, t = 9600) {
-	l = e, u = t;
+function g(e, t = 9600) {
+	d = e, f = t;
 }
-function h() {
-	p(), l = "", u = 9600;
+function _() {
+	h(), d = "", f = 9600;
 }
-var g = [
+var v = [
 	{
 		name: "home",
 		description: "send all servos to their home positions",
@@ -164,80 +178,80 @@ var g = [
 		}
 	}
 ];
-async function _() {
-	return await (await f()).home(), "all servos moved to home positions";
+async function y() {
+	return await (await m()).home(), "all servos moved to home positions";
 }
-async function v(e) {
+async function b(e) {
 	let t = {};
 	if (e.shift_to != null && (t.s1 = Number(e.shift_to)), e.roll_to != null && (t.s2 = Number(e.roll_to)), e.pitch_to != null && (t.s3 = Number(e.pitch_to)), e.rotate_to != null && (t.s4 = Number(e.rotate_to)), e.lift_to != null && (t.s5 = Number(e.lift_to)), Object.keys(t).length === 0) throw Error("move: at least one of shift_to, roll_to, pitch_to, rotate_to, lift_to is required");
-	let n = await f();
+	let n = await m();
 	return n.State = t, await n.sendServoState(), `servos updated: ${JSON.stringify(t)}`;
 }
-async function y(e) {
-	let t = Number(e.deg), n = await f();
+async function x(e) {
+	let t = Number(e.deg), n = await m();
 	return n.State = { s1: t }, await n.sendServoState(), `s1 (shift) → ${t}°`;
 }
-async function b(e) {
-	let t = Number(e.deg), n = await f();
+async function S(e) {
+	let t = Number(e.deg), n = await m();
 	return n.State = { s2: t }, await n.sendServoState(), `s2 (roll) → ${t}°`;
 }
-async function x(e) {
-	let t = Number(e.deg), n = await f();
+async function C(e) {
+	let t = Number(e.deg), n = await m();
 	return n.State = { s3: t }, await n.sendServoState(), `s3 (pitch) → ${t}°`;
 }
-async function S(e) {
-	let t = Number(e.deg), n = await f();
+async function w(e) {
+	let t = Number(e.deg), n = await m();
 	return n.State = { s4: t }, await n.sendServoState(), `s4 (rotate) → ${t}°`;
 }
-async function C(e) {
-	let t = Number(e.deg), n = await f();
+async function T(e) {
+	let t = Number(e.deg), n = await m();
 	return n.State = { s5: t }, await n.sendServoState(), `s5 (lift) → ${t}°`;
 }
-async function w(e) {
+async function E(e) {
 	let t = Number(e.ms);
 	if (isNaN(t) || t < 0) throw Error(`wait: invalid duration '${e.ms}' — expected a non-negative number`);
 	return await new Promise((e) => setTimeout(e, t)), `waited ${t} ms`;
 }
-async function T() {
-	let e = await f();
+async function D() {
+	let e = await m();
 	return JSON.stringify(e.State);
 }
-function E() {
-	let e = new r({
+function O() {
+	let e = new i({
 		name: "nova-control-mcp-server",
-		version: "0.0.1"
+		version: "0.0.4"
 	}, { capabilities: { tools: {} } });
-	return e.setRequestHandler(o, async () => ({ tools: g })), e.setRequestHandler(a, async (e) => {
+	return e.setRequestHandler(c, async () => ({ tools: v })), e.setRequestHandler(s, async (e) => {
 		let t = e.params.name, n = e.params.arguments ?? {};
 		try {
 			let e;
 			switch (t) {
 				case "home":
-					e = await _();
+					e = await y();
 					break;
 				case "move":
-					e = await v(n);
+					e = await b(n);
 					break;
 				case "shift_to":
-					e = await y(n);
+					e = await x(n);
 					break;
 				case "roll_to":
-					e = await b(n);
+					e = await S(n);
 					break;
 				case "pitch_to":
-					e = await x(n);
+					e = await C(n);
 					break;
 				case "rotate_to":
-					e = await S(n);
+					e = await w(n);
 					break;
 				case "lift_to":
-					e = await C(n);
+					e = await T(n);
 					break;
 				case "wait":
-					e = await w(n);
+					e = await E(n);
 					break;
 				case "get_state":
-					e = await T();
+					e = await D();
 					break;
 				default: return {
 					content: [{
@@ -262,17 +276,36 @@ function E() {
 		}
 	}), e;
 }
-async function D() {
-	let { Port: e, BaudRate: t } = c();
-	l = e, u = t;
-	let n = E(), r = new i();
-	await n.connect(r);
+async function k(e) {
+	let t = new a();
+	await e.connect(t);
 	for (let e of ["SIGINT", "SIGTERM"]) process.on(e, () => {
-		p(), process.exit(0);
+		h(), process.exit(0);
+	});
+}
+async function A(e, t) {
+	let r = new o({ sessionIdGenerator: void 0 });
+	await e.connect(r);
+	let i = n(async (e, t) => {
+		e.url === "/mcp" ? await r.handleRequest(e, t) : (t.writeHead(404, { "Content-Type": "text/plain" }), t.end("not found"));
+	});
+	await new Promise((e, n) => {
+		i.listen(t, () => {
+			process.stderr.write(`nova-control-mcp: HTTP transport listening on port ${t} — POST /mcp\n`), e();
+		}), i.once("error", n);
 	});
+	for (let e of ["SIGINT", "SIGTERM"]) process.on(e, async () => {
+		await r.close(), i.close(), h(), process.exit(0);
+	});
+}
+async function j() {
+	let { Port: e, BaudRate: t, Transport: n, ListenPort: r } = u();
+	d = e, f = t;
+	let i = O();
+	n === "http" ? await A(i, r) : await k(i);
 }
-t(process.argv[1]) === e(import.meta.url) && D().catch((e) => {
+t(process.argv[1]) === e(import.meta.url) && j().catch((e) => {
 	process.stderr.write(`nova-control-mcp: fatal: ${e.message ?? e}\n`), process.exit(1);
 });
 //#endregion
-export { h as _destroyForTests, m as _setupForTests, E as createServer };
+export { _ as _destroyForTests, g as _setupForTests, O as createServer };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nova-control-mcp-server",
   "description": "MCP server for controlling a NOVA DIY Artificial Intelligence Robot by Creoqode",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "type": "module",
   "keywords": [
     "nova",