chore: import upstream snapshot with attribution

apps/sim/tools/mysql/delete.ts

@@ -0,0 +1,102 @@
+import type { MySQLDeleteParams, MySQLResponse } from '@/tools/mysql/types'
+import type { ToolConfig } from '@/tools/types'
+
+export const deleteTool: ToolConfig<MySQLDeleteParams, MySQLResponse> = {
+  id: 'mysql_delete',
+  name: 'MySQL Delete',
+  description: 'Delete records from MySQL database',
+  version: '1.0',
+
+  params: {
+    host: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'MySQL server hostname or IP address',
+    },
+    port: {
+      type: 'number',
+      required: true,
+      visibility: 'user-only',
+      description: 'MySQL server port (default: 3306)',
+    },
+    database: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Database name to connect to (e.g., my_database)',
+    },
+    username: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'Database username',
+    },
+    password: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'Database password',
+    },
+    ssl: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'SSL connection mode (disabled, required, preferred)',
+    },
+    table: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Table name to delete from (e.g., users, orders)',
+    },
+    where: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'WHERE clause condition (without WHERE keyword)',
+    },
+  },
+
+  request: {
+    url: '/api/tools/mysql/delete',
+    method: 'POST',
+    headers: () => ({
+      'Content-Type': 'application/json',
+    }),
+    body: (params) => ({
+      host: params.host,
+      port: Number(params.port),
+      database: params.database,
+      username: params.username,
+      password: params.password,
+      ssl: params.ssl || 'required',
+      table: params.table,
+      where: params.where,
+    }),
+  },
+
+  transformResponse: async (response: Response) => {
+    const data = await response.json()
+
+    if (!response.ok) {
+      throw new Error(data.error || 'MySQL delete failed')
+    }
+
+    return {
+      success: true,
+      output: {
+        message: data.message || 'Data deleted successfully',
+        rows: data.rows || [],
+        rowCount: data.rowCount || 0,
+      },
+      error: undefined,
+    }
+  },
+
+  outputs: {
+    message: { type: 'string', description: 'Operation status message' },
+    rows: { type: 'array', description: 'Array of deleted rows' },
+    rowCount: { type: 'number', description: 'Number of rows deleted' },
+  },
+}

apps/sim/tools/mysql/execute.ts

@@ -0,0 +1,96 @@
+import type { MySQLExecuteParams, MySQLResponse } from '@/tools/mysql/types'
+import type { ToolConfig } from '@/tools/types'
+
+export const executeTool: ToolConfig<MySQLExecuteParams, MySQLResponse> = {
+  id: 'mysql_execute',
+  name: 'MySQL Execute',
+  description: 'Execute raw SQL query on MySQL database',
+  version: '1.0',
+
+  params: {
+    host: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'MySQL server hostname or IP address',
+    },
+    port: {
+      type: 'number',
+      required: true,
+      visibility: 'user-only',
+      description: 'MySQL server port (default: 3306)',
+    },
+    database: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Database name to connect to (e.g., my_database)',
+    },
+    username: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'Database username',
+    },
+    password: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'Database password',
+    },
+    ssl: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'SSL connection mode (disabled, required, preferred)',
+    },
+    query: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description:
+        'Raw SQL query to execute (e.g., CREATE TABLE users (id INT PRIMARY KEY, name VARCHAR(255)))',
+    },
+  },
+
+  request: {
+    url: '/api/tools/mysql/execute',
+    method: 'POST',
+    headers: () => ({
+      'Content-Type': 'application/json',
+    }),
+    body: (params) => ({
+      host: params.host,
+      port: Number(params.port),
+      database: params.database,
+      username: params.username,
+      password: params.password,
+      ssl: params.ssl || 'required',
+      query: params.query,
+    }),
+  },
+
+  transformResponse: async (response: Response) => {
+    const data = await response.json()
+
+    if (!response.ok) {
+      throw new Error(data.error || 'MySQL execute failed')
+    }
+
+    return {
+      success: true,
+      output: {
+        message: data.message || 'Query executed successfully',
+        rows: data.rows || [],
+        rowCount: data.rowCount || 0,
+      },
+      error: undefined,
+    }
+  },
+
+  outputs: {
+    message: { type: 'string', description: 'Operation status message' },
+    rows: { type: 'array', description: 'Array of rows returned from the query' },
+    rowCount: { type: 'number', description: 'Number of rows affected' },
+  },
+}

