@gokiteam/goki-dev 0.2.0 → 0.2.2

package/package.json

@@ -1,24 +1,8 @@
 {
   "name": "@gokiteam/goki-dev",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Unified local development platform for Goki services",
   "type": "module",
-  "main": "./client/dist/index.js",
-  "types": "./client/dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./client/dist/index.d.ts",
-      "import": "./client/dist/index.js",
-      "require": "./client/dist/index.js"
-    }
-  },
-  "typesVersions": {
-    "*": {
-      ".": [
-        "./client/dist/index.d.ts"
-      ]
-    }
-  },
   "bin": {
     "goki-dev": "./bin/goki-dev.js",
     "goki-dev-mcp": "./bin/mcp-server.js",
@@ -28,7 +12,14 @@
     "bin/",
     "cli/",
     "src/",
-    "client/dist/",
+    "ui/build/",
+    "docker-compose.yml",
+    "docker-compose.services.yml",
+    "docker-compose.dev.yml",
+    "Dockerfile.backend",
+    "Dockerfile.frontend",
+    "Dockerfile.dev",
+    "nginx.conf",
     "config.development",
     "config.test",
     "guidelines/",
@@ -40,9 +31,11 @@
     "dev:watch": "dotenv -e config.development node --watch src/Server.js",
     "dev:ui": "concurrently \"npm run dev\" \"cd ui && npm start\" --names \"backend,frontend\" --prefix-colors \"blue,green\"",
     "ui:start": "cd ui && npm start",
-    "ui:build": "cd ui && npm run build",
-    "build:client": "cd client && npx tsc && echo '{\"type\":\"commonjs\"}' > dist/package.json",
-    "prepublishOnly": "npm run build:client",
+    "build": "cd ui && npm run build && cd ../client && npm run build",
+    "prepublishOnly": "npm run build",
+    "release": "standard-version && npm run build && npm publish && cd client && npm publish",
+    "release:minor": "standard-version --release-as minor && npm run build && npm publish && cd client && npm publish",
+    "release:major": "standard-version --release-as major && npm run build && npm publish && cd client && npm publish",
     "test": "dotenv -e config.test mocha 'tests/**/*.test.js'",
     "test:api": "dotenv -e config.test mocha 'tests/api/**/*.test.js'",
     "test:emulation": "dotenv -e config.test mocha 'tests/emulation/**/*.test.js'",
@@ -126,6 +119,7 @@
     "mqtt": "^5.15.0",
     "playwright": "^1.58.1",
     "standard": "^17.1.0",
+    "standard-version": "^9.5.0",
     "supertest": "^6.3.0",
     "typescript": "^5.9.3"
   },
@@ -134,5 +128,17 @@
       "mocha"
     ]
   },
+  "standard-version": {
+    "bumpFiles": [
+      {
+        "filename": "package.json",
+        "type": "json"
+      },
+      {
+        "filename": "client/package.json",
+        "type": "json"
+      }
+    ]
+  },
   "packageManager": "yarn@3.8.7+sha512.bbe7e310ff7fd20dc63b111110f96fe18192234bb0d4f10441fa6b85d2b644c8923db8fbe6d7886257ace948440ab1f83325ad02af457a1806cdc97f03d2508e"
 }

package/src/api/httpTraffic/Controllers.js

@@ -15,6 +15,13 @@ export const Controllers = {
     ctx.reply(result)
   },
 
