@zoer7788/mcp-nexus-node 0.1.0

package/README.md

@@ -0,0 +1,35 @@
+# MCP Nexus Node
+
+Remote node for MCP Nexus.
+
+## Install
+
+```bash
+npm install -g @zoer7788/mcp-nexus-node
+```
+
+## Pair with local MCP Nexus
+
+On `pub-118`:
+
+```bash
+npm install -g @zoer7788/mcp-nexus-node
+MCP_NEXUS_ADMIN_URL=https://mcpnexus-pub118.omji.top \
+mcp-nexus pair
+```
+
+Enter the printed 6-digit code in the local MCP Nexus app.
+
+After pairing, create a DevSpace project in MCP Nexus. Copy the returned
+`https://.../mcp` URL into ChatGPT.
+
+## Commands
+
+```bash
+mcp-nexus pair
+mcp-nexus serve
+mcp-nexus status
+```
+
+DevSpace is installed as a package dependency. `cloudflared` must be available on
+the remote machine before creating public DevSpace projects.

package/cli.js

@@ -0,0 +1,411 @@
+#!/usr/bin/env node
+import http from "node:http";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync, appendFileSync } from "node:fs";
+import { homedir, hostname } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+
+const home = homedir();
+const stateDir = process.env.MCP_NEXUS_NODE_DIR || join(home, ".mcp-nexus-node");
+const configPath = join(stateDir, "config.json");
+const projectsPath = join(stateDir, "projects.json");
+const tokensPath = join(stateDir, "tokens.json");
+const logDir = join(stateDir, "logs");
+const nodeIdPath = join(stateDir, "node-id");
+const packageDir = dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+function ensureState() {
+  mkdirSync(stateDir, { recursive: true });
+  mkdirSync(logDir, { recursive: true });
+  if (!existsSync(projectsPath)) saveJson(projectsPath, []);
+  if (!existsSync(tokensPath)) saveJson(tokensPath, { adminToken: randomHex(32) });
+  if (!existsSync(configPath)) saveJson(configPath, {
+    name: hostname(),
+    host: "0.0.0.0",
+    port: Number(process.env.MCP_NEXUS_NODE_PORT || 9876),
+    baseDomain: process.env.MCP_BASE_DOMAIN || "omji.top",
+    relayUrl: process.env.MCP_NEXUS_RELAY_URL || "https://mcpnexus-relay-pub118.omji.top",
+    adminUrl: process.env.MCP_NEXUS_ADMIN_URL || "",
+  });
+  if (!existsSync(nodeIdPath)) writeFileSync(nodeIdPath, randomUUID() + "\n");
+}
+
+function loadJson(path, fallback) {
+  try { return JSON.parse(readFileSync(path, "utf8")); } catch { return fallback; }
+}
+
+function saveJson(path, data) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(data, null, 2) + "\n");
+}
+
+function randomHex(bytes) {
+  return randomBytes(bytes).toString("hex");
+}
+
+function tokenHash(token) {
+  return createHash("sha256").update(token).digest("hex");
+}
+
+function config() {
+  ensureState();
+  const cfg = loadJson(configPath, {});
+  return {
+    ...cfg,
+    port: Number(process.env.MCP_NEXUS_NODE_PORT || cfg.port || 9876),
+    baseDomain: process.env.MCP_BASE_DOMAIN || cfg.baseDomain || "omji.top",
+    relayUrl: process.env.MCP_NEXUS_RELAY_URL || cfg.relayUrl || "https://mcpnexus-relay-pub118.omji.top",
+    adminUrl: process.env.MCP_NEXUS_ADMIN_URL || cfg.adminUrl || "",
+  };
+}
+
+function tokens() {
+  ensureState();
+  return loadJson(tokensPath, {});
+}
+
+function projects() {
+  ensureState();
+  return loadJson(projectsPath, []);
+}
+
+function saveProjects(items) {
+  saveJson(projectsPath, items);
+}
+
+function run(cmd, args, options = {}) {
+  const out = spawnSync(cmd, args, { encoding: "utf8", ...options });
+  if (out.status !== 0) throw new Error((out.stderr || out.stdout || `${cmd} failed`).trim());
+  return out.stdout.trim();
+}
+
+function commandExists(cmd) {
+  return spawnSync("sh", ["-lc", `command -v ${quote(cmd)}`], { encoding: "utf8" }).status === 0;
+}
+
+function quote(value) {
+  return `'${String(value).replaceAll("'", "'\\''")}'`;
+}
+
+function sanitize(value) {
+  return String(value || "").toLowerCase().replace(/[^a-z0-9]/g, "") || "project";
+}
+
+function freePort(start = 8787) {
+  for (let port = start; port < start + 200; port += 1) {
+    const out = spawnSync("sh", ["-lc", `lsof -nP -iTCP:${port} -sTCP:LISTEN >/dev/null 2>&1`]);
+    if (out.status !== 0) return port;
+  }
+  throw new Error("no free port found");
+}
+
+function localIp() {
+  const out = spawnSync("sh", ["-lc", "hostname -I 2>/dev/null | awk '{print $1}'"], { encoding: "utf8" });
+  return out.stdout.trim() || "127.0.0.1";
+}
+
+function adminUrl() {
+  const cfg = config();
+  return cfg.adminUrl || `http://${localIp()}:${cfg.port || 9876}`;
+}
+
+function json(res, status, body) {
+  res.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "access-control-allow-origin": "*",
+    "access-control-allow-headers": "content-type, authorization",
+    "access-control-allow-methods": "GET,POST,PATCH,DELETE,OPTIONS",
+  });
+  res.end(JSON.stringify(body));
+}
+
+async function readJson(req) {
+  const chunks = [];
+  for await (const chunk of req) chunks.push(chunk);
+  if (chunks.length === 0) return {};
+  return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+
+function requireAuth(req) {
+  const header = req.headers.authorization || "";
+  const token = header.startsWith("Bearer ") ? header.slice(7) : "";
+  return token && token === tokens().adminToken;
+}
+
+function findProject(name) {
+  return projects().find((p) => p.name === name);
+}
+
+function devspaceCommand() {
+  const explicit = process.env.DEVSPACE_CLI;
+  if (explicit && existsSync(explicit)) return ["node", explicit];
+  try { return ["node", require.resolve("@waishnav/devspace/dist/cli.js")]; } catch {}
+  const bundled = join(packageDir, "vendor", "devspace", "dist", "cli.js");
+  if (existsSync(bundled)) return ["node", bundled];
+  if (commandExists("devspace")) return ["devspace"];
+  throw new Error("devspace command not found");
+}
+
+function ensureTooling() {
+  devspaceCommand();
+  if (!commandExists("cloudflared")) throw new Error("cloudflared command not found");
+}
+
+function projectStatus(project) {
+  let running = false;
+  if (project.devspacePid) {
+    try { process.kill(project.devspacePid, 0); running = true; } catch {}
+  }
+  return { ...project, running, token_label: "Owner password" };
+}
+
+function setupProject(input) {
+  ensureTooling();
+  const name = String(input.name || "").trim();
+  const root = String(input.root || input.path || "").trim();
+  if (!name || !root) throw new Error("name and root are required");
+  if (!existsSync(root)) throw new Error(`root not found: ${root}`);
+  const items = projects();
+  if (items.some((p) => p.name === name)) throw new Error(`project already exists: ${name}`);
+
+  const cfg = config();
+  const port = Number(input.port || 0) || freePort();
+  const base = sanitize(input.subdomain || name);
+  let subdomain = base;
+  let i = 1;
+  while (items.some((p) => p.subdomain === subdomain)) subdomain = `${base}${++i}`;
+  const hostnameValue = `${subdomain}.${cfg.baseDomain || "omji.top"}`;
+  const tunnelName = `devspace-${subdomain}`;
+
+  let tunnelId = "";
+  const list = spawnSync("cloudflared", ["tunnel", "list"], { encoding: "utf8" }).stdout || "";
+  const existing = list.split("\n").map((line) => line.trim().split(/\s+/)).find((cols) => cols[1] === tunnelName);
+  if (existing) tunnelId = existing[0];
+  else {
+    const created = run("cloudflared", ["tunnel", "create", tunnelName]);
+    tunnelId = (created.match(/[0-9a-f-]{36}/) || [])[0] || "";
+    if (!tunnelId) throw new Error(`could not read tunnel id: ${created}`);
+  }
+
+  run("cloudflared", ["tunnel", "route", "dns", tunnelName, hostnameValue]);
+  const cfDir = join(home, ".cloudflared");
+  const cfConfig = join(cfDir, `${subdomain}-config.yml`);
+  const credFile = join(cfDir, `${tunnelId}.json`);
+  writeFileSync(cfConfig, [
+    `tunnel: ${tunnelId}`,
+    `credentials-file: ${credFile}`,
+    "",
+    "ingress:",
+    `  - hostname: ${hostnameValue}`,
+    `    service: http://127.0.0.1:${port}`,
+    `  - hostname: "*.${cfg.baseDomain || "omji.top"}"`,
+    "    service: http_status:404",
+    "  - service: http_status:404",
+    "",
+  ].join("\n"));
+
+  const ownerToken = randomHex(32);
+  const configDir = join(stateDir, "devspace-profiles", subdomain);
+  mkdirSync(configDir, { recursive: true });
+  saveJson(join(configDir, "config.json"), {
+    host: "127.0.0.1",
+    port,
+    allowedRoots: [root],
+    publicBaseUrl: `https://${hostnameValue}`,
+    allowedHosts: ["localhost", "127.0.0.1", "::1", hostnameValue],
+    minimalTools: false,
+    toolNaming: "short",
+    widgets: "full",
+    skillsEnabled: true,
+  });
+  saveJson(join(configDir, "auth.json"), { ownerToken });
+  chmodSync(join(configDir, "auth.json"), 0o600);
+
+  const project = {
+    name,
+    provider: "devspace",
+    root,
+    path: root,
+    port,
+    subdomain,
+    hostname: hostnameValue,
+    tunnel_name: tunnelName,
+    tunnel_id: tunnelId,
+    cloudflare_config: cfConfig,
+    config_dir: configDir,
+    token: ownerToken,
+    url: `https://${hostnameValue}/mcp`,
+    admin_url: `https://${hostnameValue}/dashboard`,
+  };
+  items.push(project);
+  saveProjects(items);
+  startProject(name);
+  return projectStatus(findProject(name));
+}
+
+function spawnLogged(project, cmd, args, env, logName) {
+  const logPath = join(logDir, logName);
+  const child = spawn(cmd, args, {
+    detached: true,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env, ...env },
+  });
+  child.stdout.on("data", (buf) => appendFileSync(logPath, buf));
+  child.stderr.on("data", (buf) => appendFileSync(logPath, buf));
+  child.unref();
+  return child.pid;
+}
+
+function startProject(name) {
+  const items = projects();
+  const project = items.find((p) => p.name === name);
+  if (!project) throw new Error(`project not found: ${name}`);
+  if (project.devspacePid) {
+    try { process.kill(project.devspacePid, 0); return projectStatus(project); } catch {}
+  }
+  const [cmd, ...baseArgs] = devspaceCommand();
+  project.devspacePid = spawnLogged(project, cmd, [...baseArgs, "serve"], {
+    DEVSPACE_CONFIG_DIR: project.config_dir,
+  }, `${name}.out`);
+  if (project.cloudflare_config) {
+    project.cloudflaredPid = spawnLogged(project, "cloudflared", ["tunnel", "--protocol", "http2", "--config", project.cloudflare_config, "run"], {}, `${name}-cloudflared.out`);
+  }
+  saveProjects(items);
+  return projectStatus(project);
+}
+
+function stopProject(name) {
+  const items = projects();
+  const project = items.find((p) => p.name === name);
+  if (!project) throw new Error(`project not found: ${name}`);
+  for (const key of ["devspacePid", "cloudflaredPid"]) {
+    if (project[key]) {
+      try { process.kill(project[key]); } catch {}
+      delete project[key];
+    }
+  }
+  saveProjects(items);
+  return projectStatus(project);
+}
+
+function patchProject(name, body) {
+  const items = projects();
+  const project = items.find((p) => p.name === name);
+  if (!project) throw new Error(`project not found: ${name}`);
+  const configFile = join(project.config_dir, "config.json");
+  const cfg = loadJson(configFile, {});
+  if (Array.isArray(body.allowedRoots)) cfg.allowedRoots = body.allowedRoots.map(String).filter(Boolean);
+  if (body.publicBaseUrl !== undefined) cfg.publicBaseUrl = body.publicBaseUrl || null;
+  if (Array.isArray(body.allowedHosts)) cfg.allowedHosts = body.allowedHosts.map(String).filter(Boolean);
+  saveJson(configFile, cfg);
+  return { ...projectStatus(project), config: cfg, restart_required: true };
+}
+
+function deleteProject(name) {
+  stopProject(name);
+  saveProjects(projects().filter((p) => p.name !== name));
+  return { ok: true, name };
+}
+
+function tail(name, lines = 80) {
+  const file = join(logDir, `${name}.out`);
+  if (!existsSync(file)) return "";
+  return readFileSync(file, "utf8").split("\n").slice(-lines).join("\n");
+}
+
+function serve() {
+  ensureState();
+  const cfg = config();
+  const server = http.createServer(async (req, res) => {
+    try {
+      if (req.method === "OPTIONS") return json(res, 204, {});
+      if (req.method === "GET" && req.url === "/api/health") {
+        return json(res, 200, { ok: true, app: "mcp-nexus-node", nodeId: readFileSync(nodeIdPath, "utf8").trim(), name: cfg.name, version: "0.1.0" });
+      }
+      if (!req.url?.startsWith("/api/")) return json(res, 404, { ok: false, error: "not found" });
+      if (!requireAuth(req)) return json(res, 401, { ok: false, error: "unauthorized" });
+      if (req.method === "GET" && req.url === "/api/projects") return json(res, 200, { projects: projects().map(projectStatus) });
+      if (req.method === "POST" && req.url === "/api/projects") return json(res, 200, setupProject(await readJson(req)));
+      const match = req.url.match(/^\/api\/projects\/([^/]+)(?:\/([^?]+))?/);
+      if (match) {
+        const name = decodeURIComponent(match[1]);
+        const action = match[2] || "";
+        if (req.method === "PATCH" && action === "config") return json(res, 200, patchProject(name, await readJson(req)));
+        if (req.method === "POST" && action === "start") return json(res, 200, startProject(name));
+        if (req.method === "POST" && action === "stop") return json(res, 200, stopProject(name));
+        if (req.method === "POST" && action === "restart") { stopProject(name); return json(res, 200, startProject(name)); }
+        if (req.method === "GET" && action === "logs") return json(res, 200, { logs: tail(name) });
+        if (req.method === "DELETE" && !action) return json(res, 200, deleteProject(name));
+      }
+      json(res, 404, { ok: false, error: "not found" });
+    } catch (error) {
+      json(res, 500, { ok: false, error: error instanceof Error ? error.message : String(error) });
+    }
+  });
+  server.listen(cfg.port || 9876, cfg.host || "0.0.0.0", () => {
+    console.log(`mcp-nexus-node listening on http://${cfg.host || "0.0.0.0"}:${cfg.port || 9876}`);
+  });
+}
+
+async function postJson(url, body) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  const jsonBody = await response.json().catch(() => ({}));
+  if (!response.ok) throw new Error(jsonBody.error || `HTTP ${response.status}`);
+  return jsonBody;
+}
+
+function startServeDetached() {
+  const child = spawn(process.argv[0], [fileURLToPath(import.meta.url), "serve"], {
+    detached: true,
+    stdio: ["ignore", "ignore", "ignore"],
+    env: process.env,
+  });
+  child.unref();
+}
+
+async function pair() {
+  ensureState();
+  const cfg = config();
+  const pairCode = String(Math.floor(100000 + Math.random() * 900000));
+  const pairingSecret = randomHex(16);
+  startServeDetached();
+  await new Promise((resolve) => setTimeout(resolve, 800));
+  const node = {
+    nodeId: readFileSync(nodeIdPath, "utf8").trim(),
+    name: cfg.name || hostname(),
+    adminUrl: adminUrl(),
+    token: tokens().adminToken,
+    tokenHash: tokenHash(tokens().adminToken),
+  };
+  await postJson(`${cfg.relayUrl.replace(/\/$/, "")}/pair/register`, { pairCode, pairingSecret, node });
+  console.log("");
+  console.log(`MCP Nexus pairing code: ${pairCode}`);
+  console.log(`Relay: ${cfg.relayUrl}`);
+  console.log(`Admin: ${node.adminUrl}`);
+  console.log("Enter this code in local MCP Nexus within 5 minutes.");
+}
+
+function status() {
+  ensureState();
+  console.log(JSON.stringify({
+    config: config(),
+    nodeId: readFileSync(nodeIdPath, "utf8").trim(),
+    projects: projects().map(projectStatus),
+  }, null, 2));
+}
+
+const command = process.argv[2] || "help";
+if (command === "serve") serve();
+else if (command === "pair") pair().catch((error) => { console.error(error.message); process.exit(1); });
+else if (command === "status") status();
+else {
+  console.log("Usage: mcp-nexus <pair|serve|status>");
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@zoer7788/mcp-nexus-node",
+  "version": "0.1.0",
+  "description": "Remote node for MCP Nexus pairing and DevSpace project control.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "mcp-nexus": "cli.js"
+  },
+  "files": [
+    "cli.js",
+    "README.md"
+  ],
+  "scripts": {
+    "check": "node --check cli.js"
+  },
+  "dependencies": {
+    "@waishnav/devspace": "^1.0.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}