worsoft-frontend-codegen-mcp 0.1.0

package/README.md

@@ -0,0 +1,69 @@
+# worsoft-frontend-codegen-mcp
+
+Worsoft frontend code generation MCP server.
+
+This package exposes a stdio MCP server with one tool:
+
+- `worsoft_codegen_generate_frontend`
+
+The tool delegates to a running Worsoft code generation service and supports:
+
+- single-table generation by `tableIds`
+- single-table generation by `dsName + tableName`
+- master-child template generation by `style + childTableName + mainField + childField`
+- render-only mode and write-to-disk mode
+
+## Requirements
+
+- Node.js 18+
+- A running Worsoft code generation backend reachable from this machine
+
+## Environment variables
+
+- `WORSOFT_CODEGEN_BASE_URL`
+- `WORSOFT_CODEGEN_EXECUTE_PATH`
+- `WORSOFT_CODEGEN_EXECUTE_URL`
+
+If `WORSOFT_CODEGEN_EXECUTE_URL` is set, it takes priority.
+
+## MCP configuration example
+
+```json
+{
+  "mcpServers": {
+    "worsoft-codegen": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "worsoft-frontend-codegen-mcp"
+      ],
+      "env": {
+        "WORSOFT_CODEGEN_BASE_URL": "http://127.0.0.1:9999",
+        "WORSOFT_CODEGEN_EXECUTE_PATH": "/admin/generator/mcp/execute"
+      }
+    }
+  }
+}
+```
+
+## Tool arguments
+
+- `tableIds`
+- `dsName`
+- `tableName`
+- `style`
+- `childTableName`
+- `mainField`
+- `childField`
+- `frontendPath`
+- `baseUrl`
+- `executeUrl`
+- `overwrite`
+- `writeToDisk`
+
+## Notes
+
+- Pass 64-bit ids such as `tableIds` and `style` as strings when possible.
+- `frontendPath` must be an absolute path.
+- This package does not include the Worsoft backend service. It only wraps the MCP transport and forwards requests to your running Worsoft service.
+

package/mcp_server.js