+  async waitFor (ctx) {
+    const { traceId } = ctx.state
+    const { filter, timeout } = ctx.request.body
+    const result = await Logic.waitForTraffic({ filter, timeout, traceId })
+    ctx.reply(result)
+  },
+
   async clear (ctx) {
     const { traceId } = ctx.state
     const result = Logic.clear({ traceId })

package/src/api/httpTraffic/Logic.js

@@ -1,5 +1,7 @@
 import { HttpProxy } from '../../singletons/HttpProxy.js'
 
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms))
+
 export const Logic = {
   list (params) {
     const { filter, limit = 50, offset = 0, traceId } = params
@@ -19,6 +21,32 @@ export const Logic = {
     return { entry, traceId }
   },
 
+  async waitForTraffic (params) {
+    const { filter, timeout = 5000, traceId } = params
+    const startTime = Date.now()
+    const pollInterval = 100
+    const { pathContains, ...equalityFilter } = filter
+    try {
+      while (Date.now() - startTime < timeout) {
+        const { data } = HttpProxy.listTraffic({ filter: equalityFilter, limit: 50 })
+        if (data && data.length > 0) {
+          for (const entry of data) {
+            if (!pathContains) {
+              return { entry, foundAt: Date.now() - startTime, traceId }
+            }
+            if (entry.targetPath && entry.targetPath.includes(pathContains)) {
+              return { entry, foundAt: Date.now() - startTime, traceId }
+            }
+          }
+        }
+        await sleep(pollInterval)
+      }
+      return { status: 'error', message: 'Timeout waiting for HTTP traffic', traceId }
+    } catch (error) {
+      return { status: 'error', message: error.message, traceId }
+    }
+  },
+
   clear (params) {
     const { traceId } = params
     HttpProxy.clearTraffic()

package/src/api/httpTraffic/Router.js

@@ -5,5 +5,6 @@ export const Router = new KoaRouter({ prefix: '/v1/http-traffic' })
 
 Router.post('/list', Controllers.list)
 Router.post('/details', Controllers.details)
+Router.post('/wait-for', Controllers.waitFor)
 Router.post('/clear', Controllers.clear)
 Router.post('/stats', Controllers.stats)

package/src/api/httpTraffic/Schemas.js

@@ -7,7 +7,9 @@ export const Schemas = {
       targetHost: Joi.string(),
       sourceService: Joi.string(),
       statusCode: Joi.number().integer(),
-      traceId: Joi.string()
+      traceId: Joi.string(),
+      since: Joi.string().isoDate(),
+      until: Joi.string().isoDate()
     }).optional(),
     limit: Joi.number().integer().min(1).max(500).default(50),
     offset: Joi.number().integer().min(0).default(0)
@@ -17,6 +19,18 @@ export const Schemas = {
     id: Joi.string().required()
   }),
 
+  waitFor: Joi.object({
+    filter: Joi.object({
+      method: Joi.string().valid('GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'),
+      targetHost: Joi.string(),
+      sourceService: Joi.string(),
+      statusCode: Joi.number().integer(),
+      traceId: Joi.string(),
+      pathContains: Joi.string()
+    }).required(),
+    timeout: Joi.number().integer().min(100).max(30000).default(5000)
+  }),
+
   clear: Joi.object({}),
 
   stats: Joi.object({})

package/src/api/snapshots/Logic.js

@@ -1,7 +1,7 @@
 import { execa } from 'execa'
 import fs from 'fs/promises'
+import os from 'os'
 import path from 'path'
-import { fileURLToPath } from 'url'
 import { Logic as FirestoreLogic } from '../firestore/Logic.js'
 import { Logic as DockerLogic } from '../docker/Logic.js'
 import { Logic as PubSubLogic } from '../pubsub/Logic.js'
@@ -23,10 +23,7 @@ import {
   PUBSUB_MESSAGE_HISTORY
 } from '../../db/Tables.js'
 
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-const PROJECT_ROOT = path.join(__dirname, '../../..')
-const SNAPSHOTS_DIR = path.join(PROJECT_ROOT, '.goki-dev/snapshots')
+const SNAPSHOTS_DIR = path.join(os.homedir(), '.goki-dev', 'snapshots')
 
 // Ensure snapshot directories exist
 async function ensureSnapshotDirs () {

package/src/configs/Application.js

@@ -1,4 +1,6 @@
 import Moment from 'moment'
+import os from 'os'
+import path from 'path'
 
 const {
   NODE_ENV = 'development',
@@ -77,7 +79,7 @@ export const Application = {
     shadowSubscriptionCheckIntervalMs: parseInt(SHADOW_SUBSCRIPTION_CHECK_INTERVAL_MS) || 5000
   },
   storage: {
-    dataDir: DATA_DIR
+    dataDir: DATA_DIR || path.join(os.homedir(), '.goki-dev', 'data')
   },
   redis: {
     host: REDIS_HOST || 'localhost',

package/src/mcp/tools/httpTraffic.js

@@ -5,7 +5,7 @@ export function registerHttpTrafficTools (server, apiClient) {
     '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)'),
+      filter: z.record(z.any()).optional().describe('Optional filter criteria (method, targetHost, sourceService, statusCode, traceId, since, until)'),
       limit: z.number().optional().describe('Maximum number of records to return'),
       offset: z.number().optional().describe('Number of records to skip for pagination')
     },
@@ -39,6 +39,25 @@ export function registerHttpTrafficTools (server, apiClient) {
     }
   )
 
+  server.tool(
+    'http_traffic_wait_for',
+    'Wait for an HTTP traffic entry matching the filter to appear within a timeout (polling). Useful for e2e tests.',
+    {
+      filter: z.record(z.any()).describe('Required filter criteria (method, targetHost, sourceService, statusCode, traceId, pathContains)'),
+      timeout: z.number().optional().describe('Timeout in ms (default: 5000, max: 30000)')
+    },
+    async ({ filter, timeout }) => {
+      try {
+        const body = { filter }
+        if (timeout !== undefined) body.timeout = timeout
+        const data = await apiClient.post('/v1/http-traffic/wait-for', body)
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Failed to wait for HTTP traffic: ${error.message}` }], isError: true }
+      }
+    }
+  )
+
   server.tool(
     'http_traffic_clear',
     'Clear all recorded HTTP traffic',

package/src/singletons/HttpProxy.js

@@ -174,7 +174,17 @@ class HttpProxyClass {
       offset
     }
     if (filter && Object.keys(filter).length > 0) {
-      listOptions.filter = filter
+      const { since, until, ...equalityFilter } = filter
+      if (Object.keys(equalityFilter).length > 0) {
+        listOptions.filter = equalityFilter
+      }
+      const conditions = []
+      const params = []
+      if (since) { conditions.push('created_at >= ?'); params.push(since) }
+      if (until) { conditions.push('created_at <= ?'); params.push(until) }
+      if (conditions.length > 0) {
+        listOptions.rawWhere = { sql: conditions.join(' AND '), params }
+      }
     }
     return SqliteStore.list(HTTP_TRAFFIC, listOptions)
   }

package/src/singletons/SqliteStore.js

@@ -21,10 +21,15 @@ class SqliteStoreClass {
   initialize (dbPath = null) {
     if (this.isInitialized) return
 
-    const dataDir = Application.storage.dataDir || './data'
+    const dataDir = Application.storage.dataDir
     if (!fs.existsSync(dataDir)) {
       fs.mkdirSync(dataDir, { recursive: true })
     }
+    if (dataDir.includes('.goki-dev') && fs.existsSync('./data/dev-tools.db')) {
+      console.warn('[MIGRATION] Found legacy database at ./data/dev-tools.db')
+      console.warn(`[MIGRATION] Database now lives at ${path.join(dataDir, 'dev-tools.db')}`)
+      console.warn(`[MIGRATION] Copy manually: cp ./data/dev-tools.db ${path.join(dataDir, 'dev-tools.db')}`)
+    }
 
     const finalDbPath = dbPath || path.join(dataDir, 'dev-tools.db')
     this.db = new Database(finalDbPath)
@@ -147,8 +152,12 @@ class SqliteStoreClass {
         params.push(...where.params)
       }
 
-      const countSql = `SELECT COUNT(*) as count FROM ${tableName}` +
-        (params.length > 0 ? ` ${this.buildWhereClause(options.where || options.filter).sql}` : '')
+      if (options.rawWhere) {
+        sql += params.length > 0 ? ` AND ${options.rawWhere.sql}` : ` WHERE ${options.rawWhere.sql}`
+        params.push(...options.rawWhere.params)
+      }
+
+      const countSql = sql.replace(/^SELECT \* FROM/, 'SELECT COUNT(*) as count FROM')
       const totalResult = this.db.prepare(countSql).get(...params)
       const total = totalResult.count
 

package/ui/Dockerfile.dev

@@ -0,0 +1,19 @@
+FROM node:20-alpine
+
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+
+# Install dependencies
+RUN npm install
+
+# Copy config files (source files will be mounted as volumes)
+COPY tailwind.config.js ./
+COPY postcss.config.js ./
+
+# Expose React dev server port
+EXPOSE 9001
+
+# Start React dev server
+CMD ["npm", "start"]

package/client/dist/client.d.ts

@@ -1,332 +0,0 @@
-/**
- * @gokiteam/goki-dev - Main Client
- *
- * HTTP client for Goki Developer Tools
- */
-import { AxiosInstance } from 'axios';
-import type * as Types from './types';
-export interface DevToolsClientConfig {
-    baseUrl?: string;
-    timeout?: number;
-}
-export declare class PubSubClient {
-    private client;
-    constructor(client: AxiosInstance);
-    private call;
-    /**
-     * Extract short topic name from a full path like 'projects/X/topics/Y' -> 'Y'
-     */
-    private extractTopicName;
-    publish(params: {
-        topic: string;
-        message: any;
-        attributes?: Record<string, string>;
-        traceId?: string;
-    }): Promise<{
-        messageIds: string[];
-    } & {
-        traceId: string;
-    }>;
-    waitForMessage(params: Types.WaitForMessageRequest): Promise<Types.WaitForMessageResponse>;
-    assertMessagePublished(params: Types.AssertMessagePublishedRequest): Promise<Types.AssertMessagePublishedResponse>;
-    getMessages(params?: {
-        filter?: Types.PubSubHistoryFilter;
-        page?: Types.PageOptions;
-        traceId?: string;
-    }): Promise<{
-        messages: Types.PubSubMessage[];
-        total: number;
-    } & {
-        traceId: string;
-    }>;
-    searchMessages(params: {
-        query: string;
-        filter?: Partial<Types.PubSubHistoryFilter>;
-        traceId?: string;
-    }): Promise<{
-        messages: Types.PubSubMessage[];
-        total: number;
-    } & {
-        traceId: string;
-    }>;
-    listTopics(params?: {
-        traceId?: string;
-    }): Promise<{
-        topics: Types.PubSubTopic[];
-        total: number;
-    } & {
-        traceId: string;
-    }>;
-    createTopic(params: {
-        topic: string;
-        traceId?: string;
-    }): Promise<{
-        topic: Types.PubSubTopic;
-    } & {
-        traceId: string;
-    }>;
-    deleteTopic(params: {
-        topic: string;
-        traceId?: string;
-    }): Promise<void>;
-}
-export declare class LoggingClient {
-    private client;
-    constructor(client: AxiosInstance);
-    private call;
-    getByTrace(params: {
-        traceId: string;
-        queryTraceId?: string;
-    }): Promise<{
-        traceId: string;
-        entries: Types.LogEntry[];
-        count: number;
-    }>;
-    list(params?: {
-        filter?: Types.LogFilter;
-        page?: Types.PageOptions;
-        traceId?: string;
-    }): Promise<{
-        entries: Types.LogEntry[];
-        total: number;
-    } & {
-        traceId: string;
-    }>;
-    clear(params?: {
-        service?: string;
-        traceId?: string;
-    }): Promise<{
-        deletedCount: number;
-    } & {
-        traceId: string;
-    }>;
-    waitForLog(params: Types.WaitForLogRequest): Promise<Types.WaitForLogResponse>;
-    assertNoErrors(params: Types.AssertNoErrorsRequest): Promise<Types.AssertNoErrorsResponse>;
-}
-export declare class PostgresClient {
-    private client;
-    constructor(client: AxiosInstance);
-    private call;
-    query(params: Types.PostgresQueryRequest): Promise<Types.PostgresQueryResponse>;
-    listTables(params: {
-        database: string;
-        schema?: string;
-        traceId?: string;
-    }): Promise<{
-        tables: {
-            name: string;
-            rowCount: number;
-        }[];
-    } & {
-        traceId: string;
-    }>;
-    listRows(params: {
-        database: string;
-        schema: string;
-        table: string;
-        page?: Types.PageOptions;
-        traceId?: string;
-    }): Promise<{
-        rows: any[];
-        total: number;
-    } & {
-        traceId: string;
-    }>;
-    waitForCondition(params: Types.WaitForConditionRequest & {
-        type: 'postgres';
-    }): Promise<Types.WaitForConditionResponse>;
-}
-export declare class RedisClient {
-    private client;
-    constructor(client: AxiosInstance);
-    private call;
-    get(params: {
-        key: string;
-        traceId?: string;
-    }): Promise<Types.RedisValue>;
-    scan(params: {
-        pattern: string;
-        count?: number;
-        traceId?: string;
-    }): Promise<{
-        keys: Types.RedisKey[];
-        total: number;
-    } & {
-        traceId: string;
-    }>;
-    delete(params: {
-        key: string;
-        traceId?: string;
-    }): Promise<{
-        deleted: boolean;
-    } & {
-        traceId: string;
-    }>;
-    deletePattern(params: {
-        pattern: string;
-        traceId?: string;
-    }): Promise<{
-        deletedCount: number;
-    } & {
-        traceId: string;
-    }>;
-    waitForCondition(params: Types.WaitForConditionRequest & {
-        type: 'redis';
-    }): Promise<Types.WaitForConditionResponse>;
-}
-export declare class FirestoreClient {
-    private client;
-    constructor(client: AxiosInstance);
-    private call;
-    /**
-     * Parses a Firestore REST API typed value into a plain JS value.
-     */
-    private parseFirestoreValue;
-    /**
-     * Parses Firestore REST API fields object into a plain JS object.
-     */
-    private parseFirestoreFields;
-    /**
-     * Converts a raw Firestore REST API document to a clean FirestoreDocument.
-     * Raw format: { name: "projects/.../documents/collection/id", fields: { key: { stringValue: "..." } }, ... }
-     * Clean format: { id: "docId", data: { key: "..." } }
-     */
-    private parseRawDocument;
-    getDocument(params: {
-        collection: string;
-        documentId: string;
-        traceId?: string;
-    }): Promise<{
-        document: Types.FirestoreDocument;
-    }>;
-    query(params: {
-        collection: string;
-        where: Types.FirestoreQuery;
-        traceId?: string;
-    }): Promise<{
-        documents: Types.FirestoreDocument[];
-    }>;
-    listDocuments(params: {
-        collection: string;
-        page?: Types.PageOptions;
-        traceId?: string;
-    }): Promise<{
-        documents: Types.FirestoreDocument[];
-        total: number;
-    }>;
-    deleteByQuery(params: Types.DeleteByQueryRequest): Promise<Types.DeleteByQueryResponse>;
-    deleteByPrefix(params: Types.DeleteByPrefixRequest): Promise<Types.DeleteByPrefixResponse>;
-    deleteBatch(params: Types.DeleteBatchRequest): Promise<Types.DeleteBatchResponse>;
-    waitForCondition(params: Types.WaitForConditionRequest & {
-        type: 'firestore';
-    }): Promise<Types.WaitForConditionResponse>;
-}
-export declare class MqttClient {
-    private client;
-    constructor(client: AxiosInstance);
-    private call;
-    listClients(params?: {
-        traceId?: string;
-    }): Promise<{
-        clients: Types.MqttClientInfo[];
-    } & {
-        traceId: string;
-    }>;
-    getMessages(params?: {
-        filter?: {
-            clientId?: string;
-            topic?: string;
-        };
-        page?: Types.PageOptions;
-        traceId?: string;
-    }): Promise<{
-        messages: Types.MqttMessage[];
-        total: number;
-    } & {
-        traceId: string;
-    }>;
-}
-export declare class DockerClient {
-    private client;
-    constructor(client: AxiosInstance);
-    private call;
-    list(params?: {
-        traceId?: string;
-    }): Promise<{
-        data: Types.DockerContainer[];
-    } & {
-        traceId: string;
-    }>;
-    start(params: {
-        containerName: string;
-        traceId?: string;
-    }): Promise<void>;
-    stop(params: {
-        containerName: string;
-        traceId?: string;
-    }): Promise<void>;
-    restart(params: {
-        containerName: string;
-        traceId?: string;
-    }): Promise<void>;
-    logs(params: {
-        containerName: string;
-        lines?: number;
-        traceId?: string;
-    }): Promise<{
-        data: string;
-    } & {
-        traceId: string;
-    }>;
-}
-export declare class PlatformClient {
-    private client;
-    constructor(client: AxiosInstance);
-    private call;
-    getStats(params?: {
-        traceId?: string;
-    }): Promise<{
-        stats: Types.PlatformStats;
-    } & {
-        traceId: string;
-    }>;
-    clearAll(params?: {
-        traceId?: string;
-    }): Promise<{
-        cleared: Record<string, number>;
-    } & {
-        traceId: string;
-    }>;
-    clearServices(params: Types.ClearServiceDataRequest): Promise<Types.ClearServiceDataResponse>;
-    export(params?: {
-        traceId?: string;
-    }): Promise<{
-        export: Types.ExportData;
-    } & {
-        traceId: string;
-    }>;
-}
-export declare class SchedulerClient {
-    private client;
-    constructor(client: AxiosInstance);
-    private call;
-    triggerTick(params?: {
-        traceId?: string;
-    }): Promise<Types.SchedulerTickResponse>;
-}
-export declare class DevToolsClient {
-    private client;
-    private baseUrl;
-    pubsub: PubSubClient;
-    logging: LoggingClient;
-    postgres: PostgresClient;
-    redis: RedisClient;
-    firestore: FirestoreClient;
-    mqtt: MqttClient;
-    docker: DockerClient;
-    platform: PlatformClient;
-    scheduler: SchedulerClient;
-    constructor(config?: DevToolsClientConfig);
-    generateTraceId(prefix?: string): string;
-}
-export * from './types';