@enfyra/mcp-server 0.0.8 → 0.0.10

package/package.json

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

package/src/index.mjs

@@ -351,6 +351,109 @@ server.tool('login', 'Force login to Enfyra and get new tokens', {
   return { content: [{ type: 'text', text: `Logged in successfully!\nToken expires: ${new Date(getTokenExpiry()).toISOString()}` }] };
 });
 
+// ============================================================================
+// PACKAGE TOOLS
+// ============================================================================
+
+server.tool(
+  'search_npm',
+  'Search NPM registry for packages. Returns name, version, description for installation.',
+  {
+    query: z.string().describe('Package name or search term (e.g., "axios", "node-ssh", "dayjs")'),
+    limit: z.number().optional().default(5).describe('Max results (default: 5)'),
+  },
+  async ({ query, limit }) => {
+    const url = `https://registry.npmjs.org/-/v1/search?text=${encodeURIComponent(query)}&size=${limit}`;
+    const response = await fetch(url);
+    if (!response.ok) throw new Error(`NPM search failed: ${response.statusText}`);
+    const data = await response.json();
+
+    const packages = data.objects.map((obj) => ({
+      name: obj.package.name,
+      version: obj.package.version,
+      description: obj.package.description || '',
+    }));
+
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({ packages, total: data.total }, null, 2),
+      }],
+    };
+  },
+);
+
+server.tool(
+  'install_package',
+  [
+    'Install an NPM package on Enfyra. Searches NPM registry for exact version, then creates package_definition record.',
+    'Enfyra handles the actual yarn add internally based on type.',
+    'Type "Server" = available in handlers/hooks as $ctx.$pkgs.packageName.',
+    'Type "App" = available in extensions via getPackages().',
+  ].join(' '),
+  {
+    name: z.string().describe('Exact NPM package name (e.g., "node-ssh", "axios")'),
+    type: z.enum(['Server', 'App']).default('Server').describe('Where to install: Server (handlers/hooks) or App (extensions)'),
+    version: z.string().optional().describe('Specific version. If omitted, fetches latest from NPM.'),
+  },
+  async ({ name, type, version }) => {
+    // Step 1: Get package info from NPM if version not specified
+    let pkgVersion = version;
+    let pkgDescription = '';
+
+    if (!pkgVersion) {
+      const npmUrl = `https://registry.npmjs.org/-/v1/search?text=${encodeURIComponent(name)}&size=5`;
+      const npmResponse = await fetch(npmUrl);
+      if (!npmResponse.ok) throw new Error(`NPM search failed: ${npmResponse.statusText}`);
+      const npmData = await npmResponse.json();
+
+      const exactMatch = npmData.objects.find((obj) => obj.package.name === name);
+      if (!exactMatch) throw new Error(`Package "${name}" not found on NPM`);
+
+      pkgVersion = exactMatch.package.version;
+      pkgDescription = exactMatch.package.description || '';
+    }
+
+    // Step 2: Check if already installed
+    const checkFilter = JSON.stringify({ name: { _eq: name } });
+    const existing = await fetchAPI(ENFYRA_API_URL, `/package_definition?filter=${encodeURIComponent(checkFilter)}&limit=1`);
+    if (existing.data && existing.data.length > 0) {
+      return {
+        content: [{
+          type: 'text',
+          text: `Package "${name}" is already installed (version: ${existing.data[0].version}, type: ${existing.data[0].type}).\n${JSON.stringify(existing.data[0], null, 2)}`,
+        }],
+      };
+    }
+
+    // Step 3: Get current user for installedBy
+    const me = await fetchAPI(ENFYRA_API_URL, '/me');
+    const userId = me.data?.[0]?.id || me.data?.[0]?._id;
+    if (!userId) throw new Error('Cannot get current user ID');
+
+    // Step 4: Install via package_definition
+    const body = {
+      name,
+      version: pkgVersion,
+      description: pkgDescription,
+      type,
+      installedBy: { id: userId },
+    };
+
+    const result = await fetchAPI(ENFYRA_API_URL, '/package_definition', {
+      method: 'POST',
+      body: JSON.stringify(body),
+    });
+
+    return {
+      content: [{
+        type: 'text',
+        text: `Package "${name}@${pkgVersion}" installed successfully (type: ${type}).\n${JSON.stringify(result, null, 2)}`,
+      }],
+    };
+  },
+);
+
 // ============================================================================
 // MENU & EXTENSION TOOLS
 // ============================================================================