@@ -0,0 +1,418 @@
+#!/usr/bin/env node
+'use strict';
+
+const http = require('http');
+const https = require('https');
+const { URL } = require('url');
+
+const SERVER_NAME = 'worsoft-codegen';
+const SERVER_VERSION = '0.5.1';
+const PROTOCOL_VERSION = '2024-11-05';
+const TOOL_NAME = 'worsoft_codegen_generate_frontend';
+const DEFAULT_BASE_URL = process.env.WORSOFT_CODEGEN_BASE_URL || 'http://127.0.0.1:5003';
+const DEFAULT_EXECUTE_PATH = process.env.WORSOFT_CODEGEN_EXECUTE_PATH || '/admin/generator/mcp/execute';
+const DEFAULT_EXECUTE_URL = process.env.WORSOFT_CODEGEN_EXECUTE_URL || '';
+const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
+
+const TOOL_SCHEMA = {
+  type: 'object',
+  properties: {
+    tableIds: {
+      type: 'array',
+      items: {
+        oneOf: [
+          { type: 'string', pattern: '^[0-9]+$' },
+          { type: 'integer' }
+        ]
+      },
+      minItems: 1,
+      description: 'Optional. Generate by table config ids. Prefer strings for 64-bit ids.'
+    },
+    dsName: {
+      type: 'string',
+      description: 'Optional data source name when generating by table name.'
+    },
+    tableName: {
+      type: 'string',
+      description: 'Optional main table name when generating by table name.'
+    },
+    style: {
+      oneOf: [
+        { type: 'string', pattern: '^[0-9]+$' },
+        { type: 'integer' }
+      ],
+      description: 'Optional template group id. Prefer string for 64-bit ids.'
+    },
+    childTableName: {
+      type: 'string',
+      description: 'Optional child table name for master-child templates.'
+    },
+    mainField: {
+      type: 'string',
+      description: 'Optional relation field on the main table.'
+    },
+    childField: {
+      type: 'string',
+      description: 'Optional relation field on the child table.'
+    },
+    frontendPath: {
+      type: 'string',
+      description: 'Absolute frontend output root path.'
+    },
+    baseUrl: {
+      type: 'string',
+      description: 'Optional base service url, for example http://127.0.0.1:9999.'
+    },
+    executeUrl: {
+      type: 'string',
+      description: 'Optional full execute url. Higher priority than baseUrl.'
+    },
+    overwrite: {
+      type: 'boolean',
+      default: true,
+      description: 'Whether to overwrite existing files.'
+    },
+    writeToDisk: {
+      type: 'boolean',
+      default: true,
+      description: 'Whether to write files. False means render only.'
+    }
+  },
+  required: ['frontendPath'],
+  anyOf: [
+    { required: ['tableIds'] },
+    { required: ['dsName', 'tableName'] }
+  ],
+  additionalProperties: false
+};
+
+function writeMessage(payload) {
+  const body = Buffer.from(JSON.stringify(payload), 'utf8');
+  process.stdout.write(`Content-Length: ${body.length}\r\n\r\n`);
+  process.stdout.write(body);
+}
+
+function successResponse(id, result) {
+  return { jsonrpc: '2.0', id, result };
+}
+
+function errorResponse(id, code, message) {
+  return { jsonrpc: '2.0', id, error: { code, message } };
+}
+
+function toolErrorResult(message) {
+  return {
+    content: [{ type: 'text', text: message }],
+    isError: true
+  };
+}
+
+function toolResultFromResponse(response) {
+  const text = JSON.stringify(response, null, 2);
+  return {
+    content: [{ type: 'text', text }],
+    structuredContent: response,
+    isError: false
+  };
+}
+
+function trimOptionalString(value, name) {
+  if (value === undefined || value === null) {
+    return null;
+  }
+  if (typeof value !== 'string' || !value.trim()) {
+    throw new Error(`${name} must be a non-empty string`);
+  }
+  return value.trim();
+}
+
+function ensureHttpUrl(value, name) {
+  if (!value) {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    throw new Error(`${name} must be a valid HTTP URL`);
+  }
+  if (!['http:', 'https:'].includes(parsed.protocol) || !parsed.host) {
+    throw new Error(`${name} must be a valid HTTP URL`);
+  }
+  return value;
+}
+
+function normalizeId(value, name) {
+  if (value === undefined || value === null) {
+    return null;
+  }
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    if (!/^\d+$/.test(trimmed)) {
+      throw new Error(`${name} must contain digits only`);
+    }
+    return trimmed;
+  }
+  if (typeof value === 'number') {
+    if (!Number.isInteger(value)) {
+      throw new Error(`${name} must be an integer or digit string`);
+    }
+    if (!Number.isSafeInteger(value)) {
+      throw new Error(`${name} exceeds JS safe integer range; pass it as a string`);
+    }
+    return String(value);
+  }
+  throw new Error(`${name} must be an integer or digit string`);
+}
+
+function normalizeIdList(value) {
+  if (value === undefined || value === null) {
+    return null;
+  }
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error('tableIds must be a non-empty array');
+  }
+  return value.map((item, index) => normalizeId(item, `tableIds[${index}]`));
+}
+
+function validateArguments(argumentsObject) {
+  if (!argumentsObject || typeof argumentsObject !== 'object' || Array.isArray(argumentsObject)) {
+    throw new Error('arguments must be an object');
+  }
+  const tableIds = normalizeIdList(argumentsObject.tableIds);
+  const dsName = trimOptionalString(argumentsObject.dsName, 'dsName');
+  const tableName = trimOptionalString(argumentsObject.tableName, 'tableName');
+  if ((!tableIds || tableIds.length === 0) && (!dsName || !tableName)) {
+    throw new Error('Provide tableIds, or provide both dsName and tableName');
+  }
+  const style = normalizeId(argumentsObject.style, 'style');
+  const frontendPath = trimOptionalString(argumentsObject.frontendPath, 'frontendPath');
+  const baseUrl = ensureHttpUrl(trimOptionalString(argumentsObject.baseUrl, 'baseUrl'), 'baseUrl');
+  const executeUrl = ensureHttpUrl(trimOptionalString(argumentsObject.executeUrl, 'executeUrl'), 'executeUrl');
+  const childTableName = trimOptionalString(argumentsObject.childTableName, 'childTableName');
+  const mainField = trimOptionalString(argumentsObject.mainField, 'mainField');
+  const childField = trimOptionalString(argumentsObject.childField, 'childField');
+  const overwrite = argumentsObject.overwrite === undefined ? true : argumentsObject.overwrite;
+  const writeToDisk = argumentsObject.writeToDisk === undefined ? true : argumentsObject.writeToDisk;
+  if (typeof overwrite !== 'boolean') {
+    throw new Error('overwrite must be a boolean');
+  }
+  if (typeof writeToDisk !== 'boolean') {
+    throw new Error('writeToDisk must be a boolean');
+  }
+  return {
+    tableIds,
+    dsName,
+    tableName,
+    style,
+    childTableName,
+    mainField,
+    childField,
+    frontendPath,
+    baseUrl,
+    executeUrl,
+    overwrite,
+    writeToDisk
+  };
+}
+
+function resolveExecuteUrl(argumentsObject) {
+  if (argumentsObject.executeUrl) {
+    return argumentsObject.executeUrl;
+  }
+  if (argumentsObject.baseUrl) {
+    return argumentsObject.baseUrl.replace(/\/+$/, '') + DEFAULT_EXECUTE_PATH;
+  }
+  if (DEFAULT_EXECUTE_URL) {
+    return DEFAULT_EXECUTE_URL;
+  }
+  return DEFAULT_BASE_URL.replace(/\/+$/, '') + DEFAULT_EXECUTE_PATH;
+}
+
+function callExecute(argumentsObject) {
+  const executeUrl = resolveExecuteUrl(argumentsObject);
+  const payload = {
+    frontendPath: argumentsObject.frontendPath,
+    overwrite: argumentsObject.overwrite,
+    writeToDisk: argumentsObject.writeToDisk
+  };
+  if (argumentsObject.tableIds) {
+    payload.tableIds = argumentsObject.tableIds;
+  }
+  if (argumentsObject.dsName && argumentsObject.tableName) {
+    payload.dsName = argumentsObject.dsName;
+    payload.tableName = argumentsObject.tableName;
+  }
+  if (argumentsObject.style !== null) {
+    payload.style = argumentsObject.style;
+  }
+  for (const key of ['childTableName', 'mainField', 'childField']) {
+    if (argumentsObject[key]) {
+      payload[key] = argumentsObject[key];
+    }
+  }
+  const parsedUrl = new URL(executeUrl);
+  const transport = parsedUrl.protocol === 'https:' ? https : http;
+  const body = Buffer.from(JSON.stringify(payload), 'utf8');
+
+  return new Promise((resolve, reject) => {
+    const req = transport.request(
+      {
+        protocol: parsedUrl.protocol,
+        hostname: parsedUrl.hostname,
+        port: parsedUrl.port || undefined,
+        path: `${parsedUrl.pathname}${parsedUrl.search}`,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json; charset=utf-8',
+          'Content-Length': String(body.length)
+        },
+        timeout: 60000
+      },
+      (res) => {
+        const chunks = [];
+        res.on('data', (chunk) => chunks.push(chunk));
+        res.on('end', () => {
+          const text = Buffer.concat(chunks).toString('utf8');
+          if ((res.statusCode || 0) < 200 || (res.statusCode || 0) >= 300) {
+            reject(new Error(`HTTP ${res.statusCode}: ${text}`));
+            return;
+          }
+          try {
+            resolve({
+              executeUrl,
+              data: JSON.parse(text)
+            });
+          } catch (error) {
+            reject(new Error(`Response is not valid JSON: ${error.message}`));
+          }
+        });
+      }
+    );
+
+    req.on('timeout', () => {
+      req.destroy(new Error(`Request to ${executeUrl} timed out`));
+    });
+    req.on('error', (error) => {
+      reject(new Error(`Failed to reach ${executeUrl}: ${error.message}`));
+    });
+    req.write(body);
+    req.end();
+  });
+}
+
+async function handleRequest(message) {
+  const method = message.method;
+  const messageId = message.id;
+  const params = message.params || {};
+
+  if (method === 'initialize') {
+    return successResponse(messageId, {
+      protocolVersion: PROTOCOL_VERSION,
+      capabilities: { tools: { listChanged: false } },
+      serverInfo: { name: SERVER_NAME, version: SERVER_VERSION }
+    });
+  }
+
+  if (method === 'notifications/initialized') {
+    return null;
+  }
+
+  if (method === 'ping') {
+    return successResponse(messageId, {});
+  }
+
+  if (method === 'tools/list') {
+    return successResponse(messageId, {
+      tools: [
+        {
+          name: TOOL_NAME,
+          description: 'Generate Worsoft frontend files and return a per-file manifest. Supports tableIds or dsName plus tableName, including master-child templates.',
+          inputSchema: TOOL_SCHEMA
+        }
+      ]
+    });
+  }
+
+  if (method === 'tools/call') {
+    if (params.name !== TOOL_NAME) {
+      return successResponse(messageId, toolErrorResult(`Unknown tool: ${params.name}`));
+    }
+    try {
+      const argumentsObject = validateArguments(params.arguments || {});
+      const response = await callExecute(argumentsObject);
+      return successResponse(messageId, toolResultFromResponse(response));
+    } catch (error) {
+      return successResponse(messageId, toolErrorResult(error.message));
+    }
+  }
+
+  return errorResponse(messageId, -32601, `Method not found: ${method}`);
+}
+
+let buffer = Buffer.alloc(0);
+let processing = false;
+
+async function drainBuffer() {
+  if (processing) {
+    return;
+  }
+  processing = true;
+  try {
+    while (true) {
+      const separator = buffer.indexOf('\r\n\r\n');
+      if (separator === -1) {
+        return;
+      }
+      const headerText = buffer.subarray(0, separator).toString('utf8');
+      const headers = {};
+      for (const line of headerText.split('\r\n')) {
+        if (!line.trim()) {
+          continue;
+        }
+        const index = line.indexOf(':');
+        if (index === -1) {
+          continue;
+        }
+        headers[line.slice(0, index).trim().toLowerCase()] = line.slice(index + 1).trim();
+      }
+      const contentLength = Number(headers['content-length'] || '0');
+      if (!Number.isFinite(contentLength) || contentLength < 0) {
+        throw new Error('Missing valid Content-Length');
+      }
+      const totalLength = separator + 4 + contentLength;
+      if (buffer.length < totalLength) {
+        return;
+      }
+      const body = buffer.subarray(separator + 4, totalLength).toString('utf8');
+      buffer = buffer.subarray(totalLength);
+      const message = JSON.parse(body);
+      const response = await handleRequest(message);
+      if (response) {
+        writeMessage(response);
+      }
+    }
+  } finally {
+    processing = false;
+    if (buffer.length > 0) {
+      setImmediate(() => {
+        drainBuffer().catch((error) => {
+          console.error(error.stack || String(error));
+          process.exit(1);
+        });
+      });
+    }
+  }
+}
+
+process.stdin.on('data', (chunk) => {
+  buffer = Buffer.concat([buffer, chunk]);
+  drainBuffer().catch((error) => {
+    console.error(error.stack || String(error));
+    process.exit(1);
+  });
+});
+
+process.stdin.on('end', () => {
+  process.exit(0);
+});

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "worsoft-frontend-codegen-mcp",
+  "version": "0.1.0",
+  "description": "Worsoft frontend code generation MCP server.",
+  "license": "UNLICENSED",
+  "author": "worsoft <sw@worsoft.vip>",
+  "homepage": "https://www.worsoft.com",
+  "repository": {
+    "type": "git",
+    "url": "https://www.worsoft.com"
+  },
+  "bugs": {
+    "url": "https://www.worsoft.com"
+  },
+  "keywords": [
+    "mcp",
+    "worsoft",
+    "codegen",
+    "frontend"
+  ],
+  "type": "commonjs",
+  "bin": {
+    "worsoft-frontend-codegen-mcp": "mcp_server.js"
+  },
+  "files": [
+    "mcp_server.js",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}