@enfyra/mcp-server 0.0.59 → 0.0.60

package/README.md

@@ -215,7 +215,7 @@ When an LLM builds a Nuxt, Next, or other SSR frontend for Enfyra, follow the sa
 
 ## Tools (summary)
 
-Metadata, examples, query/CRUD, route/handler/hook, tables/columns, reload cache, logs, user/roles, login, menu/extension, `get_enfyra_api_context`. For full tool list and behavior, see the app after enabling MCP or the source in `src/mcp-server-entry.mjs`.
+Metadata, examples, query/CRUD, method management, route/handler/hook, tables/columns, reload cache, logs, user/roles, login, menu/extension, `get_enfyra_api_context`. For full tool list and behavior, see the app after enabling MCP or the source in `src/mcp-server-entry.mjs`.
 
 Use `get_enfyra_examples` when asking an LLM to generate concrete Enfyra implementation patterns. It returns categorized examples for SSR app auth/OAuth/proxy setup, schema/relations, queries/deep, handlers/hooks, permissions/RLS, websocket, flows, files, and extensions.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@enfyra/mcp-server",
-  "version": "0.0.59",
+  "version": "0.0.60",
   "description": "MCP server for Enfyra - manage your Enfyra instance via Claude Code",
   "type": "module",
   "license": "MIT",

package/src/lib/mcp-examples.js

@@ -785,6 +785,28 @@ return {
     title: 'Dynamic app extensions and menus',
     useWhen: 'Use when adding custom UI pages to the Enfyra app.',
     examples: [
+      {
+        name: 'Create or update HTTP method colors',
+        code: `list_methods()
+
+create_method({
+  method: "PUT",
+  buttonColor: "#e0e7ff",
+  textColor: "#4338ca"
+})
+
+update_method({
+  method: "PATCH",
+  buttonColor: "#fef3c7",
+  textColor: "#b45309"
+})`,
+        notes: [
+          'Use dedicated method tools instead of generic CRUD on method_definition.',
+          'buttonColor is the badge background and textColor is the badge text color.',
+          'The eApp management UI is /settings/methods.',
+          'delete_method is preview-first and should only be used for unused custom methods.',
+        ],
+      },
       {
         name: 'Create menu then extension',
         code: `create_menu({

package/src/lib/mcp-instructions.js

@@ -306,6 +306,7 @@ export function buildMcpServerInstructions(apiBaseUrl) {
     '- **Do not misuse PageHeader stats:** `PageHeader.stats` renders prominent stat cards inside the shell header. Do not put normal operational KPIs, capacity totals, billing totals, or detail metrics there by default; keep those as body cards/tables where the operator can scan them with the page content. Only use PageHeader stats for a deliberately compact overview page where the stats are truly header-level context.',
     '- **Page actions belong in registries:** Move page-level buttons into `useHeaderActionRegistry` or `useSubHeaderActionRegistry`; keep the extension body for operational content only. Sensitive registry actions must include a `permission` condition, for example `{ id: "create", label: "Create report", permission: { and: [{ route: "/report_definition", methods: ["POST"] }] }, onClick }`.',
     '- **Header action button variants:** choose the button variant by intent. Use `color: "primary", variant: "solid"` for the main page action. Use `color: "neutral", variant: "ghost"` for back/navigation actions and `color: "neutral", variant: "outline"` for visible secondary actions. `variant: "soft"` is only for low-emphasis secondary/chrome actions; do not use soft for critical or primary header actions just because it looks acceptable in dark mode.',
+    '- **HTTP method management:** use the dedicated MCP tools `list_methods`, `create_method`, `update_method`, and preview-first `delete_method` for `method_definition`. The eApp UI for the same records is `/settings/methods`. Method color fields are `buttonColor` for badge background and `textColor` for badge text, both full hex colors. Do not use generic `create_record` on `method_definition` unless the dedicated tool is unavailable.',
     '- **Extension navigation:** prefer `NuxtLink` or Nuxt UI components with `:to` for visible navigation links and drill-down cards/buttons. Use `navigateTo(...)` only for imperative navigation after submit, confirm, mutation, or another side effect.',
     '- **Extension runtime scope:** eApp exposes Vue APIs and injected Nuxt/Enfyra composables both to script global scope and Vue app `globalProperties`. Template expressions may call injected helpers directly, for example after a save handler can call `navigateTo("/data/report_definition")`, because Vue compiles template helpers to `_ctx.*`.',
     '- **Extension CSS affects shell utility ordering:** dynamic extension CSS is injected after the app shell CSS. Shell/page-header code must not put conflicting plain Tailwind utilities on the same element, such as `flex-col` plus `flex-row`, `items-start` plus `items-center`, or `text-left` plus `text-center`. Choose one mutually exclusive class per state; otherwise extension CSS can change which utility wins and shift shell layout.',

package/src/mcp-server-entry.mjs

@@ -356,6 +356,31 @@ function appendQuery(path, queryParams) {
   return `${path}${path.includes('?') ? '&' : '?'}${queryParams}`;
 }
 
+const METHOD_NAME_RE = /^[A-Z][A-Z0-9_]*$/;
+const HEX_COLOR_RE = /^#[0-9a-fA-F]{6}$/;
+
+function normalizeMethodNameInput(method) {
+  const value = String(method || '').trim().toUpperCase();
+  if (!METHOD_NAME_RE.test(value)) {
+    throw new Error('Method must start with A-Z and contain only uppercase letters, numbers, or underscore.');
+  }
+  return value;
+}
+
+function normalizeHexColorInput(value, fieldName) {
+  const color = String(value || '').trim().toLowerCase();
+  if (!HEX_COLOR_RE.test(color)) {
+    throw new Error(`${fieldName} must be a full hex color such as #1d4ed8.`);
+  }
+  return color;
+}
+
+async function findMethodRecordByName(method) {
+  const filter = encodeURIComponent(JSON.stringify({ method: { _eq: method } }));
+  const result = await fetchAPI(ENFYRA_API_URL, `/method_definition?filter=${filter}&limit=1&fields=id,_id,method,buttonColor,textColor,isSystem`);
+  return unwrapData(result)[0] || null;
+}
+
 // Create MCP server — `instructions` is sent to the host (e.g. Claude Code) for the LLM; not README
 const server = new McpServer(
   {
@@ -1020,6 +1045,154 @@ server.tool('delete_record', 'Delete a record by ID', {
   }, null, 2) }] };
 });
 