package/src/lib/mcp-instructions.js

@@ -70,7 +70,7 @@ export function buildMcpServerInstructions(apiBaseUrl) {
     '- **`column_definition` has NO route** — do NOT call `query_table("column_definition", …)`. It will always 404.',
     '- To check which tables are accessible via MCP tools, call `get_all_routes` and look for the route whose `mainTable.id` matches the table you need, or `get_all_metadata` to see all table names.',
     '- **Tables confirmed to have REST routes (system):** `table_definition`, `route_definition`, `user_definition`, `setting_definition`, `ai_config_definition`, `role_definition`, `menu_definition`, `extension_definition`, `folder_definition`, `file_definition`, `file_permission_definition`, `package_definition`, `bootstrap_script_definition`, `storage_config_definition`, `ai_conversation_definition`, `ai_message_definition`, `websocket_definition`, `websocket_event_definition`, `oauth_config_definition`, `oauth_account_definition`, `method_definition`, `pre_hook_definition`, `post_hook_definition`, `route_handler_definition`, `route_permission_definition`.',
-    '- **Tables without REST routes (internal/system only):** `column_definition`, `relation_definition` — these are managed indirectly via `create_column`, `create_table`, or admin sync endpoints.',
+    '- **Tables without REST routes (internal/system only):** `column_definition`, `relation_definition` — these are managed indirectly via cascade on `table_definition` (PATCH /table_definition/{id} with columns/relations array). The `create_column` MCP tool handles this automatically.',
     '',
     '### Schema / table migration (sequential only)',
     '- When creating, updating, or deleting tables (or columns), run operations **one at a time**. The migration process locks the DB per operation.',
@@ -156,9 +156,13 @@ export function buildMcpServerInstructions(apiBaseUrl) {
     '- **type "page":** Full-page extension. Requires `menu: { id }` — create menu first (`create_menu` or `create_record` on `menu_definition`), find by path/label, then create extension with `menu: { id: menuId }`. `menu_definition` uses **label** not name — filter by `label` or `path`.',
     '- **type "widget":** Widget extension. No menu required. Embed via `<Widget :id="extensionId" />` in other extensions or pages.',
     '',
-    '#### NPM packages:',
-    '- Before using (e.g. dayjs, chart.js) — check `package_definition` (filter `type: App`, `name`, `isEnabled`). If not found, tell user to install via Settings → Packages.',
-    '- Use `getPackages([\'dayjs\'])` in code; call in `onMounted` or async handler.',
+    '#### NPM packages (install via MCP):',
+    '- **Use `install_package` tool** — just pass the package name and type. The tool auto-fetches version from NPM, checks if already installed, and creates the record.',
+    '- Example: `install_package({ name: "node-ssh", type: "Server" })` — that is all. Tool handles everything.',
+    '- **Search first with `search_npm`** if unsure of exact package name.',
+    '- **Server** packages → available as `$ctx.$pkgs.packageName` in handlers/hooks.',
+    '- **App** packages → available via `getPackages([\'dayjs\'])` in extensions (call in `onMounted`).',
+    '- **Do NOT use `create_record` on `package_definition` directly** — use `install_package` instead.',
     '',
     '#### Important patterns:',
     '- **useApi:** Must call `execute()` — does NOT auto-run. Supports batch operations with `ids` or `files` options.',

package/src/lib/table-tools.js

@@ -4,11 +4,23 @@
 import { z } from 'zod';
 import { fetchAPI } from './fetch.js';
 
+/**
+ * Helper: fetch table with columns and relations
+ */
+async function fetchTableWithDetails(ENFYRA_API_URL, tableId) {
+  const filter = encodeURIComponent(JSON.stringify({ id: { _eq: tableId } }));
+  const result = await fetchAPI(ENFYRA_API_URL, `/table_definition?filter=${filter}&limit=1&fields=*,columns.*,relations.*`);
+  return result?.data?.[0] || result?.[0] || null;
+}
+
 /**
  * Register table tools with MCP server
  */
 export function registerTableTools(server, ENFYRA_API_URL) {
   const apiBase = ENFYRA_API_URL.replace(/\/$/, '');
+
+  // ─── READ ───
+
   server.tool(
     'get_all_tables',
     'Get all table definitions in the system',
@@ -21,11 +33,13 @@ export function registerTableTools(server, ENFYRA_API_URL) {
     }
   );
 
+  // ─── CREATE TABLE ───
+
   server.tool(
     'create_table',
     [
       'Create a new table definition with an auto-included `id` primary key column.',
-      'Use create_column to add more columns after creation.',
+      'Use create_column to add more columns after creation (columns are managed via cascade PATCH on table_definition, NOT via /column_definition).',
       'Schema operations (create/update/delete table, add column) must run one at a time — migration locks DB; parallel calls will fail.',
       'Enfyra auto-creates a REST route at path `/<table_name>` (same segment as `name`, not alias).',
       'REST surface for that route (matches server route engine): 4 HTTP operations — GET `/<table>` (list/filter), POST `/<table>` (create), PATCH `/<table>/:id` (update), DELETE `/<table>/:id` (delete).',
@@ -57,6 +71,194 @@ export function registerTableTools(server, ENFYRA_API_URL) {
     }
   );
 
+  // ─── UPDATE TABLE ───
+
+  server.tool(
+    'update_table',
+    [
+      'Update table properties: name (rename), alias, description, isSingleRecord, uniques, indexes.',
+      'Does NOT modify columns or relations — use create_column, update_column, delete_column, create_relation for those.',
+      'Run schema changes sequentially — migration locks DB per operation.',
+    ].join(' '),
+    {
+      tableId: z.string().describe('Table definition ID.'),
+      name: z.string().optional().describe('New table name (rename). Lowercase with underscores.'),
+      alias: z.string().optional().describe('New table alias.'),
+      description: z.string().optional().describe('New description.'),
+      isSingleRecord: z.boolean().optional().describe('Set to true for single-record table (e.g., settings/config).'),
+    },
+    async ({ tableId, name, alias, description, isSingleRecord }) => {
+      const body = {};
+      if (name !== undefined) body.name = name;
+      if (alias !== undefined) body.alias = alias;
+      if (description !== undefined) body.description = description;
+      if (isSingleRecord !== undefined) body.isSingleRecord = isSingleRecord;
+
+      const result = await fetchAPI(ENFYRA_API_URL, `/table_definition/${tableId}`, {
+        method: 'PATCH',
+        body: JSON.stringify(body),
+      });
+      return {
+        content: [{ type: 'text', text: `Table ${tableId} updated.\n\n${JSON.stringify(result, null, 2)}` }],
+      };
+    }
+  );
+
+  // ─── DELETE TABLE ───
+
+  server.tool(
+    'delete_table',
+    [
+      'Delete a table and ALL associated data. This is DESTRUCTIVE and IRREVERSIBLE.',
+      'Deletes: table metadata, all columns, all relations (source + target), all routes, junction tables, FK columns from other tables, and the PHYSICAL DATABASE TABLE with ALL DATA.',
+      'Always confirm with the user before calling this tool.',
+    ].join(' '),
+    {
+      tableId: z.string().describe('Table definition ID to delete.'),
+    },
+    async ({ tableId }) => {
+      const result = await fetchAPI(ENFYRA_API_URL, `/table_definition/${tableId}`, {
+        method: 'DELETE',
+      });
+      return {
+        content: [{ type: 'text', text: `Table ${tableId} deleted.\n\n${JSON.stringify(result, null, 2)}` }],
+      };
+    }
+  );
+
+  // ─── CREATE COLUMN ───
+
+  server.tool(
+    'create_column',
+    [
+      'Add a column to an existing table via PATCH /table_definition/{tableId}.',
+      'Columns are managed through cascade with table_definition — there is NO direct /column_definition endpoint.',
+      'This tool fetches existing columns, appends the new one, and PATCHes the table.',
+      'Run schema changes sequentially — migration locks DB per operation.',
+    ].join(' '),
+    {
+      tableId: z.string().describe('Table definition ID (from get_all_tables or create_table).'),
+      name: z.string().describe('Column name (e.g., "title", "user_id"). Lowercase with underscores.'),
+      type: z.string().describe('Column type: varchar, int, text, boolean, datetime, json, decimal, timestamp, uuid, bigint, float, longtext, richtext, simple-json, code, enum, array-select, date.'),
+      isNullable: z.boolean().optional().default(true).describe('Set to false if column cannot be null.'),
+      isUnique: z.boolean().optional().default(false).describe('Set to true for unique constraint.'),
+      defaultValue: z.string().optional().describe('Default value as JSON string.'),
+      description: z.string().optional().describe('Column description.'),
+      options: z.string().optional().describe('Column options as JSON string (e.g., enum values).'),
+    },
+    async ({ tableId, name, type, isNullable, isUnique, defaultValue, description, options }) => {
+      const tableData = await fetchTableWithDetails(ENFYRA_API_URL, tableId);
+      if (!tableData) {
+        return { content: [{ type: 'text', text: `Error: Table with ID ${tableId} not found.` }] };
+      }
+
+      const existingColumns = (tableData.columns || []).map(col => ({ id: col.id }));
+      const newCol = { name, type, isNullable: isNullable ?? true };
+      if (isUnique) newCol.isUnique = true;
+      if (defaultValue !== undefined) newCol.defaultValue = defaultValue;
+      if (description) newCol.description = description;
+      if (options) newCol.options = JSON.parse(options);
+
+      const result = await fetchAPI(ENFYRA_API_URL, `/table_definition/${tableId}`, {
+        method: 'PATCH',
+        body: JSON.stringify({ columns: [...existingColumns, newCol] }),
+      });
+
+      return {
+        content: [{ type: 'text', text: `Column "${name}" added to table ${tableId}.\n\n${JSON.stringify(result, null, 2)}` }],
+      };
+    }
+  );
+
+  // ─── UPDATE COLUMN ───
+
+  server.tool(
+    'update_column',
+    [
+      'Update an existing column on a table via PATCH /table_definition/{tableId}.',
+      'Fetches all columns, modifies the target column, and PATCHes the table.',
+      'Run schema changes sequentially — migration locks DB per operation.',
+    ].join(' '),
+    {
+      tableId: z.string().describe('Table definition ID.'),
+      columnId: z.string().describe('Column definition ID to update.'),
+      name: z.string().optional().describe('New column name.'),
+      type: z.string().optional().describe('New column type.'),
+      isNullable: z.boolean().optional().describe('Set nullable.'),
+      isHidden: z.boolean().optional().describe('Hide column from API responses.'),
+      defaultValue: z.string().optional().describe('New default value as JSON string.'),
+      description: z.string().optional().describe('New description.'),
+      options: z.string().optional().describe('New options as JSON string.'),
+    },
+    async ({ tableId, columnId, name, type, isNullable, isHidden, defaultValue, description, options }) => {
+      const tableData = await fetchTableWithDetails(ENFYRA_API_URL, tableId);
+      if (!tableData) {
+        return { content: [{ type: 'text', text: `Error: Table with ID ${tableId} not found.` }] };
+      }
+
+      const columns = (tableData.columns || []).map(col => {
+        if (String(col.id) === String(columnId)) {
+          const updated = { id: col.id };
+          if (name !== undefined) updated.name = name;
+          if (type !== undefined) updated.type = type;
+          if (isNullable !== undefined) updated.isNullable = isNullable;
+          if (isHidden !== undefined) updated.isHidden = isHidden;
+          if (defaultValue !== undefined) updated.defaultValue = defaultValue;
+          if (description !== undefined) updated.description = description;
+          if (options !== undefined) updated.options = JSON.parse(options);
+          return updated;
+        }
+        return { id: col.id };
+      });
+
+      const result = await fetchAPI(ENFYRA_API_URL, `/table_definition/${tableId}`, {
+        method: 'PATCH',
+        body: JSON.stringify({ columns }),
+      });
+
+      return {
+        content: [{ type: 'text', text: `Column ${columnId} updated on table ${tableId}.\n\n${JSON.stringify(result, null, 2)}` }],
+      };
+    }
+  );
+
+  // ─── DELETE COLUMN ───
+
+  server.tool(
+    'delete_column',
+    [
+      'Delete a column from a table via PATCH /table_definition/{tableId}.',
+      'Fetches all columns, removes the target, and PATCHes the table.',
+      'The physical column is dropped from the database. System columns (id, createdAt, updatedAt) cannot be deleted.',
+      'Run schema changes sequentially — migration locks DB per operation.',
+    ].join(' '),
+    {
+      tableId: z.string().describe('Table definition ID.'),
+      columnId: z.string().describe('Column definition ID to delete.'),
+    },
+    async ({ tableId, columnId }) => {
+      const tableData = await fetchTableWithDetails(ENFYRA_API_URL, tableId);
+      if (!tableData) {
+        return { content: [{ type: 'text', text: `Error: Table with ID ${tableId} not found.` }] };
+      }
+
+      const columns = (tableData.columns || [])
+        .filter(col => String(col.id) !== String(columnId))
+        .map(col => ({ id: col.id }));
+
+      const result = await fetchAPI(ENFYRA_API_URL, `/table_definition/${tableId}`, {
+        method: 'PATCH',
+        body: JSON.stringify({ columns }),
+      });
+
+      return {
+        content: [{ type: 'text', text: `Column ${columnId} deleted from table ${tableId}.\n\n${JSON.stringify(result, null, 2)}` }],
+      };
+    }
+  );
+
+  // ─── CREATE RELATION ───
+
   server.tool(
     'create_relation',
     [
@@ -85,26 +287,36 @@ export function registerTableTools(server, ENFYRA_API_URL) {
     }
   );
 
+  // ─── DELETE RELATION ───
+
   server.tool(
-    'create_column',
-    'Create a column for an existing table. Columns cascade through table_definition. Run schema changes sequentially — migration locks DB per operation.',
+    'delete_relation',
+    [
+      'Delete a relation from a table via PATCH /table_definition/{tableId}.',
+      'Fetches all relations, removes the target, and PATCHes the table.',
+      'Drops FK columns and junction tables (for many-to-many).',
+    ].join(' '),
     {
-      tableId: z.string().describe('Table definition ID (from get_all_tables or create_table).'),
-      name: z.string().describe('Column name (e.g., "title", "user_id"). Lowercase with underscores.'),
-      type: z.string().describe('Column type: varchar, int, text, boolean, datetime, json, decimal, etc.'),
-      length: z.number().optional().describe('Length for varchar types (e.g., 255).'),
-      isRequired: z.boolean().optional().default(false).describe('Set to true if column cannot be null.'),
-      isUnique: z.boolean().optional().default(false).describe('Set to true for unique constraint.'),
-      defaultValue: z.string().optional().describe('Default value as JSON string.'),
-      description: z.string().optional().describe('Column description.'),
+      tableId: z.string().describe('Table definition ID (source table of the relation).'),
+      relationId: z.string().describe('Relation definition ID to delete.'),
     },
-    async ({ tableId, name, type, length, isRequired, isUnique, defaultValue, description }) => {
-      const result = await fetchAPI(ENFYRA_API_URL, '/column_definition', {
-        method: 'POST',
-        body: JSON.stringify({ tableId, name, type, length, isRequired, isUnique, defaultValue, description }),
+    async ({ tableId, relationId }) => {
+      const tableData = await fetchTableWithDetails(ENFYRA_API_URL, tableId);
+      if (!tableData) {
+        return { content: [{ type: 'text', text: `Error: Table with ID ${tableId} not found.` }] };
+      }
+
+      const relations = (tableData.relations || [])
+        .filter(rel => String(rel.id) !== String(relationId))
+        .map(rel => ({ id: rel.id }));
+
+      const result = await fetchAPI(ENFYRA_API_URL, `/table_definition/${tableId}`, {
+        method: 'PATCH',
+        body: JSON.stringify({ relations }),
       });
+
       return {
-        content: [{ type: 'text', text: `Column created with ID: ${result.id}.\n\n${JSON.stringify(result, null, 2)}` }],
+        content: [{ type: 'text', text: `Relation ${relationId} deleted from table ${tableId}.\n\n${JSON.stringify(result, null, 2)}` }],
       };
     }
   );