@neverinfamous/mysql-mcp 2.3.0 → 3.0.0

package/src/adapters/mysql/tools/codemode/__tests__/codemode-tool.test.ts

@@ -0,0 +1,227 @@
+/**
+ * mysql-mcp - Code Mode Tool Unit Tests
+ *
+ * Tests for createExecuteCodeTool, getCodeModeTools, and cleanupCodeMode.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import {
+  createExecuteCodeTool,
+  getCodeModeTools,
+  cleanupCodeMode,
+} from "../index.js";
+import type { MySQLAdapter } from "../../../MySQLAdapter.js";
+import type { ToolDefinition } from "../../../../../types/index.js";
+
+// Suppress logger
+vi.mock("../../../../../utils/logger.js", () => ({
+  logger: { info: vi.fn(), warning: vi.fn(), error: vi.fn() },
+}));
+
+/**
+ * Create a mock adapter sufficient for Code Mode usage
+ */
+function createCodeModeMockAdapter(): MySQLAdapter {
+  const mockTools: ToolDefinition[] = [
+    {
+      name: "mysql_read_query",
+      group: "core",
+      title: "Read Query",
+      description: "Execute a read query",
+      inputSchema: { parse: (v: unknown) => v } as never,
+      requiredScopes: ["read"],
+      annotations: { readOnlyHint: true },
+      handler: vi
+        .fn()
+        .mockResolvedValue({ rows: [{ id: 1 }], rowsAffected: 0 }),
+    },
+    {
+      name: "mysql_write_query",
+      group: "core",
+      title: "Write Query",
+      description: "Execute a write query",
+      inputSchema: { parse: (v: unknown) => v } as never,
+      requiredScopes: ["write"],
+      annotations: {},
+      handler: vi.fn().mockResolvedValue({ rows: [], rowsAffected: 1 }),
+    },
+  ];
+
+  return {
+    type: "mysql",
+    getToolDefinitions: vi.fn().mockReturnValue(mockTools),
+    createContext: vi.fn().mockReturnValue({
+      timestamp: new Date(),
+      requestId: "test-ctx",
+    }),
+    getActiveTransactionIds: vi.fn().mockReturnValue([]),
+    rollbackTransaction: vi.fn().mockResolvedValue(undefined),
+  } as unknown as MySQLAdapter;
+}
+
+describe("Code Mode Tool", () => {
+  let mockAdapter: MySQLAdapter;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    process.env["CODEMODE_ISOLATION"] = "vm";
+    mockAdapter = createCodeModeMockAdapter();
+  });
+
+  afterEach(() => {
+    cleanupCodeMode();
+    delete process.env["CODEMODE_ISOLATION"];
+  });
+
+  // ===========================================================================
+  // createExecuteCodeTool
+  // ===========================================================================
+  describe("createExecuteCodeTool", () => {
+    it("should create tool with correct definition", () => {
+      const tool = createExecuteCodeTool(mockAdapter);
+      expect(tool.name).toBe("mysql_execute_code");
+      expect(tool.group).toBe("codemode");
+      expect(tool.requiredScopes).toContain("admin");
+    });
+
+    it("should have proper annotations", () => {
+      const tool = createExecuteCodeTool(mockAdapter);
+      expect(tool.annotations?.destructiveHint).toBe(true);
+      expect(tool.annotations?.readOnlyHint).toBe(false);
+    });
+
+    it("should reject invalid code (blocked patterns)", async () => {
+      const tool = createExecuteCodeTool(mockAdapter);
+      const result = (await tool.handler(
+        { code: 'require("fs")' },
+        { timestamp: new Date(), requestId: "test" },
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("validation failed");
+    });
+
+    it("should reject empty code", async () => {
+      const tool = createExecuteCodeTool(mockAdapter);
+      const result = (await tool.handler(
+        { code: "" },
+        { timestamp: new Date(), requestId: "test" },
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("validation failed");
+    });
+
+    it("should execute valid code successfully", async () => {
+      const tool = createExecuteCodeTool(mockAdapter);
+      const result = (await tool.handler(
+        { code: "return 42" },
+        { timestamp: new Date(), requestId: "test" },
+      )) as { success: boolean; result: unknown; hint: string };
+
+      expect(result.success).toBe(true);
+      expect(result.result).toBe(42);
+      expect(result.hint).toContain("mysql.help()");
+    });
+
+    it("should handle execution errors gracefully", async () => {
+      const tool = createExecuteCodeTool(mockAdapter);
+      const result = (await tool.handler(
+        { code: 'throw new Error("test fail")' },
+        { timestamp: new Date(), requestId: "test" },
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("test fail");
+    });
+
+    it("should cleanup orphaned transactions", async () => {
+      // Simulate a transaction that starts during execution
+      const getActiveIds = mockAdapter.getActiveTransactionIds as ReturnType<
+        typeof vi.fn
+      >;
+      getActiveIds
+        .mockReturnValueOnce([]) // before execution
+        .mockReturnValueOnce(["orphan-txn-1"]); // after execution
+
+      const tool = createExecuteCodeTool(mockAdapter);
+      await tool.handler(
+        { code: "return 'done'" },
+        { timestamp: new Date(), requestId: "test" },
+      );
+
+      expect(mockAdapter.rollbackTransaction).toHaveBeenCalledWith(
+        "orphan-txn-1",
+      );
+    });
+
+    it("should handle rollback errors gracefully during cleanup", async () => {
+      const getActiveIds = mockAdapter.getActiveTransactionIds as ReturnType<
+        typeof vi.fn
+      >;
+      getActiveIds.mockReturnValueOnce([]).mockReturnValueOnce(["bad-txn"]);
+
+      (
+        mockAdapter.rollbackTransaction as ReturnType<typeof vi.fn>
+      ).mockRejectedValueOnce(new Error("rollback failed"));
+
+      const tool = createExecuteCodeTool(mockAdapter);
+      // Should not throw even though rollback fails
+      const result = (await tool.handler(
+        { code: "return 'done'" },
+        { timestamp: new Date(), requestId: "test" },
+      )) as { success: boolean };
+
+      expect(result.success).toBe(true);
+    });
+  });
+
+  // ===========================================================================
+  // getCodeModeTools
+  // ===========================================================================
+  describe("getCodeModeTools", () => {
+    it("should return array with execute code tool", () => {
+      const tools = getCodeModeTools(mockAdapter);
+      expect(tools).toHaveLength(1);
+      expect(tools[0].name).toBe("mysql_execute_code");
+    });
+  });
+
+  // ===========================================================================
+  // cleanupCodeMode
+  // ===========================================================================
+  describe("cleanupCodeMode", () => {
+    it("should clean up without error when not initialized", () => {
+      expect(() => cleanupCodeMode()).not.toThrow();
+    });
+
+    it("should clean up after initialization", async () => {
+      // Initialize by executing
+      const tool = createExecuteCodeTool(mockAdapter);
+      await tool.handler(
+        { code: "return 1" },
+        { timestamp: new Date(), requestId: "test" },
+      );
+      // Clean up
+      expect(() => cleanupCodeMode()).not.toThrow();
+    });
+
+    it("should allow re-initialization after cleanup", async () => {
+      const tool = createExecuteCodeTool(mockAdapter);
+      await tool.handler(
+        { code: "return 1" },
+        { timestamp: new Date(), requestId: "test" },
+      );
+      cleanupCodeMode();
+
+      // Re-execute should work
+      const result = (await tool.handler(
+        { code: "return 2" },
+        { timestamp: new Date(), requestId: "test" },
+      )) as { success: boolean; result: unknown };
+
+      expect(result.success).toBe(true);
+      expect(result.result).toBe(2);
+    });
+  });
+});

package/src/adapters/mysql/tools/codemode/index.ts

@@ -13,6 +13,7 @@ import type {
 } from "../../../../types/index.js";
 import {
   createSandboxPool,
+  getDefaultSandboxMode,
   type ISandboxPool,
   type SandboxMode,
 } from "../../../../codemode/sandbox-factory.js";
@@ -68,7 +69,8 @@ let securityManager: CodeModeSecurityManager | null = null;
 function getIsolationMode(): SandboxMode {
   const envMode = process.env["CODEMODE_ISOLATION"];
   if (envMode === "worker") return "worker";
-  return "vm"; // Default
+  if (envMode === "vm") return "vm";
+  return getDefaultSandboxMode();
 }
 
 /**
@@ -162,8 +164,8 @@ return results;
         };
       }
 
-      // Create mysql API bindings
-      const mysqlApi = createMysqlApi(adapter);
+      // Create mysql API bindings (readonly filtering applied when readonly: true)
+      const mysqlApi = createMysqlApi(adapter, readonly);
       const bindings = mysqlApi.createSandboxBindings();
 
       // Validate bindings are populated

package/src/adapters/mysql/tools/core.ts

@@ -24,6 +24,14 @@ import {
   GetIndexesSchemaBase,
   ListTablesSchema,
 } from "../types.js";
+import { ZodError } from "zod";
+
+/**
+ * Extract human-readable messages from a ZodError instead of raw JSON array
+ */
+function formatZodError(error: ZodError): string {
+  return error.issues.map((i) => i.message).join("; ");
+}
 
 /**
  * Pre-compiled identifier validation patterns (hoisted for performance)
@@ -83,11 +91,15 @@ function createReadQueryTool(adapter: MySQLAdapter): ToolDefinition {
       idempotentHint: true,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const {
-        query,
-        params: queryParams,
-        transactionId,
-      } = ReadQuerySchema.parse(params);
+      let parsed;
+      try {
+        parsed = ReadQuerySchema.parse(params);
+      } catch (err: unknown) {
+        if (err instanceof ZodError)
+          return { success: false, error: formatZodError(err) };
+        throw err;
+      }
+      const { query, params: queryParams, transactionId } = parsed;
       try {
         const result = await adapter.executeReadQuery(
           query,
@@ -123,11 +135,15 @@ function createWriteQueryTool(adapter: MySQLAdapter): ToolDefinition {
       readOnlyHint: false,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const {
-        query,
-        params: queryParams,
-        transactionId,
-      } = WriteQuerySchema.parse(params);
+      let parsed;
+      try {
+        parsed = WriteQuerySchema.parse(params);
+      } catch (err: unknown) {
+        if (err instanceof ZodError)
+          return { success: false, error: formatZodError(err) };
+        throw err;
+      }
+      const { query, params: queryParams, transactionId } = parsed;
       try {
         const result = await adapter.executeWriteQuery(
           query,
@@ -163,18 +179,47 @@ function createListTablesTool(adapter: MySQLAdapter): ToolDefinition {
       idempotentHint: true,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const { database } = ListTablesSchema.parse(params);
-      const tables = await adapter.listTables(database);
-      return {
-        tables: tables.map((t) => ({
-          name: t.name,
-          type: t.type,
-          engine: t.engine,
-          rowCount: t.rowCount,
-          comment: t.comment,
-        })),
-        count: tables.length,
-      };
+      let parsed;
+      try {
+        parsed = ListTablesSchema.parse(params);
+      } catch (err: unknown) {
+        if (err instanceof ZodError)
+          return { success: false, error: formatZodError(err) };
+        throw err;
+      }
+      const { database } = parsed;
+
+      // P154: Pre-check database existence when explicitly provided
+      if (database) {
+        const dbCheck = await adapter.executeReadQuery(
+          `SELECT SCHEMA_NAME FROM information_schema.SCHEMATA WHERE SCHEMA_NAME = ?`,
+          [database],
+        );
+        if (!dbCheck.rows || dbCheck.rows.length === 0) {
+          return {
+            exists: false,
+            database,
+            message: `Database '${database}' does not exist`,
+          };
+        }
+      }
+
+      try {
+        const tables = await adapter.listTables(database);
+        return {
+          tables: tables.map((t) => ({
+            name: t.name,
+            type: t.type,
+            engine: t.engine,
+            rowCount: t.rowCount,
+            comment: t.comment,
+          })),
+          count: tables.length,
+        };
+      } catch (err: unknown) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { success: false, error: message };
+      }
     },
   };
 }
@@ -196,7 +241,15 @@ function createDescribeTableTool(adapter: MySQLAdapter): ToolDefinition {
       idempotentHint: true,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const { table } = DescribeTableSchema.parse(params);
+      let parsed;
+      try {
+        parsed = DescribeTableSchema.parse(params);
+      } catch (err: unknown) {
+        if (err instanceof ZodError)
+          return { success: false, error: formatZodError(err) };
+        throw err;
+      }
+      const { table } = parsed;
       const tableInfo = await adapter.describeTable(table);
       // Graceful handling for non-existent tables
       if (!tableInfo.columns || tableInfo.columns.length === 0) {
@@ -227,8 +280,32 @@ function createCreateTableTool(adapter: MySQLAdapter): ToolDefinition {
       readOnlyHint: false,
     },
     handler: async (params: unknown, _context: RequestContext) => {
+      let parsed;
+      try {
+        parsed = CreateTableSchema.parse(params);
+      } catch (err: unknown) {
+        if (err instanceof ZodError)
+          return { success: false, error: formatZodError(err) };
+        throw err;
+      }
       const { name, columns, engine, charset, collate, comment, ifNotExists } =
-        CreateTableSchema.parse(params);
+        parsed;
+
+      // Pre-check existence for skipped indicator when ifNotExists is true
+      if (ifNotExists) {
+        const checkName = name.includes(".")
+          ? (name.split(".")[1] ?? name)
+          : name;
+        const tableInfo = await adapter.describeTable(checkName);
+        if (tableInfo.columns && tableInfo.columns.length > 0) {
+          return {
+            success: true,
+            skipped: true,
+            tableName: name,
+            reason: "Table already exists",
+          };
+        }
+      }
 
       // Build column definitions
       const columnDefs = columns.map((col) => {
@@ -310,12 +387,13 @@ function createCreateTableTool(adapter: MySQLAdapter): ToolDefinition {
         if (message.includes("already exists")) {
           return {
             success: false,
-            reason: `Table '${name}' already exists`,
+            error: `Table '${name}' already exists`,
           };
         }
-        throw err;
+        return { success: false, error: message };
       }
 
+      adapter.clearSchemaCache();
       return { success: true, tableName: name };
     },
   };
@@ -337,11 +415,19 @@ function createDropTableTool(adapter: MySQLAdapter): ToolDefinition {
       destructiveHint: true,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const { table, ifExists } = DropTableSchema.parse(params);
+      let parsed;
+      try {
+        parsed = DropTableSchema.parse(params);
+      } catch (err: unknown) {
+        if (err instanceof ZodError)
+          return { success: false, error: formatZodError(err) };
+        throw err;
+      }
+      const { table, ifExists } = parsed;
 
       // Validate table name
       if (!isValidId(table)) {
-        throw new Error("Invalid table name");
+        return { success: false, error: "Invalid table name" };
       }
 
       // Pre-check existence for skipped indicator when ifExists is true
@@ -363,12 +449,14 @@ function createDropTableTool(adapter: MySQLAdapter): ToolDefinition {
         if (message.includes("Unknown table")) {
           return {
             success: false,
-            reason: `Table '${table}' does not exist`,
+            error: `Table '${table}' does not exist`,
           };
         }
-        throw err;
+        return { success: false, error: message };
       }
 
+      adapter.clearSchemaCache();
+
       if (tableAbsent) {
         return {
           success: true,
@@ -400,7 +488,15 @@ function createGetIndexesTool(adapter: MySQLAdapter): ToolDefinition {
       idempotentHint: true,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const { table } = GetIndexesSchema.parse(params);
+      let parsed;
+      try {
+        parsed = GetIndexesSchema.parse(params);
+      } catch (err: unknown) {
+        if (err instanceof ZodError)
+          return { success: false, error: formatZodError(err) };
+        throw err;
+      }
+      const { table } = parsed;
       // First check if table exists by describing it
       const tableInfo = await adapter.describeTable(table);
       if (!tableInfo.columns || tableInfo.columns.length === 0) {
@@ -433,16 +529,22 @@ function createCreateIndexTool(adapter: MySQLAdapter): ToolDefinition {
       readOnlyHint: false,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const { name, table, columns, unique, type, ifNotExists } =
-        CreateIndexSchema.parse(params);
+      let parsed;
+      try {
+        parsed = CreateIndexSchema.parse(params);
+      } catch (err: unknown) {
+        if (err instanceof ZodError)
+          return { success: false, error: formatZodError(err) };
+        throw err;
+      }
+      const { name, table, columns, unique, type, ifNotExists } = parsed;
 
       // Validate names
       if (!VALID_INDEX_NAME_PATTERN.test(name)) {
-        // Index names usually don't have schema prefix
-        throw new Error("Invalid index name");
+        return { success: false, error: "Invalid index name" };
       }
       if (!isValidId(table)) {
-        throw new Error("Invalid table name");
+        return { success: false, error: "Invalid table name" };
       }
 
       const columnList = columns.map((c) => `\`${c}\``).join(", ");
@@ -478,15 +580,27 @@ function createCreateIndexTool(adapter: MySQLAdapter): ToolDefinition {
         if (message.includes("Duplicate key name")) {
           return {
             success: false,
-            reason: `Index '${name}' already exists on table '${table}'`,
+            error: `Index '${name}' already exists on table '${table}'`,
+          };
+        }
+        // Distinguish column errors from table errors
+        if (message.includes("Key column")) {
+          const colMatch = /Key column '([^']+)'/.exec(message);
+          return {
+            success: false,
+            error: colMatch
+              ? `Column '${colMatch[1]}' does not exist in table '${table}'`
+              : `Column does not exist in table '${table}'`,
           };
         }
         if (message.includes("doesn't exist")) {
           return { exists: false, table };
         }
-        throw err;
+        return { success: false, error: message };
       }
 
+      adapter.clearSchemaCache();
+
       // Warn if HASH was requested on a non-MEMORY engine (InnoDB silently converts to BTREE)
       if (type === "HASH") {
         return {