+server.tool(
+  'list_methods',
+  'List method_definition records with their UI colors. Use this before creating route methods or method-colored UI.',
+  {},
+  async () => {
+    const result = await fetchAPI(ENFYRA_API_URL, '/method_definition?fields=id,_id,method,buttonColor,textColor,isSystem&sort=method&limit=0');
+    const methods = unwrapData(result).map((method) => ({
+      id: getId(method),
+      method: method.method,
+      buttonColor: method.buttonColor,
+      textColor: method.textColor,
+      isSystem: method.isSystem === true,
+    }));
+    return { content: [{ type: 'text', text: JSON.stringify({
+      tableName: 'method_definition',
+      methods,
+      appUi: '/settings/methods',
+    }, null, 2) }] };
+  },
+);
+
+server.tool(
+  'create_method',
+  'Create a method_definition record with app badge colors. Prefer this over generic create_record for method_definition.',
+  {
+    method: z.string().describe('Uppercase method name, e.g. GET, POST, PUT, CUSTOM_METHOD. Must start with A-Z and contain only A-Z, 0-9, or underscore.'),
+    buttonColor: z.string().describe('Badge background color as full hex, e.g. #dbeafe.'),
+    textColor: z.string().describe('Badge text color as full hex, e.g. #1d4ed8.'),
+    isSystem: z.boolean().optional().default(false).describe('Set true only for built-in/runtime-owned methods. Normal app methods should leave this false.'),
+  },
+  async ({ method, buttonColor, textColor, isSystem }) => {
+    const normalizedMethod = normalizeMethodNameInput(method);
+    const existing = await findMethodRecordByName(normalizedMethod);
+    if (existing) {
+      throw new Error(`Method ${normalizedMethod} already exists with id ${getId(existing)}. Use update_method to change colors.`);
+    }
+    const body = {
+      method: normalizedMethod,
+      buttonColor: normalizeHexColorInput(buttonColor, 'buttonColor'),
+      textColor: normalizeHexColorInput(textColor, 'textColor'),
+      isSystem: isSystem === true,
+    };
+    const result = await fetchAPI(ENFYRA_API_URL, '/method_definition', {
+      method: 'POST',
+      body: JSON.stringify(body),
+    });
+    _methodMap = null;
+    return { content: [{ type: 'text', text: JSON.stringify({
+      ...summarizeMutationResult(result, 'created', 'method_definition'),
+      method: normalizedMethod,
+      appUi: '/settings/methods',
+    }, null, 2) }] };
+  },
+);
+
+server.tool(
+  'update_method',
+  'Update a method_definition record color pair, and optionally rename non-system methods. Prefer this over generic update_record for method_definition.',
+  {
+    id: z.string().optional().describe('Method record id. If omitted, method is used to find the record.'),
+    method: z.string().optional().describe('Existing method name to find, or new name when id is provided.'),
+    buttonColor: z.string().optional().describe('Badge background color as full hex, e.g. #dbeafe.'),
+    textColor: z.string().optional().describe('Badge text color as full hex, e.g. #1d4ed8.'),
+  },
+  async ({ id, method, buttonColor, textColor }) => {
+    let targetId = id;
+    let existing = null;
+    if (!targetId) {
+      if (!method) throw new Error('Provide id or method.');
+      const normalizedMethod = normalizeMethodNameInput(method);
+      existing = await findMethodRecordByName(normalizedMethod);
+      if (!existing) throw new Error(`Method ${normalizedMethod} was not found.`);
+      targetId = getId(existing);
+    }
+
+    const body = {};
+    if (buttonColor !== undefined) {
+      body.buttonColor = normalizeHexColorInput(buttonColor, 'buttonColor');
+    }
+    if (textColor !== undefined) {
+      body.textColor = normalizeHexColorInput(textColor, 'textColor');
+    }
+    if (method !== undefined && id) {
+      body.method = normalizeMethodNameInput(method);
+    }
+    if (Object.keys(body).length === 0) {
+      throw new Error('Provide buttonColor, textColor, or a new method name.');
+    }
+
+    const result = await fetchAPI(ENFYRA_API_URL, `/method_definition/${encodeURIComponent(String(targetId))}`, {
+      method: 'PATCH',
+      body: JSON.stringify(body),
+    });
+    _methodMap = null;
+    return { content: [{ type: 'text', text: JSON.stringify({
+      ...summarizeMutationResult(result, 'updated', 'method_definition'),
+      id: targetId,
+      appUi: '/settings/methods',
+    }, null, 2) }] };
+  },
+);
+
+server.tool(
+  'delete_method',
+  'Preview or delete a method_definition record. Only delete unused custom methods; system/default methods should be kept.',
+  {
+    id: z.string().optional().describe('Method record id. If omitted, method is used to find the record.'),
+    method: z.string().optional().describe('Method name to find when id is omitted.'),
+    confirm: z.boolean().optional().default(false).describe('Required true to apply the destructive delete. Omit/false returns a preview only.'),
+  },
+  async ({ id, method, confirm }) => {
+    let targetId = id;
+    let target = null;
+    if (!targetId) {
+      if (!method) throw new Error('Provide id or method.');
+      target = await findMethodRecordByName(normalizeMethodNameInput(method));
+      if (!target) throw new Error(`Method ${method} was not found.`);
+      targetId = getId(target);
+    }
+    if (!confirm) {
+      if (!target) {
+        const primaryKey = await getPrimaryFieldName('method_definition');
+        const filter = encodeURIComponent(JSON.stringify({ [primaryKey]: { _eq: targetId } }));
+        const result = await fetchAPI(ENFYRA_API_URL, `/method_definition?filter=${filter}&limit=1&fields=id,_id,method,buttonColor,textColor,isSystem`);
+        target = unwrapData(result)[0] || null;
+      }
+      return { content: [{ type: 'text', text: JSON.stringify({
+        action: 'delete_method_preview',
+        id: targetId,
+        method: target?.method,
+        isSystem: target?.isSystem === true,
+        destructive: true,
+        warning: 'Only delete unused custom methods. Deleting a method can affect route method relations.',
+        next: 'Call delete_method again with confirm=true to delete.',
+      }, null, 2) }] };
+    }
+    const result = await fetchAPI(ENFYRA_API_URL, `/method_definition/${encodeURIComponent(String(targetId))}`, { method: 'DELETE' });
+    _methodMap = null;
+    return { content: [{ type: 'text', text: JSON.stringify({
+      action: 'deleted',
+      tableName: 'method_definition',
+      id: targetId,
+      statusCode: result?.statusCode,
+      success: result?.success,
+    }, null, 2) }] };
+  },
+);
+
 server.tool(
   'run_admin_test',
   [