@gokiteam/goki-dev 0.2.0

package/src/mcp/tools/postgres.js

@@ -0,0 +1,130 @@
+import { z } from 'zod'
+
+export function registerPostgresTools (server, apiClient) {
+  server.tool(
+    'postgres_test_connection',
+    'Test the PostgreSQL database connection',
+    {},
+    async () => {
+      try {
+        const data = await apiClient.post('/v1/postgres/connection/test')
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'postgres_list_databases',
+    'List all PostgreSQL databases',
+    {},
+    async () => {
+      try {
+        const data = await apiClient.post('/v1/postgres/databases/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(
+    'postgres_list_schemas',
+    'List all schemas in the current database',
+    {},
+    async () => {
+      try {
+        const data = await apiClient.post('/v1/postgres/schemas/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(
+    'postgres_list_tables',
+    'List tables in a PostgreSQL schema (defaults to public)',
+    {
+      schema: z.string().optional().describe('Schema name (defaults to public)')
+    },
+    async ({ schema }) => {
+      try {
+        const data = await apiClient.post('/v1/postgres/tables/list', { schema })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'postgres_list_columns',
+    'List columns of a PostgreSQL table with types and constraints',
+    {
+      table: z.string().describe('Table name'),
+      schema: z.string().optional().describe('Schema name (defaults to public)')
+    },
+    async ({ table, schema }) => {
+      try {
+        const data = await apiClient.post('/v1/postgres/columns/list', { table, schema })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'postgres_list_rows',
+    'List rows from a PostgreSQL table with pagination',
+    {
+      table: z.string().describe('Table name'),
+      page: z.object({ limit: z.number().optional(), offset: z.number().optional() }).optional().describe('Pagination options with limit and offset')
+    },
+    async ({ table, page }) => {
+      try {
+        const data = await apiClient.post('/v1/postgres/rows/list', { table, 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(
+    'postgres_execute_query',
+    'Execute a raw SQL query against PostgreSQL',
+    {
+      query: z.string().describe('SQL query to execute'),
+      params: z.array(z.any()).optional().describe('Query parameters for parameterized queries')
+    },
+    async ({ query, params }) => {
+      try {
+        const data = await apiClient.post('/v1/postgres/query/execute', { query, params })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'postgres_wait_for_row',
+    'Wait for a row matching the condition (blocks up to timeout)',
+    {
+      query: z.string().describe('SQL query to poll'),
+      condition: z.record(z.any()).optional().describe('Condition to match against query results'),
+      timeout: z.number().optional().describe('Timeout in milliseconds')
+    },
+    async ({ query, condition, timeout }) => {
+      try {
+        const data = await apiClient.post('/v1/postgres/rows/wait-for', { query, condition, timeout })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true }
+      }
+    }
+  )
+}

package/src/mcp/tools/pubsub.js

@@ -0,0 +1,316 @@
+import { z } from 'zod'
+
+export function registerPubsubTools (server, apiClient) {
+  server.tool(
+    'pubsub_list_topics',
+    'List all Pub/Sub topics in the dev-tools emulator',
+    {},
+    async () => {
+      try {
+        const data = await apiClient.post('/v1/pubsub/topics/list')
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to list topics: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'pubsub_create_topic',
+    'Create a new Pub/Sub topic in the dev-tools emulator',
+    {
+      topicName: z.string().describe('Name of the topic to create')
+    },
+    async ({ topicName }) => {
+      try {
+        const data = await apiClient.post('/v1/pubsub/topics/create', { topicName })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to create topic: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'pubsub_delete_topic',
+    'Delete a Pub/Sub topic from the dev-tools emulator',
+    {
+      topicName: z.string().describe('Name of the topic to delete')
+    },
+    async ({ topicName }) => {
+      try {
+        const data = await apiClient.post('/v1/pubsub/topics/delete', { topicName })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to delete topic: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'pubsub_suggest_topics',
+    'Get topic name suggestions based on a query string, useful for autocomplete',
+    {
+      query: z.string().describe('Search query to match against topic names'),
+      limit: z.number().optional().describe('Maximum number of suggestions to return')
+    },
+    async ({ query, limit }) => {
+      try {
+        const body = { query }
+        if (limit !== undefined) body.limit = limit
+        const data = await apiClient.post('/v1/pubsub/topics/suggest', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to suggest topics: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'pubsub_list_subscriptions',
+    'List all Pub/Sub subscriptions in the dev-tools emulator',
+    {},
+    async () => {
+      try {
+        const data = await apiClient.post('/v1/pubsub/subscriptions/list')
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to list subscriptions: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'pubsub_create_subscription',
+    'Create a new Pub/Sub subscription attached to a topic',
+    {
+      topicName: z.string().describe('Name of the topic to subscribe to'),
+      subscriptionName: z.string().describe('Name for the new subscription')
+    },
+    async ({ topicName, subscriptionName }) => {
+      try {
+        const data = await apiClient.post('/v1/pubsub/subscriptions/create', { topicName, subscriptionName })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to create subscription: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'pubsub_delete_subscription',
+    'Delete a Pub/Sub subscription from the dev-tools emulator',
+    {
+      subscriptionName: z.string().describe('Name of the subscription to delete')
+    },
+    async ({ subscriptionName }) => {
+      try {
+        const data = await apiClient.post('/v1/pubsub/subscriptions/delete', { subscriptionName })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to delete subscription: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'pubsub_publish_message',
+    'Publish a message to a Pub/Sub topic. The message can be a string or a JSON object. Optionally include key-value attributes.',
+    {
+      topicName: z.string().describe('Topic to publish the message to'),
+      message: z.any().describe('Message payload — can be a string or a JSON object'),
+      attributes: z.record(z.string()).optional().describe('Optional key-value attributes to attach to the message')
+    },
+    async ({ topicName, message, attributes }) => {
+      try {
+        const body = { topicName, message }
+        if (attributes !== undefined) body.attributes = attributes
+        const data = await apiClient.post('/v1/pubsub/messages/publish', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to publish message: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'pubsub_pull_messages',
+    'Pull pending messages from a Pub/Sub subscription',
+    {
+      subscriptionName: z.string().describe('Subscription to pull messages from'),
+      maxMessages: z.number().optional().describe('Maximum number of messages to pull')
+    },
+    async ({ subscriptionName, maxMessages }) => {
+      try {
+        const body = { subscriptionName }
+        if (maxMessages !== undefined) body.maxMessages = maxMessages
+        const data = await apiClient.post('/v1/pubsub/messages/pull', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to pull messages: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'pubsub_search_messages',
+    'Search through Pub/Sub message history by query string. Can search in specific fields and apply additional filters.',
+    {
+      query: z.string().describe('Search query to match against message content'),
+      searchIn: z.array(z.string()).optional().describe('Optional list of fields to search in (e.g. ["data", "attributes", "topic"])'),
+      filter: z.record(z.any()).optional().describe('Optional additional filter criteria')
+    },
+    async ({ query, searchIn, filter }) => {
+      try {
+        const body = { query }
+        if (searchIn !== undefined) body.searchIn = searchIn
+        if (filter !== undefined) body.filter = filter
+        const data = await apiClient.post('/v1/pubsub/messages/search', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to search messages: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'pubsub_get_history',
+    'Retrieve Pub/Sub message history with optional filtering and pagination',
+    {
+      filter: z.record(z.any()).optional().describe('Optional filter criteria (e.g. by topic, time range)'),
+      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/pubsub/messages/history', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to get message history: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'pubsub_clear_history',
+    'Clear Pub/Sub message history. Optionally keep a number of recent messages or clear only a specific topic.',
+    {
+      keepCount: z.number().optional().describe('Number of recent messages to keep'),
+      topic: z.string().optional().describe('Only clear history for this topic')
+    },
+    async ({ keepCount, topic }) => {
+      try {
+        const body = {}
+        if (keepCount !== undefined) body.keepCount = keepCount
+        if (topic !== undefined) body.topic = topic
+        const data = await apiClient.post('/v1/pubsub/history/clear', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to clear history: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'pubsub_history_stats',
+    'Get statistics about Pub/Sub message history including counts per topic and total volume',
+    {},
+    async () => {
+      try {
+        const data = await apiClient.post('/v1/pubsub/history/stats')
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to get history stats: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'pubsub_wait_for_message',
+    'Block until a Pub/Sub message matching the filter criteria arrives, or timeout. Useful for waiting on async responses after publishing a command.',
+    {
+      filter: z.record(z.any()).describe('Filter criteria with jsonPath and/or predicate to match incoming messages'),
+      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/pubsub/messages/wait-for', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to wait for message: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'pubsub_assert_message_published',
+    'Assert that a message was published to a topic matching filter criteria. Returns whether a match was found, the count, and the first matching message.',
+    {
+      filter: z.record(z.any()).describe('Filter criteria: { topic (string), since (ISO timestamp), dataContains (string), attributesMatch (object) }')
+    },
+    async ({ filter }) => {
+      try {
+        const data = await apiClient.post('/v1/pubsub/messages/assert-published', { filter })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to assert message published: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'pubsub_registry_register',
+    'Register topics in the persistent Pub/Sub registry for a project. Topics persist across restarts.',
+    {
+      projectName: z.string().describe('Project name to register topics for'),
+      topics: z.array(z.any()).describe('Array of topic names (strings) or objects with { name, subscription }')
+    },
+    async ({ projectName, topics }) => {
+      try {
+        const data = await apiClient.post('/v1/pubsub/registry/register', { projectName, topics })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to register topics: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'pubsub_registry_list',
+    'List registered topics from the persistent Pub/Sub registry. Optionally filter by project name.',
+    {
+      projectName: z.string().optional().describe('Optional project name to filter by')
+    },
+    async ({ projectName }) => {
+      try {
+        const body = {}
+        if (projectName !== undefined) body.projectName = projectName
+        const data = await apiClient.post('/v1/pubsub/registry/list', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to list registry: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'pubsub_registry_unregister',
+    'Unregister topics for a project from the persistent Pub/Sub registry',
+    {
+      projectName: z.string().describe('Project name to unregister topics from'),
+      topicNames: z.array(z.string()).describe('Array of topic name strings to unregister')
+    },
+    async ({ projectName, topicNames }) => {
+      try {
+        const data = await apiClient.post('/v1/pubsub/registry/unregister', { projectName, topicNames })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to unregister topics: ${error.message}` }], isError: true }
+      }
+    }
+  )
+}

package/src/mcp/tools/redis.js

@@ -0,0 +1,146 @@
+import { z } from 'zod'
+
+export function registerRedisTools (server, apiClient) {
+  server.tool(
+    'redis_test_connection',
+    'Test the Redis connection',
+    {},
+    async () => {
+      try {
+        const data = await apiClient.post('/v1/redis/connection/test')
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'redis_info',
+    'Get Redis server info including memory usage and db size',
+    {},
+    async () => {
+      try {
+        const data = await apiClient.post('/v1/redis/info')
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'redis_scan_keys',
+    'Scan Redis keys matching a pattern (default: *)',
+    {
+      pattern: z.string().optional().describe('Key pattern to match (default: *)'),
+      cursor: z.string().optional().describe('Cursor for pagination'),
+      count: z.number().optional().describe('Approximate number of keys to return per scan')
+    },
+    async ({ pattern, cursor, count }) => {
+      try {
+        const data = await apiClient.post('/v1/redis/keys/scan', { pattern, cursor, count })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'redis_get_key',
+    'Get the value of a Redis key (auto-detects type: string, hash, list, set)',
+    {
+      key: z.string().describe('Redis key name')
+    },
+    async ({ key }) => {
+      try {
+        const data = await apiClient.post('/v1/redis/keys/get', { key })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'redis_get_ttl',
+    'Get the TTL (time-to-live) of a Redis key in seconds',
+    {
+      key: z.string().describe('Redis key name')
+    },
+    async ({ key }) => {
+      try {
+        const data = await apiClient.post('/v1/redis/keys/ttl', { key })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'redis_delete_key',
+    'Delete a specific Redis key',
+    {
+      key: z.string().describe('Redis key name')
+    },
+    async ({ key }) => {
+      try {
+        const data = await apiClient.post('/v1/redis/keys/delete', { key })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'redis_update_key',
+    'Set or update a Redis key value with optional TTL',
+    {
+      key: z.string().describe('Redis key name'),
+      value: z.string().describe('Value to set'),
+      ttl: z.number().optional().describe('Time-to-live in seconds')
+    },
+    async ({ key, value, ttl }) => {
+      try {
+        const data = await apiClient.post('/v1/redis/keys/update', { key, value, ttl })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'redis_delete_all',
+    'Delete all Redis keys (FLUSHDB)',
+    {},
+    async () => {
+      try {
+        const data = await apiClient.post('/v1/redis/keys/delete-all')
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
+  server.tool(
+    'redis_wait_for_key',
+    'Wait for a Redis key to match a condition',
+    {
+      condition: z.record(z.any()).describe('Condition to match against the key value'),
+      timeout: z.number().optional().describe('Timeout in milliseconds')
+    },
+    async ({ condition, timeout }) => {
+      try {
+        const data = await apiClient.post('/v1/redis/keys/wait-for', { condition, timeout })
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true }
+      }
+    }
+  )
+}