apps/sim/tools/mysql/index.ts

@@ -0,0 +1,15 @@
+import { deleteTool } from './delete'
+import { executeTool } from './execute'
+import { insertTool } from './insert'
+import { introspectTool } from './introspect'
+import { queryTool } from './query'
+import { updateTool } from './update'
+
+export const mysqlDeleteTool = deleteTool
+export const mysqlExecuteTool = executeTool
+export const mysqlInsertTool = insertTool
+export const mysqlIntrospectTool = introspectTool
+export const mysqlQueryTool = queryTool
+export const mysqlUpdateTool = updateTool
+
+export * from './types'

apps/sim/tools/mysql/insert.ts

@@ -0,0 +1,102 @@
+import type { MySQLInsertParams, MySQLResponse } from '@/tools/mysql/types'
+import type { ToolConfig } from '@/tools/types'
+
+export const insertTool: ToolConfig<MySQLInsertParams, MySQLResponse> = {
+  id: 'mysql_insert',
+  name: 'MySQL Insert',
+  description: 'Insert new record into MySQL database',
+  version: '1.0',
+
+  params: {
+    host: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'MySQL server hostname or IP address',
+    },
+    port: {
+      type: 'number',
+      required: true,
+      visibility: 'user-only',
+      description: 'MySQL server port (default: 3306)',
+    },
+    database: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Database name to connect to (e.g., my_database)',
+    },
+    username: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'Database username',
+    },
+    password: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'Database password',
+    },
+    ssl: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'SSL connection mode (disabled, required, preferred)',
+    },
+    table: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Table name to insert into (e.g., users, orders)',
+    },
+    data: {
+      type: 'object',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Data to insert as key-value pairs',
+    },
+  },
+
+  request: {
+    url: '/api/tools/mysql/insert',
+    method: 'POST',
+    headers: () => ({
+      'Content-Type': 'application/json',
+    }),
+    body: (params) => ({
+      host: params.host,
+      port: Number(params.port),
+      database: params.database,
+      username: params.username,
+      password: params.password,
+      ssl: params.ssl || 'required',
+      table: params.table,
+      data: params.data,
+    }),
+  },
+
+  transformResponse: async (response: Response) => {
+    const data = await response.json()
+
+    if (!response.ok) {
+      throw new Error(data.error || 'MySQL insert failed')
+    }
+
+    return {
+      success: true,
+      output: {
+        message: data.message || 'Data inserted successfully',
+        rows: data.rows || [],
+        rowCount: data.rowCount || 0,
+      },
+      error: undefined,
+    }
+  },
+
+  outputs: {
+    message: { type: 'string', description: 'Operation status message' },
+    rows: { type: 'array', description: 'Array of inserted rows' },
+    rowCount: { type: 'number', description: 'Number of rows inserted' },
+  },
+}

apps/sim/tools/mysql/introspect.ts

