@gokiteam/goki-dev 0.2.0

package/src/mcp/tools/functions.js

@@ -0,0 +1,380 @@
+import { z } from 'zod'
+
+export function registerFunctionsTools (server, apiClient) {
+  server.tool(
+    'functions_create',
+    'Register and deploy a Cloud Function in the dev-tools emulator',
+    {
+      name: z.string().describe('Unique function name (alphanumeric, hyphens, underscores)'),
+      source: z.string().optional().describe('Inline function source code'),
+      sourcePath: z.string().optional().describe('Absolute path to the function source directory'),
+      entryPoint: z.string().describe('Name of the exported function to invoke'),
+      triggerType: z.enum(['http', 'pubsub', 'firestore', 'scheduler']).describe('How the function is triggered'),
+      triggerConfig: z.record(z.any()).optional().describe('Trigger-specific config (e.g. { topic: "myTopic" } for pubsub)'),
+      signatureType: z.enum(['cloudevent', 'http']).optional().describe('Function signature type'),
+      runtime: z.string().optional().describe('Runtime identifier (default: nodejs20)'),
+      environmentVariables: z.record(z.string()).optional().describe('Environment variables for the function process'),
+      timeoutSeconds: z.number().optional().describe('Maximum execution time in seconds (1-540)'),
+      description: z.string().optional().describe('Human-readable description')
+    },
+    async ({ name, source, sourcePath, entryPoint, triggerType, triggerConfig, signatureType, runtime, environmentVariables, timeoutSeconds, description }) => {
+      try {
+        const body = { name, entryPoint, triggerType }
+        if (source !== undefined) body.source = source
+        if (sourcePath !== undefined) body.sourcePath = sourcePath
+        if (triggerConfig !== undefined) body.triggerConfig = triggerConfig
+        if (signatureType !== undefined) body.signatureType = signatureType
+        if (runtime !== undefined) body.runtime = runtime
+        if (environmentVariables !== undefined) body.environmentVariables = environmentVariables
+        if (timeoutSeconds !== undefined) body.timeoutSeconds = timeoutSeconds
+        if (description !== undefined) body.description = description
+        const data = await apiClient.post('/v1/functions/create', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to create function: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'functions_list',
+    'List all registered Cloud Functions in the dev-tools emulator',
+    {
+      triggerType: z.enum(['http', 'pubsub', 'firestore', 'scheduler']).optional().describe('Filter by trigger type'),
+      status: z.enum(['stopped', 'starting', 'running', 'error']).optional().describe('Filter by status'),
+      limit: z.number().optional().describe('Maximum number of results'),
+      offset: z.number().optional().describe('Offset for pagination')
+    },
+    async ({ triggerType, status, limit, offset }) => {
+      try {
+        const body = {}
+        const filter = {}
+        if (triggerType !== undefined) filter.triggerType = triggerType
+        if (status !== undefined) filter.status = status
+        if (Object.keys(filter).length > 0) body.filter = filter
+        if (limit !== undefined) body.limit = limit
+        if (offset !== undefined) body.offset = offset
+        const data = await apiClient.post('/v1/functions/list', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to list functions: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'functions_details',
+    'Get details of a specific Cloud Function by id or name',
+    {
+      id: z.string().optional().describe('Function ID'),
+      name: z.string().optional().describe('Function name')
+    },
+    async ({ id, name }) => {
+      try {
+        const body = {}
+        if (id !== undefined) body.id = id
+        if (name !== undefined) body.name = name
+        const data = await apiClient.post('/v1/functions/details', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to get function details: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'functions_update',
+    'Update configuration of a Cloud Function',
+    {
+      id: z.string().optional().describe('Function ID'),
+      name: z.string().optional().describe('Function name'),
+      description: z.string().optional().describe('Updated description'),
+      triggerConfig: z.record(z.any()).optional().describe('Updated trigger configuration'),
+      enabled: z.boolean().optional().describe('Enable or disable the function'),
+      environmentVariables: z.record(z.string()).optional().describe('Updated environment variables'),
+      timeoutSeconds: z.number().optional().describe('Updated timeout in seconds'),
+      entryPoint: z.string().optional().describe('Updated entry point'),
+      signatureType: z.enum(['cloudevent', 'http']).optional().describe('Updated signature type')
+    },
+    async ({ id, name, description, triggerConfig, enabled, environmentVariables, timeoutSeconds, entryPoint, signatureType }) => {
+      try {
+        const body = {}
+        if (id !== undefined) body.id = id
+        if (name !== undefined) body.name = name
+        if (description !== undefined) body.description = description
+        if (triggerConfig !== undefined) body.triggerConfig = triggerConfig
+        if (enabled !== undefined) body.enabled = enabled
+        if (environmentVariables !== undefined) body.environmentVariables = environmentVariables
+        if (timeoutSeconds !== undefined) body.timeoutSeconds = timeoutSeconds
+        if (entryPoint !== undefined) body.entryPoint = entryPoint
+        if (signatureType !== undefined) body.signatureType = signatureType
+        const data = await apiClient.post('/v1/functions/update', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to update function: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'functions_delete',
+    'Delete a Cloud Function from the dev-tools emulator',
+    {
+      id: z.string().optional().describe('Function ID'),
+      name: z.string().optional().describe('Function name')
+    },
+    async ({ id, name }) => {
+      try {
+        const body = {}
+        if (id !== undefined) body.id = id
+        if (name !== undefined) body.name = name
+        const data = await apiClient.post('/v1/functions/delete', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to delete function: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'functions_start',
+    'Start a stopped Cloud Function',
+    {
+      id: z.string().optional().describe('Function ID'),
+      name: z.string().optional().describe('Function name')
+    },
+    async ({ id, name }) => {
+      try {
+        const body = {}
+        if (id !== undefined) body.id = id
+        if (name !== undefined) body.name = name
+        const data = await apiClient.post('/v1/functions/start', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to start function: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'functions_stop',
+    'Stop a running Cloud Function',
+    {
+      id: z.string().optional().describe('Function ID'),
+      name: z.string().optional().describe('Function name')
+    },
+    async ({ id, name }) => {
+      try {
+        const body = {}
+        if (id !== undefined) body.id = id
+        if (name !== undefined) body.name = name
+        const data = await apiClient.post('/v1/functions/stop', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to stop function: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'functions_restart',
+    'Restart a Cloud Function (stop then start)',
+    {
+      id: z.string().optional().describe('Function ID'),
+      name: z.string().optional().describe('Function name')
+    },
+    async ({ id, name }) => {
+      try {
+        const body = {}
+        if (id !== undefined) body.id = id
+        if (name !== undefined) body.name = name
+        const data = await apiClient.post('/v1/functions/restart', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to restart function: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'functions_invoke',
+    'Manually invoke a Cloud Function with a custom payload',
+    {
+      id: z.string().optional().describe('Function ID'),
+      name: z.string().optional().describe('Function name'),
+      payload: z.any().optional().describe('Payload to pass as CloudEvent data')
+    },
+    async ({ id, name, payload }) => {
+      try {
+        const body = {}
+        if (id !== undefined) body.id = id
+        if (name !== undefined) body.name = name
+        if (payload !== undefined) body.payload = payload
+        const data = await apiClient.post('/v1/functions/invoke', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to invoke function: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'functions_invocations_list',
+    'List invocation history for Cloud Functions',
+    {
+      functionId: z.string().optional().describe('Filter by function ID'),
+      functionName: z.string().optional().describe('Filter by function name'),
+      triggerType: z.string().optional().describe('Filter by trigger type'),
+      limit: z.number().optional().describe('Maximum number of results (default: 50)'),
+      offset: z.number().optional().describe('Offset for pagination')
+    },
+    async ({ functionId, functionName, triggerType, limit, offset }) => {
+      try {
+        const body = {}
+        if (functionId !== undefined) body.functionId = functionId
+        if (functionName !== undefined) body.functionName = functionName
+        if (triggerType !== undefined) body.triggerType = triggerType
+        if (limit !== undefined) body.limit = limit
+        if (offset !== undefined) body.offset = offset
+        const data = await apiClient.post('/v1/functions/invocations/list', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to list invocations: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'functions_stats',
+    'Get aggregate statistics for Cloud Functions (counts by trigger type, status, invocations)',
+    {},
+    async () => {
+      try {
+        const data = await apiClient.post('/v1/functions/stats')
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to get functions stats: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'functions_dependencies_read',
+    'Read the package.json for a Cloud Function to see its npm dependencies',
+    {
+      name: z.string().describe('Function name')
+    },
+    async ({ name }) => {
+      try {
+        const data = await apiClient.post('/v1/functions/dependencies/read', { name })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to read dependencies: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'functions_dependencies_update',
+    'Update the package.json for a Cloud Function and optionally run npm install',
+    {
+      name: z.string().describe('Function name'),
+      packageJson: z.string().describe('Full package.json content as a JSON string'),
+      install: z.boolean().optional().describe('Whether to run npm install after writing (default: true)')
+    },
+    async ({ name, packageJson, install }) => {
+      try {
+        const body = { name, packageJson }
+        if (install !== undefined) body.install = install
+        const data = await apiClient.post('/v1/functions/dependencies/update', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to update dependencies: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'functions_files_list',
+    'List all files in a Cloud Function source directory (excludes node_modules)',
+    {
+      id: z.string().optional().describe('Function ID'),
+      name: z.string().optional().describe('Function name')
+    },
+    async ({ id, name }) => {
+      try {
+        const body = {}
+        if (id !== undefined) body.id = id
+        if (name !== undefined) body.name = name
+        const data = await apiClient.post('/v1/functions/files/list', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to list files: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'functions_files_read',
+    'Read a file from a Cloud Function source directory',
+    {
+      id: z.string().optional().describe('Function ID'),
+      name: z.string().optional().describe('Function name'),
+      filePath: z.string().describe('Relative file path within the function source directory')
+    },
+    async ({ id, name, filePath }) => {
+      try {
+        const body = { filePath }
+        if (id !== undefined) body.id = id
+        if (name !== undefined) body.name = name
+        const data = await apiClient.post('/v1/functions/files/read', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to read file: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'functions_files_write',
+    'Write a file in a Cloud Function source directory',
+    {
+      id: z.string().optional().describe('Function ID'),
+      name: z.string().optional().describe('Function name'),
+      filePath: z.string().describe('Relative file path within the function source directory'),
+      content: z.string().describe('File content to write')
+    },
+    async ({ id, name, filePath, content }) => {
+      try {
+        const body = { filePath, content }
+        if (id !== undefined) body.id = id
+        if (name !== undefined) body.name = name
+        const data = await apiClient.post('/v1/functions/files/write', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to write file: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'functions_files_delete',
+    'Delete a file from a Cloud Function source directory',
+    {
+      id: z.string().optional().describe('Function ID'),
+      name: z.string().optional().describe('Function name'),
+      filePath: z.string().describe('Relative file path within the function source directory')
+    },
+    async ({ id, name, filePath }) => {
+      try {
+        const body = { filePath }
+        if (id !== undefined) body.id = id
+        if (name !== undefined) body.name = name
+        const data = await apiClient.post('/v1/functions/files/delete', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to delete file: ${error.message}` }], isError: true }
+      }
+    }
+  )
+}

package/src/mcp/tools/httpTraffic.js

@@ -0,0 +1,69 @@
+import { z } from 'zod'
+
+export function registerHttpTrafficTools (server, apiClient) {
+  server.tool(
+    'http_traffic_list',
+    'List recorded HTTP traffic between microservices (captured by the dev-tools proxy)',
+    {
+      filter: z.record(z.any()).optional().describe('Optional filter criteria (method, targetHost, sourceService, statusCode, traceId)'),
+      limit: z.number().optional().describe('Maximum number of records to return'),
+      offset: z.number().optional().describe('Number of records to skip for pagination')
+    },
+    async ({ filter, limit, offset }) => {
+      try {
+        const body = {}
+        if (filter !== undefined) body.filter = filter
+        if (limit !== undefined) body.limit = limit
+        if (offset !== undefined) body.offset = offset
+        const data = await apiClient.post('/v1/http-traffic/list', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to list HTTP traffic: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'http_traffic_details',
+    'Get full request/response details of an HTTP traffic entry including headers and body',
+    {
+      id: z.string().describe('ID of the HTTP traffic entry to retrieve')
+    },
+    async ({ id }) => {
+      try {
+        const data = await apiClient.post('/v1/http-traffic/details', { id })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to get HTTP traffic details: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'http_traffic_clear',
+    'Clear all recorded HTTP traffic',
+    {},
+    async () => {
+      try {
+        const data = await apiClient.post('/v1/http-traffic/clear')
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to clear HTTP traffic: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'http_traffic_stats',
+    'Get HTTP traffic statistics grouped by host, method, and error rates',
+    {},
+    async () => {
+      try {
+        const data = await apiClient.post('/v1/http-traffic/stats')
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to get HTTP traffic stats: ${error.message}` }], isError: true }
+      }
+    }
+  )
+}

package/src/mcp/tools/logging.js

@@ -0,0 +1,174 @@
+import { z } from 'zod'
+
+export function registerLoggingTools (server, apiClient) {
+  server.tool(
+    'logging_list_services',
+    'List all services that have sent log entries to the dev-tools logging emulator',
+    {},
+    async () => {
+      try {
+        const data = await apiClient.post('/v1/logging/services/list')
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to list services: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'logging_list_entries',
+    'List log entries with optional filters for service name, severity level, and search text. Supports pagination. Use compact=true (default) for an overview with just id, timestamp, severity, service, message, and error — then call logging_get_entries with specific IDs to get full details.',
+    {
+      serviceName: z.string().optional().describe('Filter by service name (e.g., "core-pms", "integration-apaleo")'),
+      severity: z.string().optional().describe('Filter by severity level: DEBUG, INFO, NOTICE, WARNING, ERROR, CRITICAL, ALERT, EMERGENCY'),
+      textContains: z.string().optional().describe('Search for text in log messages (case-sensitive substring match)'),
+      traceId: z.string().optional().describe('Filter by trace ID to see all logs for a specific request'),
+      sinceTimestamp: z.string().optional().describe('ISO timestamp - only show logs after this time (e.g., "2024-01-01T00:00:00Z")'),
+      untilTimestamp: z.string().optional().describe('ISO timestamp - only show logs before this time'),
+      compact: z.boolean().optional().describe('Return compact entries with only key fields. Default: true. Set to false for full entries.'),
+      limit: z.number().optional().describe('Max entries to return (default: 100, max: 1000)'),
+      offset: z.number().optional().describe('Skip this many entries for pagination (default: 0)')
+    },
+    async ({ serviceName, severity, textContains, traceId, sinceTimestamp, untilTimestamp, compact, limit, offset }) => {
+      try {
+        const filter = {}
+        if (serviceName) filter.serviceName = serviceName
+        if (severity) filter.severity = severity
+        if (textContains) filter.textPayload = { $regex: textContains }
+        if (traceId) filter.trace = traceId
+        if (sinceTimestamp || untilTimestamp) {
+          filter.timestamp = {}
+          if (sinceTimestamp) filter.timestamp.$gte = sinceTimestamp
+          if (untilTimestamp) filter.timestamp.$lte = untilTimestamp
+        }
+        const page = {}
+        if (limit !== undefined) page.limit = Math.min(limit, 1000)
+        if (offset !== undefined) page.offset = offset
+        const body = { compact: compact !== false }
+        if (Object.keys(filter).length > 0) body.filter = filter
+        if (Object.keys(page).length > 0) body.page = page
+        const data = await apiClient.post('/v1/logging/entries/list', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to list log entries: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'logging_get_entries',
+    'Get full details of one or more log entries by their IDs. Use this after logging_list_entries (compact mode) to fetch complete details for specific entries you want to inspect.',
+    {
+      ids: z.array(z.string()).describe('Array of log entry IDs to retrieve (from the _id field in compact list results)')
+    },
+    async ({ ids }) => {
+      try {
+        const data = await apiClient.post('/v1/logging/entries/get', { ids })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to get log entries: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'logging_clear',
+    'Clear all log entries from the dev-tools logging emulator',
+    {},
+    async () => {
+      try {
+        const data = await apiClient.post('/v1/logging/entries/clear')
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to clear log entries: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'logging_export',
+    'Export log entries from the dev-tools logging emulator, optionally filtered by criteria',
+    {
+      filter: z.record(z.any()).optional().describe('Optional filter criteria to scope the export')
+    },
+    async ({ filter }) => {
+      try {
+        const body = {}
+        if (filter !== undefined) body.filter = filter
+        const data = await apiClient.post('/v1/logging/entries/export', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to export log entries: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'logging_get_trace',
+    'Get all log entries for a specific trace ID, useful for following a request across services',
+    {
+      traceId: z.string().describe('The trace ID to look up')
+    },
+    async ({ traceId }) => {
+      try {
+        const data = await apiClient.post(`/v1/logging/trace/${traceId}`)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to get trace: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'logging_wait_for',
+    'Wait for a log entry matching the filter criteria to appear. Blocks up to timeout seconds. Useful for verifying async operations completed.',
+    {
+      filter: z.record(z.any()).describe('Filter criteria the log entry must match'),
+      timeout: z.number().optional().describe('Maximum seconds to wait before timing out')
+    },
+    async ({ filter, timeout }) => {
+      try {
+        const body = { filter }
+        if (timeout !== undefined) body.timeout = timeout
+        const data = await apiClient.post('/v1/logging/entries/wait-for', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to wait for log entry: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'logging_assert_no_errors',
+    'Assert that no error-level log entries exist. Optionally scope to a specific traceId or time window. Returns errors if any are found.',
+    {
+      traceId: z.string().optional().describe('Optional trace ID to scope the assertion to'),
+      sinceTimestamp: z.string().optional().describe('Optional ISO timestamp — only check logs after this time')
+    },
+    async ({ traceId, sinceTimestamp }) => {
+      try {
+        const body = {}
+        if (traceId !== undefined) body.traceId = traceId
+        if (sinceTimestamp !== undefined) body.sinceTimestamp = sinceTimestamp
+        const data = await apiClient.post('/v1/logging/entries/assert-no-errors', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to assert no errors: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'logging_get_queue_stats',
+    'Get Bull queue statistics including job counts and health status for the blackbox logs consumer',
+    {},
+    async () => {
+      try {
+        const data = await apiClient.post('/v1/logging/queue-stats', {})
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to get queue stats: ${error.message}` }], isError: true }
+      }
+    }
+  )
+}

package/src/mcp/tools/mqtt.js

@@ -0,0 +1,37 @@
+import { z } from 'zod'
+
+export function registerMqttTools (server, apiClient) {
+  server.tool(
+    'mqtt_list_clients',
+    'List all connected MQTT clients with their connection info',
+    {},
+    async () => {
+      try {
+        const data = await apiClient.post('/v1/mqtt/clients/list')
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to list MQTT clients: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'mqtt_list_messages',
+    'List recent MQTT messages with optional filtering',
+    {
+      filter: z.record(z.any()).optional().describe('Optional filter criteria for MQTT messages'),
+      page: z.object({ limit: z.number().optional(), offset: z.number().optional() }).optional().describe('Optional pagination with limit and offset')
+    },
+    async ({ filter, page }) => {
+      try {
+        const body = {}
+        if (filter !== undefined) body.filter = filter
+        if (page !== undefined) body.page = page
+        const data = await apiClient.post('/v1/mqtt/messages/list', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to list MQTT messages: ${error.message}` }], isError: true }
+      }
+    }
+  )
+}