@etavioxy/wocingflow-mcp-server 0.0.1

package/README.md

@@ -0,0 +1,58 @@
+# @etavioxy/wocingflow-mcp-server
+
+WocingFlow MCP launcher package compatible with `install-mcp`.
+
+## What this package does
+
+- Starts WocingFlow backend `mcp_server` over HTTP.
+- Bridges HTTP MCP to stdio using `mcp-remote@latest`.
+- Exposes a bin command: `wocingflow-mcp-server`.
+
+## Configure Your AI Assistant
+
+Use `install-mcp` to add the server to your AI assistant:
+
+```bash
+npx -y install-mcp @etavioxy/wocingflow-mcp-server --client cursor --yes
+```
+
+Supported clients: `claude-code`, `cursor`, `windsurf`, `vscode`, `cline`, `roo-cline`, `claude`, `zed`, `goose`, `warp`, `codex`
+
+### Claude Code
+
+```bash
+npx -y install-mcp @etavioxy/wocingflow-mcp-server --client claude-code --yes
+```
+
+### Cursor
+
+```bash
+npx -y install-mcp @etavioxy/wocingflow-mcp-server --client cursor --yes
+```
+
+### VS Code / Copilot
+
+```bash
+npx -y install-mcp @etavioxy/wocingflow-mcp-server --client vscode --yes
+```
+
+### Windsurf
+
+```bash
+npx -y install-mcp @etavioxy/wocingflow-mcp-server --client windsurf --yes
+```
+
+### Cline
+
+```bash
+npx -y install-mcp @etavioxy/wocingflow-mcp-server --client cline --yes
+```
+
+Restart your AI assistant after adding the configuration.
+
+## Environment variables
+
+- `WF_MCP_SERVER_BIN`: absolute path to `mcp_server` binary (optional)
+- `WF_SERVICE_DATA_DIR`: absolute path to `service/data` (optional)
+- `WF_MCP_HTTP_HOST`: default `127.0.0.1`
+- `WF_MCP_HTTP_PORT`: optional fixed port (if unset, launcher auto-selects a free port)