@@ -0,0 +1,92 @@
+import type { MySQLIntrospectParams, MySQLIntrospectResponse } from '@/tools/mysql/types'
+import type { ToolConfig } from '@/tools/types'
+
+export const introspectTool: ToolConfig<MySQLIntrospectParams, MySQLIntrospectResponse> = {
+  id: 'mysql_introspect',
+  name: 'MySQL Introspect',
+  description:
+    'Introspect MySQL database schema to retrieve table structures, columns, and relationships',
+  version: '1.0',
+
+  params: {
+    host: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'MySQL server hostname or IP address',
+    },
+    port: {
+      type: 'number',
+      required: true,
+      visibility: 'user-only',
+      description: 'MySQL server port (default: 3306)',
+    },
+    database: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Database name to connect to (e.g., my_database)',
+    },
+    username: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'Database username',
+    },
+    password: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'Database password',
+    },
+    ssl: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'SSL connection mode (disabled, required, preferred)',
+    },
+  },
+
+  request: {
+    url: '/api/tools/mysql/introspect',
+    method: 'POST',
+    headers: () => ({
+      'Content-Type': 'application/json',
+    }),
+    body: (params) => ({
+      host: params.host,
+      port: Number(params.port),
+      database: params.database,
+      username: params.username,
+      password: params.password,
+      ssl: params.ssl || 'required',
+    }),
+  },
+
+  transformResponse: async (response: Response) => {
+    const data = await response.json()
+
+    if (!response.ok) {
+      throw new Error(data.error || 'MySQL introspection failed')
+    }
+
+    return {
+      success: true,
+      output: {
+        message: data.message || 'Schema introspection completed successfully',
+        tables: data.tables || [],
+        databases: data.databases || [],
+      },
+      error: undefined,
+    }
+  },
+
+  outputs: {
+    message: { type: 'string', description: 'Operation status message' },
+    tables: {
+      type: 'array',
+      description: 'Array of table schemas with columns, keys, and indexes',
+    },
+    databases: { type: 'array', description: 'List of available databases on the server' },
+  },
+}

apps/sim/tools/mysql/query.ts

@@ -0,0 +1,95 @@
+import type { MySQLQueryParams, MySQLResponse } from '@/tools/mysql/types'
+import type { ToolConfig } from '@/tools/types'
+
+export const queryTool: ToolConfig<MySQLQueryParams, MySQLResponse> = {
+  id: 'mysql_query',
+  name: 'MySQL Query',
+  description: 'Execute SELECT query on MySQL database',
+  version: '1.0',
+
+  params: {
+    host: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'MySQL server hostname or IP address',
+    },
+    port: {
+      type: 'number',
+      required: true,
+      visibility: 'user-only',
+      description: 'MySQL server port (default: 3306)',
+    },
+    database: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Database name to connect to (e.g., my_database)',
+    },
+    username: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'Database username',
+    },
+    password: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'Database password',
+    },
+    ssl: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'SSL connection mode (disabled, required, preferred)',
+    },
+    query: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'SQL SELECT query to execute (e.g., SELECT * FROM users WHERE active = 1)',
+    },
+  },
+
+  request: {
+    url: '/api/tools/mysql/query',
+    method: 'POST',
+    headers: () => ({
+      'Content-Type': 'application/json',
+    }),
+    body: (params) => ({
+      host: params.host,
+      port: Number(params.port),
+      database: params.database,
+      username: params.username,
+      password: params.password,
+      ssl: params.ssl || 'required',
+      query: params.query,
+    }),
+  },
+
+  transformResponse: async (response: Response) => {
+    const data = await response.json()
+
+    if (!response.ok) {
+      throw new Error(data.error || 'MySQL query failed')
+    }
+
+    return {
+      success: true,
+      output: {
+        message: data.message || 'Query executed successfully',
+        rows: data.rows || [],
+        rowCount: data.rowCount || 0,
+      },
+      error: undefined,
+    }
+  },
+
+  outputs: {
+    message: { type: 'string', description: 'Operation status message' },
+    rows: { type: 'array', description: 'Array of rows returned from the query' },
+    rowCount: { type: 'number', description: 'Number of rows returned' },
+  },
+}

apps/sim/tools/mysql/types.ts

