@gokiteam/goki-dev 0.2.0

package/src/mcp/tools/docker.js

@@ -0,0 +1,166 @@
+import { z } from 'zod'
+import { exec } from 'child_process'
+import { promisify } from 'util'
+
+const execAsync = promisify(exec)
+
+// Container display names for better UX
+const CONTAINER_DISPLAY_NAMES = {
+  'goki-postgres': 'PostgreSQL',
+  'goki-redis': 'Redis',
+  'goki-redis-logs': 'Redis (Logs)',
+  'goki-pubsub-emulator': 'Pub/Sub Emulator',
+  'goki-firestore-emulator': 'Firestore Emulator',
+  'goki-elasticsearch': 'Elasticsearch',
+  'goki-kibana': 'Kibana',
+  'goki-dev-tools-backend': 'Dev Tools Backend',
+  'goki-dev-tools-frontend': 'Dev Tools Frontend',
+  'device-native-app': 'Device Native',
+  'device-simulator-app': 'Device Simulator',
+  'integration-apaleo-app': 'Integration Apaleo',
+  'core-pms-app': 'Core PMS',
+  'core-key-app': 'Core Key',
+  'integration-mews-app': 'Integration Mews',
+  'integration-opera-app': 'Integration Opera'
+}
+
+const parseContainerStatus = (status) => {
+  if (!status) return 'unknown'
+  const lower = status.toLowerCase()
+  if (lower.includes('up')) return 'running'
+  if (lower.includes('exited')) return 'stopped'
+  if (lower.includes('created')) return 'created'
+  if (lower.includes('restarting')) return 'restarting'
+  if (lower.includes('paused')) return 'paused'
+  return 'unknown'
+}
+
+const parseUptime = (status) => {
+  if (!status) return null
+  const match = status.match(/Up\s+(.+?)(?:\s+\(|$)/i)
+  if (!match) return null
+  return match[1].trim()
+}
+
+const parsePorts = (portsStr) => {
+  if (!portsStr) return null
+  const match = portsStr.match(/0\.0\.0\.0:(\d+)->/)
+  return match ? parseInt(match[1], 10) : null
+}
+
+const generateDisplayName = (containerName) => {
+  return containerName
+    .replace(/-app$/, '')
+    .replace(/^goki-/, '')
+    .split('-')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ')
+}
+
+// Docker commands run directly on host (MCP server runs on host, not in container)
+export function registerDockerTools (server, apiClient) {
+  server.tool(
+    'docker_list_containers',
+    'List all Docker containers on the goki-network with their status, ports, and uptime',
+    {},
+    async () => {
+      try {
+        const { stdout } = await execAsync(
+          'docker ps -a --filter "network=goki-network" --format "{{.Names}}\t{{.Status}}\t{{.Ports}}\t{{.Image}}"'
+        )
+        const lines = stdout.trim().split('\n').filter(Boolean)
+        const containers = lines.map(line => {
+          const [name, status, ports, image] = line.split('\t')
+          const isSelf = name === 'goki-dev-tools-backend'
+          return {
+            name,
+            displayName: CONTAINER_DISPLAY_NAMES[name] || generateDisplayName(name),
+            status: parseContainerStatus(status),
+            statusText: status,
+            uptime: parseUptime(status),
+            port: parsePorts(ports),
+            image,
+            capabilities: {
+              canStart: !isSelf,
+              canStop: !isSelf,
+              canRestart: !isSelf
+            }
+          }
+        })
+        containers.sort((a, b) => a.displayName.localeCompare(b.displayName))
+        return { content: [{ type: 'text', text: JSON.stringify({ containers, total: containers.length }, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to list containers: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'docker_start_container',
+    'Start a stopped Docker container by name',
+    {
+      containerName: z.string().describe('Name of the Docker container to start')
+    },
+    async ({ containerName }) => {
+      try {
+        await execAsync(`docker start ${containerName}`)
+        const displayName = CONTAINER_DISPLAY_NAMES[containerName] || containerName
+        return { content: [{ type: 'text', text: JSON.stringify({ message: `${displayName} started successfully` }, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to start container: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'docker_stop_container',
+    'Stop a running Docker container by name',
+    {
+      containerName: z.string().describe('Name of the Docker container to stop')
+    },
+    async ({ containerName }) => {
+      try {
+        await execAsync(`docker stop ${containerName}`)
+        const displayName = CONTAINER_DISPLAY_NAMES[containerName] || containerName
+        return { content: [{ type: 'text', text: JSON.stringify({ message: `${displayName} stopped successfully` }, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to stop container: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'docker_restart_container',
+    'Restart a Docker container by name',
+    {
+      containerName: z.string().describe('Name of the Docker container to restart')
+    },
+    async ({ containerName }) => {
+      try {
+        await execAsync(`docker restart ${containerName}`)
+        const displayName = CONTAINER_DISPLAY_NAMES[containerName] || containerName
+        return { content: [{ type: 'text', text: JSON.stringify({ message: `${displayName} restarted successfully` }, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to restart container: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'docker_get_logs',
+    'Get recent logs from a Docker container. Returns the last N lines (default 100).',
+    {
+      containerName: z.string().describe('Name of the Docker container'),
+      lines: z.number().optional().describe('Number of recent log lines to retrieve (default 100)')
+    },
+    async ({ containerName, lines = 100 }) => {
+      try {
+        const { stdout, stderr } = await execAsync(`docker logs --tail ${lines} ${containerName} 2>&1`)
+        const logs = stdout || stderr
+        return { content: [{ type: 'text', text: JSON.stringify({ logs, containerName, lines }, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to get container logs: ${error.message}` }], isError: true }
+      }
+    }
+  )
+}

package/src/mcp/tools/firestore.js

@@ -0,0 +1,162 @@
+import { z } from 'zod'
+
+export function registerFirestoreTools (server, apiClient) {
+  server.tool(
+    'firestore_list_projects',
+    'List configured Firestore emulator projects',
+    {},
+    async () => {
+      try {
+        const data = await apiClient.post('/v1/firestore/projects/list')
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'firestore_list_collections',
+    'List collections in a Firestore project',
+    {
+      projectId: z.string().optional().describe('Firestore project ID')
+    },
+    async ({ projectId }) => {
+      try {
+        const data = await apiClient.post('/v1/firestore/collections/list', { projectId })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'firestore_list_documents',
+    'List documents in a Firestore collection',
+    {
+      projectId: z.string().optional().describe('Firestore project ID'),
+      collectionPath: z.string().describe('Collection path'),
+      page: z.object({ limit: z.number().optional(), offset: z.number().optional() }).optional().describe('Pagination options with limit and offset')
+    },
+    async ({ projectId, collectionPath, page }) => {
+      try {
+        const data = await apiClient.post('/v1/firestore/documents/list', { projectId, collectionPath, page })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'firestore_get_document',
+    'Get a single Firestore document by ID',
+    {
+      projectId: z.string().optional().describe('Firestore project ID'),
+      collectionPath: z.string().describe('Collection path'),
+      documentId: z.string().describe('Document ID')
+    },
+    async ({ projectId, collectionPath, documentId }) => {
+      try {
+        const data = await apiClient.post('/v1/firestore/documents/get', { projectId, collectionPath, documentId })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'firestore_create_document',
+    'Create a new Firestore document',
+    {
+      projectId: z.string().optional().describe('Firestore project ID'),
+      collectionPath: z.string().describe('Collection path'),
+      fields: z.record(z.any()).describe('Document fields'),
+      documentId: z.string().optional().describe('Document ID (auto-generated if omitted)')
+    },
+    async ({ projectId, collectionPath, fields, documentId }) => {
+      try {
+        const data = await apiClient.post('/v1/firestore/documents/create', { projectId, collectionPath, fields, documentId })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'firestore_update_document',
+    'Update an existing Firestore document',
+    {
+      projectId: z.string().optional().describe('Firestore project ID'),
+      collectionPath: z.string().describe('Collection path'),
+      documentId: z.string().describe('Document ID'),
+      fields: z.record(z.any()).describe('Fields to update')
+    },
+    async ({ projectId, collectionPath, documentId, fields }) => {
+      try {
+        const data = await apiClient.post('/v1/firestore/documents/update', { projectId, collectionPath, documentId, fields })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'firestore_delete_document',
+    'Delete a Firestore document',
+    {
+      projectId: z.string().optional().describe('Firestore project ID'),
+      collectionPath: z.string().describe('Collection path'),
+      documentId: z.string().describe('Document ID')
+    },
+    async ({ projectId, collectionPath, documentId }) => {
+      try {
+        const data = await apiClient.post('/v1/firestore/documents/delete', { projectId, collectionPath, documentId })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'firestore_query',
+    'Execute a query against a Firestore collection with optional where/orderBy/limit',
+    {
+      projectId: z.string().optional().describe('Firestore project ID'),
+      collectionPath: z.string().describe('Collection path'),
+      where: z.array(z.any()).optional().describe('Array of where clauses'),
+      orderBy: z.array(z.any()).optional().describe('Array of orderBy clauses'),
+      limit: z.number().optional().describe('Maximum number of results')
+    },
+    async ({ projectId, collectionPath, where, orderBy, limit }) => {
+      try {
+        const data = await apiClient.post('/v1/firestore/query/execute', { projectId, collectionPath, where, orderBy, limit })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'firestore_clear_collection',
+    'Delete all documents in a Firestore collection',
+    {
+      projectId: z.string().optional().describe('Firestore project ID'),
+      collectionPath: z.string().describe('Collection path')
+    },
+    async ({ projectId, collectionPath }) => {
+      try {
+        const data = await apiClient.post('/v1/firestore/collection/clear', { projectId, collectionPath })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true }
+      }
+    }
+  )
+}