package/bin/wocingflow-mcp-server.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+const fs = require("node:fs");
+const path = require("node:path");
+const net = require("node:net");
+const { spawn } = require("node:child_process");
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function isWindows() {
+  return process.platform === "win32";
+}
+
+function fileExists(filePath) {
+  try {
+    return fs.existsSync(filePath);
+  } catch {
+    return false;
+  }
+}
+
+function candidateRoots() {
+  const cwd = process.cwd();
+  return [cwd, path.resolve(cwd, ".."), path.resolve(cwd, "..", "..")];
+}
+
+function resolveServiceDataDir() {
+  if (process.env.WF_SERVICE_DATA_DIR && fileExists(process.env.WF_SERVICE_DATA_DIR)) {
+    return process.env.WF_SERVICE_DATA_DIR;
+  }
+  for (const root of candidateRoots()) {
+    const candidate = path.join(root, "service", "data");
+    if (fileExists(candidate)) {
+      return candidate;
+    }
+  }
+  return "";
+}
+
+function resolveServerLaunch() {
+  if (process.env.WF_MCP_SERVER_BIN && fileExists(process.env.WF_MCP_SERVER_BIN)) {
+    return { command: process.env.WF_MCP_SERVER_BIN, args: [] };
+  }
+
+  const exeName = isWindows() ? "mcp_server.exe" : "mcp_server";
+  const bundledPath = path.join(__dirname, "..", "vendor", exeName);
+  if (fileExists(bundledPath)) {
+    return { command: bundledPath, args: [] };
+  }
+
+  for (const root of candidateRoots()) {
+    const debugPath = path.join(root, "service", "target", "debug", exeName);
+    const releasePath = path.join(root, "service", "target", "release", exeName);
+    if (fileExists(debugPath)) return { command: debugPath, args: [] };
+    if (fileExists(releasePath)) return { command: releasePath, args: [] };
+  }
+
+  for (const root of candidateRoots()) {
+    const manifestPath = path.join(root, "service", "Cargo.toml");
+    if (fileExists(manifestPath)) {
+      return {
+        command: "cargo",
+        args: ["run", "--manifest-path", manifestPath, "--bin", "mcp_server", "--"],
+      };
+    }
+  }
+
+  throw new Error(
+    "Cannot locate wocingflow mcp_server. Build service/bin/mcp_server or set WF_MCP_SERVER_BIN."
+  );
+}
+
+async function resolvePort() {
+  if (process.env.WF_MCP_HTTP_PORT) {
+    return String(process.env.WF_MCP_HTTP_PORT);
+  }
+  return String(
+    await new Promise((resolve, reject) => {
+      const server = net.createServer();
+      server.listen(0, "127.0.0.1", () => {
+        const address = server.address();
+        if (!address || typeof address === "string") {
+          server.close();
+          reject(new Error("Failed to allocate free TCP port."));
+          return;
+        }
+        const freePort = address.port;
+        server.close(() => resolve(freePort));
+      });
+      server.on("error", reject);
+    })
+  );
+}
+
+async function waitHealth(endpoint, timeoutMs) {
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    try {
+      const response = await fetch(`${endpoint}/health`);
+      if (response.ok) return;
+    } catch {
+      // keep waiting
+    }
+    await sleep(300);
+  }
+  throw new Error(`mcp_server health check timeout: ${endpoint}/health`);
+}
+
+function spawnBackend(command, args, env) {
+  const child = spawn(command, args, {
+    stdio: ["ignore", "pipe", "pipe"],
+    env,
+    shell: false,
+    windowsHide: true,
+  });
+  child.stdout.on("data", (chunk) => {
+    process.stderr.write(String(chunk));
+  });
+  child.stderr.on("data", (chunk) => {
+    process.stderr.write(String(chunk));
+  });
+  return child;
+}
+
+function spawnBridge(command, args, env) {
+  const child = spawn(command, args, {
+    stdio: ["pipe", "pipe", "pipe"],
+    env,
+    shell: false,
+    windowsHide: true,
+  });
+
+  process.stdin.pipe(child.stdin);
+  child.stdout.pipe(process.stdout);
+  child.stderr.pipe(process.stderr);
+  return child;
+}
+
+async function main() {
+  const host = process.env.WF_MCP_HTTP_HOST || "127.0.0.1";
+  const port = await resolvePort();
+  const endpoint = `http://${host}:${port}`;
+  const serviceDataDir = resolveServiceDataDir();
+  const launch = resolveServerLaunch();
+
+  const backendEnv = { ...process.env };
+  if (serviceDataDir) {
+    backendEnv.WF_SERVICE_DATA_DIR = serviceDataDir;
+  }
+
+  const backend = spawnBackend(
+    launch.command,
+    [...launch.args, "--host", host, "--port", String(port)],
+    backendEnv
+  );
+
+  let shuttingDown = false;
+  const shutdown = () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    if (!backend.killed) {
+      backend.kill();
+    }
+  };
+
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  process.on("exit", shutdown);
+
+  backend.on("exit", (code) => {
+    if (!shuttingDown && code !== 0) {
+      console.error(`[wocingflow-mcp] backend exited early with code ${code}`);
+      process.exit(code || 1);
+    }
+  });
+
+  await waitHealth(endpoint, 20000);
+
+  const npxCmd = isWindows() ? "npx.cmd" : "npx";
+  const bridge = spawnBridge(npxCmd, ["-y", "mcp-remote@latest", endpoint], process.env);
+  bridge.on("exit", (code) => {
+    shutdown();
+    process.exit(code || 0);
+  });
+}
+
+main().catch((error) => {
+  console.error(`[wocingflow-mcp] ${error.message}`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@etavioxy/wocingflow-mcp-server",
+  "version": "0.0.1",
+  "description": "MCP stdio launcher for WocingFlow service mcp_server",
+  "type": "commonjs",
+  "bin": {
+    "wocingflow-mcp-server": "bin/wocingflow-mcp-server.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "prepack": "node scripts/prepack.js"
+  },
+  "files": [
+    "bin",
+    "vendor"
+  ]
+}