@@ -0,0 +1,77 @@
+import type { ToolResponse } from '@/tools/types'
+
+interface MySQLConnectionConfig {
+  host: string
+  port: number
+  database: string
+  username: string
+  password: string
+  ssl: 'disabled' | 'required' | 'preferred'
+}
+
+export interface MySQLQueryParams extends MySQLConnectionConfig {
+  query: string
+}
+
+export interface MySQLInsertParams extends MySQLConnectionConfig {
+  table: string
+  data: Record<string, unknown>
+}
+
+export interface MySQLUpdateParams extends MySQLConnectionConfig {
+  table: string
+  data: Record<string, unknown>
+  where: string
+}
+
+export interface MySQLDeleteParams extends MySQLConnectionConfig {
+  table: string
+  where: string
+}
+
+export interface MySQLExecuteParams extends MySQLConnectionConfig {
+  query: string
+}
+
+interface MySQLBaseResponse extends ToolResponse {
+  output: {
+    message: string
+    rows: unknown[]
+    rowCount: number
+  }
+  error?: string
+}
+
+interface MySQLQueryResponse extends MySQLBaseResponse {}
+interface MySQLInsertResponse extends MySQLBaseResponse {}
+interface MySQLUpdateResponse extends MySQLBaseResponse {}
+interface MySQLDeleteResponse extends MySQLBaseResponse {}
+interface MySQLExecuteResponse extends MySQLBaseResponse {}
+export interface MySQLResponse extends MySQLBaseResponse {}
+
+export interface MySQLIntrospectParams extends MySQLConnectionConfig {}
+
+interface MySQLTableColumn {
+  name: string
+  type: string
+  nullable: boolean
+  default: string | null
+  isPrimaryKey: boolean
+  isForeignKey: boolean
+  autoIncrement: boolean
+  references?: { table: string; column: string }
+}
+
+interface MySQLTableSchema {
+  name: string
+  database: string
+  columns: MySQLTableColumn[]
+  primaryKey: string[]
+  foreignKeys: Array<{ column: string; referencesTable: string; referencesColumn: string }>
+  indexes: Array<{ name: string; columns: string[]; unique: boolean }>
+}
+
+export interface MySQLIntrospectResponse extends ToolResponse {
+  output: { message: string; tables: MySQLTableSchema[]; databases: string[] }
+  error?: string
+}

apps/sim/tools/mysql/update.ts

@@ -0,0 +1,109 @@
+import type { MySQLResponse, MySQLUpdateParams } from '@/tools/mysql/types'
+import type { ToolConfig } from '@/tools/types'
+
+export const updateTool: ToolConfig<MySQLUpdateParams, MySQLResponse> = {
+  id: 'mysql_update',
+  name: 'MySQL Update',
+  description: 'Update existing records in MySQL database',
+  version: '1.0',
+
+  params: {
+    host: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'MySQL server hostname or IP address',
+    },
+    port: {
+      type: 'number',
+      required: true,
+      visibility: 'user-only',
+      description: 'MySQL server port (default: 3306)',
+    },
+    database: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Database name to connect to (e.g., my_database)',
+    },
+    username: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'Database username',
+    },
+    password: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'Database password',
+    },
+    ssl: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'SSL connection mode (disabled, required, preferred)',
+    },
+    table: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Table name to update (e.g., users, orders)',
+    },
+    data: {
+      type: 'object',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Data to update as key-value pairs',
+    },
+    where: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'WHERE clause condition (without WHERE keyword)',
+    },
+  },
+
+  request: {
+    url: '/api/tools/mysql/update',
+    method: 'POST',
+    headers: () => ({
+      'Content-Type': 'application/json',
+    }),
+    body: (params) => ({
+      host: params.host,
+      port: Number(params.port),
+      database: params.database,
+      username: params.username,
+      password: params.password,
+      ssl: params.ssl || 'required',
+      table: params.table,
+      data: params.data,
+      where: params.where,
+    }),
+  },
+
+  transformResponse: async (response: Response) => {
+    const data = await response.json()
+
+    if (!response.ok) {
+      throw new Error(data.error || 'MySQL update failed')
+    }
+
+    return {
+      success: true,
+      output: {
+        message: data.message || 'Data updated successfully',
+        rows: data.rows || [],
+        rowCount: data.rowCount || 0,
+      },
+      error: undefined,
+    }
+  },
+
+  outputs: {
+    message: { type: 'string', description: 'Operation status message' },
+    rows: { type: 'array', description: 'Array of updated rows' },
+    rowCount: { type: 'number', description: 'Number of rows updated' },
+  },
+}