@gokiteam/goki-dev 0.2.0 → 0.2.1

package/Dockerfile.backend

@@ -0,0 +1,38 @@
+FROM node:20-alpine
+
+WORKDIR /app
+
+# Install Java JRE 21 for Firebase Emulator + build tools for better-sqlite3 + Docker CLI + PostgreSQL client
+RUN apk add --no-cache openjdk21-jre bash python3 make g++ docker-cli postgresql-client
+
+# Install Firebase CLI globally for Firestore emulator
+RUN npm install -g firebase-tools
+
+# Copy package files and npm config
+COPY package*.json ./
+
+# Build arg for npm authentication
+ARG NPM_TOKEN
+ENV NPM_TOKEN=${NPM_TOKEN}
+COPY .npmrc ./
+
+# Install dependencies (including optional native deps like better-sqlite3)
+RUN npm install --omit=dev --include=optional
+
+# Copy source code
+COPY src/ ./src/
+COPY config.development ./
+COPY config.test ./
+
+# Copy Firebase configuration
+COPY firebase.json ./
+COPY firestore.rules ./
+
+# Create data and logs directories
+RUN mkdir -p /app/data /app/logs /app/data/firestore
+
+# Expose ports
+EXPOSE 9000 8085 8087 8883 8080
+
+# Start server directly (env vars set via docker-compose)
+CMD ["node", "src/Server.js"]

package/Dockerfile.dev

@@ -0,0 +1,38 @@
+FROM node:20-alpine
+
+WORKDIR /app
+
+# Install Java JRE 21 for Firebase Emulator + build tools for better-sqlite3 + PostgreSQL client
+RUN apk add --no-cache openjdk21-jre bash python3 make g++ postgresql-client
+
+# Install Firebase CLI globally for Firestore emulator
+RUN npm install -g firebase-tools
+
+# Copy package files and npm config
+COPY package*.json ./
+
+# Build arg for npm authentication
+ARG NPM_TOKEN
+ENV NPM_TOKEN=${NPM_TOKEN}
+COPY .npmrc ./
+
+# Install ALL dependencies (including dev for watch mode)
+RUN npm install
+
+# Install nodemon for reliable file watching in Docker (fs.watch doesn't work with bind mounts)
+RUN npm install -g nodemon
+
+# Copy config files
+COPY config.development ./
+COPY config.test ./
+COPY firebase.json ./
+COPY firestore.rules ./
+
+# Create data and logs directories
+RUN mkdir -p /app/data /app/logs /app/data/firestore
+
+# Expose ports
+EXPOSE 9000 8085 8087 8883 8080
+
+# Start server with watch mode using nodemon (polling for Docker bind mount compatibility)
+CMD ["nodemon", "--watch", "src", "--ext", "js,json", "--legacy-watch", "--polling-interval", "1000", "src/Server.js"]

package/Dockerfile.frontend

@@ -0,0 +1,37 @@
+# Build stage
+FROM node:20-alpine AS build
+
+WORKDIR /app
+
+# Copy UI package files
+COPY ui/package*.json ./ui/
+
+# Install UI dependencies
+WORKDIR /app/ui
+RUN npm ci
+
+# Copy UI source files
+COPY ui/ ./
+
+# Build the React app
+# API URL will be injected at runtime via environment variable
+RUN npm run build
+
+# Production stage
+FROM nginx:1.25-alpine
+
+# Copy nginx configuration
+COPY nginx.conf /etc/nginx/conf.d/default.conf
+
+# Copy built files from build stage
+COPY --from=build /app/ui/build /usr/share/nginx/html
+
+# Add healthcheck
+HEALTHCHECK --interval=30s --timeout=3s --start-period=10s --retries=3 \
+  CMD wget --quiet --tries=1 --spider http://127.0.0.1/health || exit 1
+
+# Expose port
+EXPOSE 80
+
+# Start nginx
+CMD ["nginx", "-g", "daemon off;"]

package/client/dist/client.d.ts

@@ -314,6 +314,53 @@ export declare class SchedulerClient {
         traceId?: string;
     }): Promise<Types.SchedulerTickResponse>;
 }
+export declare class HttpTrafficClient {
+    private client;
+    constructor(client: AxiosInstance);
+    private call;
+    list(params?: {
+        filter?: Types.HttpTrafficFilter;
+        limit?: number;
+        offset?: number;
+        traceId?: string;
+    }): Promise<{
+        entries: Types.HttpTrafficEntry[];
+        total: number;
+        limit: number;
+        offset: number;
+    } & {
+        traceId: string;
+    }>;
+    getDetails(params: {
+        id: string;
+        traceId?: string;
+    }): Promise<{
+        entry: Types.HttpTrafficEntry;
+    } & {
+        traceId: string;
+    }>;
+    clear(params?: {
+        traceId?: string;
+    }): Promise<{
+        message: string;
+    } & {
+        traceId: string;
+    }>;
+    waitFor(params: {
+        filter: Types.HttpTrafficWaitFilter;
+        timeout?: number;
+        traceId?: string;
+    }): Promise<{
+        entry: Types.HttpTrafficEntry;
+        foundAt: number;
+        traceId: string;
+    }>;
+    stats(params?: {
+        traceId?: string;
+    }): Promise<Types.HttpTrafficStats & {
+        traceId: string;
+    }>;
+}
 export declare class DevToolsClient {
     private client;
     private baseUrl;
@@ -326,6 +373,7 @@ export declare class DevToolsClient {
     docker: DockerClient;
     platform: PlatformClient;
     scheduler: SchedulerClient;
+    httpTraffic: HttpTrafficClient;
     constructor(config?: DevToolsClientConfig);
     generateTraceId(prefix?: string): string;
 }

package/client/dist/client.js

@@ -22,7 +22,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DevToolsClient = exports.SchedulerClient = exports.PlatformClient = exports.DockerClient = exports.MqttClient = exports.FirestoreClient = exports.RedisClient = exports.PostgresClient = exports.LoggingClient = exports.PubSubClient = void 0;
+exports.DevToolsClient = exports.HttpTrafficClient = exports.SchedulerClient = exports.PlatformClient = exports.DockerClient = exports.MqttClient = exports.FirestoreClient = exports.RedisClient = exports.PostgresClient = exports.LoggingClient = exports.PubSubClient = void 0;
 const axios_1 = __importDefault(require("axios"));
 // ============================================================================
 // PubSub Client
@@ -473,6 +473,55 @@ class SchedulerClient {
 }
 exports.SchedulerClient = SchedulerClient;
 // ============================================================================
+// HTTP Traffic Client
+// ============================================================================
+class HttpTrafficClient {
+    constructor(client) {
+        this.client = client;
+    }
+    async call(endpoint, data = {}) {
+        const response = await this.client.post(endpoint, data);
+        return response.data;
+    }
+    async list(params = {}) {
+        const result = await this.call('/v1/http-traffic/list', {
+            filter: params.filter,
+            limit: params.limit,
+            offset: params.offset,
+            traceId: params.traceId
+        });
+        return result.data;
+    }
+    async getDetails(params) {
+        const result = await this.call('/v1/http-traffic/details', {
+            id: params.id,
+            traceId: params.traceId
+        });
+        return result.data;
+    }
+    async clear(params = {}) {
+        const result = await this.call('/v1/http-traffic/clear', {
+            traceId: params.traceId
+        });
+        return result.data;
+    }
+    async waitFor(params) {
+        const result = await this.call('/v1/http-traffic/wait-for', {
+            filter: params.filter,
+            timeout: params.timeout,
+            traceId: params.traceId
+        });
+        return result.data;
+    }
+    async stats(params = {}) {
+        const result = await this.call('/v1/http-traffic/stats', {
+            traceId: params.traceId
+        });
+        return result.data;
+    }
+}
+exports.HttpTrafficClient = HttpTrafficClient;
+// ============================================================================
 // Main DevTools Client
 // ============================================================================
 class DevToolsClient {
@@ -494,6 +543,7 @@ class DevToolsClient {
         this.docker = new DockerClient(this.client);
         this.platform = new PlatformClient(this.client);
         this.scheduler = new SchedulerClient(this.client);
+        this.httpTraffic = new HttpTrafficClient(this.client);
     }
     // ============================================================================
     // Utility Methods

package/client/dist/types.d.ts

@@ -278,3 +278,62 @@ export interface DockerContainer {
         canRestart: boolean;
     };
 }
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+export interface HttpTrafficEntry {
+    _id: string;
+    method: string;
+    targetUrl: string;
+    targetHost: string | null;
+    targetPath: string | null;
+    queryParams: string | null;
+    requestHeaders: string | null;
+    requestBody: string | null;
+    requestCookies: string | null;
+    contentType: string | null;
+    statusCode: number | null;
+    responseHeaders: string | null;
+    responseBody: string | null;
+    responseContentType: string | null;
+    responseTimeMs: number | null;
+    startedAt: string;
+    completedAt: string | null;
+    sourceService: string | null;
+    error: string | null;
+    traceId: string | null;
+    createdAt: string;
+}
+export interface HttpTrafficFilter {
+    method?: HttpMethod;
+    targetHost?: string;
+    sourceService?: string;
+    statusCode?: number;
+    traceId?: string;
+    since?: string;
+    until?: string;
+}
+export interface HttpTrafficWaitFilter {
+    method?: HttpMethod;
+    targetHost?: string;
+    sourceService?: string;
+    statusCode?: number;
+    traceId?: string;
+    pathContains?: string;
+}
+export interface HttpTrafficStats {
+    total: number;
+    errorCount: number;
+    errorRate: string;
+    avgResponseTimeMs: number;
+    byMethod: {
+        method: string;
+        count: number;
+    }[];
+    byHost: {
+        source_service: string | null;
+        count: number;
+    }[];
+    byStatus: {
+        status_code: number | null;
+        count: number;
+    }[];
+}

package/docker-compose.dev.yml

@@ -0,0 +1,81 @@
+# App services (dev-tools backend + UI)
+# Requires shared services running first: docker compose -f docker-compose.services.yml up -d
+# Then start: docker compose -f docker-compose.dev.yml up -d
+
+services:
+  backend:
+    image: goki-dev-tools-backend
+    build:
+      context: .
+      dockerfile: Dockerfile.dev
+      args:
+        NPM_TOKEN: ${NPM_TOKEN}
+    container_name: goki-dev-tools-backend
+    ports:
+      - "9000:9000"   # Backend API
+      - "8087:8087"   # Cloud Logging Emulator
+      - "8883:8883"   # MQTT Broker
+    environment:
+      - NODE_ENV=development
+      - WEB_UI_PORT=9000
+      # Shared services (use container names for cross-compose networking)
+      - POSTGRES_HOST=goki-postgres
+      - POSTGRES_PORT=5432
+      - POSTGRES_USER=postgres
+      - POSTGRES_PASSWORD=postgres
+      - POSTGRES_DATABASE=device_native
+      - REDIS_HOST=goki-redis
+      - REDIS_PORT=6379
+      - REDIS_LOGS_HOST=goki-redis-logs
+      - REDIS_LOGS_PORT=6380
+      - PUBSUB_EMULATOR_HOST=goki-pubsub-emulator:8085
+      - FIRESTORE_EMULATOR_HOST=goki-firestore-emulator:8080
+      - FIRESTORE_PROJECT_ID=tipi-development
+      - FIRESTORE_PROJECT_IDS=tipi-development,goki-dev-local
+      # App-specific config
+      - LOGGING_PORT=8087
+      - MQTT_PORT=8883
+      - DATA_DIR=/app/data
+      - AUTO_FLUSH_INTERVAL_MS=5000
+      - LOG_LEVEL=info
+      - UI_DEV_SERVER=http://goki-dev-tools-frontend:9001
+      - CHOKIDAR_USEPOLLING=true
+      - HOST_PROJECT_DIR=${HOST_PROJECT_DIR:-${PWD}}
+    volumes:
+      - ./src:/app/src:ro
+      - ./docs:/app/docs:ro
+      - ./data:/app/data
+      - ./logs:/app/logs
+      - /var/run/docker.sock:/var/run/docker.sock:ro
+    depends_on:
+      - frontend
+    networks:
+      - goki-network
+    restart: unless-stopped
+
+  frontend:
+    image: goki-dev-tools-frontend
+    build:
+      context: ./ui
+      dockerfile: Dockerfile.dev
+    container_name: goki-dev-tools-frontend
+    ports:
+      - "9001:9001"   # React dev server
+    environment:
+      - PORT=9001
+      - CHOKIDAR_USEPOLLING=true
+      - WATCHPACK_POLLING=true
+      - WDS_SOCKET_PORT=9001
+    volumes:
+      - ./ui/src:/app/src
+      - ./ui/public:/app/public
+      - ./ui/tailwind.config.js:/app/tailwind.config.js:ro
+      - ./ui/postcss.config.js:/app/postcss.config.js:ro
+    networks:
+      - goki-network
+    restart: unless-stopped
+
+
+networks:
+  goki-network:
+    external: true

package/docker-compose.services.yml

@@ -0,0 +1,186 @@
+# Shared infrastructure services (PostgreSQL, Redis, Emulators)
+# Start these first: docker compose -f docker-compose.services.yml up -d
+# Then start app services: docker compose -f docker-compose.dev.yml up -d
+
+services:
+  postgres:
+    image: postgres:15-alpine
+    container_name: goki-postgres
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres-data:/var/lib/postgresql/data
+    networks:
+      - goki-network
+    restart: unless-stopped
+    labels:
+      - "goki.service=postgres"
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+    profiles:
+      - postgres
+
+  redis:
+    image: redis:7-alpine
+    container_name: goki-redis
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis-data:/data
+    networks:
+      - goki-network
+    restart: unless-stopped
+    labels:
+      - "goki.service=redis"
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+
+  redis-logs:
+    image: redis:7-alpine
+    container_name: goki-redis-logs
+    command: redis-server --port 6380 --maxmemory 256mb --maxmemory-policy allkeys-lru
+    ports:
+      - "6380:6380"
+    volumes:
+      - redis-logs-data:/data
+    networks:
+      - goki-network
+    restart: unless-stopped
+    labels:
+      - "goki.service=redis-logs"
+    healthcheck:
+      test: ["CMD", "redis-cli", "-p", "6380", "ping"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+    profiles:
+      - redis-logs
+
+  pubsub-emulator:
+    image: gcr.io/google.com/cloudsdktool/google-cloud-cli:emulators
+    container_name: goki-pubsub-emulator
+    command: gcloud beta emulators pubsub start --host-port=0.0.0.0:8085 --project=tipi-development
+    ports:
+      - "8085:8085"
+    networks:
+      - goki-network
+    restart: unless-stopped
+    labels:
+      - "goki.service=pubsub-emulator"
+    healthcheck:
+      test: ["CMD-SHELL", "curl -sf http://localhost:8085/v1/projects/tipi-development/topics || exit 1"]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+      start_period: 10s
+
+  firestore-emulator:
+    image: gcr.io/google.com/cloudsdktool/google-cloud-cli:emulators
+    container_name: goki-firestore-emulator
+    entrypoint: /bin/bash
+    command:
+      - -c
+      - |
+        IMPORT_FILE=$$(find /data/firestore-export -name '*.overall_export_metadata' 2>/dev/null | head -1)
+        if [ -n "$$IMPORT_FILE" ]; then
+          echo "Importing Firestore data from $$IMPORT_FILE"
+          exec gcloud emulators firestore start --host-port=0.0.0.0:8080 --project=goki-dev-local --export-on-exit=/data/firestore-export --import-data="$$IMPORT_FILE"
+        else
+          echo "No previous export found, starting fresh"
+          exec gcloud emulators firestore start --host-port=0.0.0.0:8080 --project=goki-dev-local --export-on-exit=/data/firestore-export
+        fi
+    ports:
+      - "8080:8080"
+    volumes:
+      - firestore-data:/data
+    networks:
+      - goki-network
+    restart: unless-stopped
+    labels:
+      - "goki.service=firestore-emulator"
+    healthcheck:
+      test: ["CMD-SHELL", "curl -sf http://localhost:8080/ || exit 1"]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+      start_period: 10s
+    profiles:
+      - firestore
+
+  elasticsearch:
+    image: docker.elastic.co/elasticsearch/elasticsearch:8.12.0
+    container_name: goki-elasticsearch
+    environment:
+      - discovery.type=single-node
+      - xpack.security.enabled=false
+      - ES_JAVA_OPTS=-Xms1g -Xmx1g
+    ports:
+      - "9200:9200"
+    volumes:
+      - elasticsearch-data:/usr/share/elasticsearch/data
+    networks:
+      - goki-network
+    restart: unless-stopped
+    labels:
+      - "goki.service=elasticsearch"
+    deploy:
+      resources:
+        limits:
+          memory: 2g
+    healthcheck:
+      test: ["CMD-SHELL", "curl -sf http://localhost:9200/_cluster/health || exit 1"]
+      interval: 10s
+      timeout: 5s
+      retries: 10
+      start_period: 30s
+    profiles:
+      - elasticsearch
+
+  kibana:
+    image: docker.elastic.co/kibana/kibana:8.12.0
+    container_name: goki-kibana
+    environment:
+      - ELASTICSEARCH_HOSTS=http://elasticsearch:9200
+    ports:
+      - "5601:5601"
+    depends_on:
+      elasticsearch:
+        condition: service_healthy
+    networks:
+      - goki-network
+    restart: unless-stopped
+    labels:
+      - "goki.service=kibana"
+    deploy:
+      resources:
+        limits:
+          memory: 1g
+    healthcheck:
+      test: ["CMD-SHELL", "curl -sf http://localhost:5601/api/status || exit 1"]
+      interval: 10s
+      timeout: 5s
+      retries: 10
+      start_period: 60s
+    profiles:
+      - kibana
+
+networks:
+  goki-network:
+    name: goki-network
+    driver: bridge
+
+volumes:
+  postgres-data:
+  redis-data:
+  redis-logs-data:
+  firestore-data:
+  elasticsearch-data:

package/docker-compose.yml

@@ -0,0 +1,233 @@
+services:
+  pubsub-emulator:
+    image: gcr.io/google.com/cloudsdktool/google-cloud-cli:emulators
+    container_name: goki-pubsub-emulator
+    command: gcloud beta emulators pubsub start --host-port=0.0.0.0:8085 --project=tipi-development
+    ports:
+      - "8085:8085"
+    networks:
+      - goki-network
+    restart: unless-stopped
+    labels:
+      - "goki.service=pubsub-emulator"
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8085"]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+      start_period: 10s
+
+  firestore-emulator:
+    image: gcr.io/google.com/cloudsdktool/google-cloud-cli:emulators
+    container_name: goki-firestore-emulator
+    entrypoint: /bin/bash
+    command:
+      - -c
+      - |
+        IMPORT_FILE=$$(find /data/firestore-export -name '*.overall_export_metadata' 2>/dev/null | head -1)
+        if [ -n "$$IMPORT_FILE" ]; then
+          echo "Importing Firestore data from $$IMPORT_FILE"
+          exec gcloud emulators firestore start --host-port=0.0.0.0:8081 --project=goki-dev-local --export-on-exit=/data/firestore-export --import-data="$$IMPORT_FILE"
+        else
+          echo "No previous export found, starting fresh"
+          exec gcloud emulators firestore start --host-port=0.0.0.0:8081 --project=goki-dev-local --export-on-exit=/data/firestore-export
+        fi
+    ports:
+      - "8081:8081"
+    volumes:
+      - firestore-data:/data
+    networks:
+      - goki-network
+    restart: unless-stopped
+    labels:
+      - "goki.service=firestore-emulator"
+    healthcheck:
+      test: ["CMD-SHELL", "curl -sf http://localhost:8081 || exit 1"]
+      interval: 10s
+      timeout: 10s
+      retries: 12
+      start_period: 60s
+    profiles:
+      - firestore
+
+  dev-tools-backend:
+    build:
+      context: .
+      dockerfile: Dockerfile.backend
+      args:
+        NPM_TOKEN: ${NPM_TOKEN}
+    container_name: goki-dev-tools-backend
+    ports:
+      - "9000:9000"   # Backend API
+      - "8086:8086"   # AWS IoT Core HTTPS API
+      - "8087:8087"   # Cloud Logging Emulator
+      - "8883:8883"   # MQTT Broker
+    labels:
+      - "goki.service=dev-tools-backend"
+    environment:
+      - NODE_ENV=production
+      - WEB_UI_PORT=9000
+      - PUBSUB_EMULATOR_HOST=pubsub-emulator:8085
+      - PUBSUB_PROJECT_ID=tipi-development
+      - SHADOW_POLL_INTERVAL_MS=200
+      - SHADOW_SUBSCRIPTION_CHECK_INTERVAL_MS=5000
+      - LOGGING_PORT=8087
+      - MQTT_PORT=8883
+      - AWS_IOT_PORT=8086
+      - FIRESTORE_EMULATOR_HOST=goki-firestore-emulator:8080
+      - FIRESTORE_PORT=8080
+      - FIRESTORE_PROJECT_ID=tipi-development
+      - DATA_DIR=/app/data
+      - AUTO_FLUSH_INTERVAL_MS=5000
+      - REDIS_HOST=redis
+      - REDIS_PORT=6379
+      - POSTGRES_HOST=postgres
+      - POSTGRES_PORT=5432
+      - POSTGRES_USER=postgres
+      - POSTGRES_PASSWORD=postgres
+      - LOG_LEVEL=info
+      # App Gateway config (use container names)
+      - APP_GATEWAY_PROPERTY_ID=550e8400-e29b-41d4-a716-446655440000
+      - APP_GATEWAY_DEVICE_NATIVE_URL=http://device-native-app:3000
+      - APP_GATEWAY_DEVICE_SIMULATOR_URL=http://device-simulator-app:3000
+      - APP_GATEWAY_SCAN_INTERVAL_SECONDS=30
+      - APP_GATEWAY_AUTO_START=true
+    volumes:
+      - ./data:/app/data
+      - ./logs:/app/logs
+      - /var/run/docker.sock:/var/run/docker.sock
+    depends_on:
+      pubsub-emulator:
+        condition: service_healthy
+      redis:
+        condition: service_started
+      # Note: firestore and postgres are optional (have profiles)
+      # App should gracefully handle missing connections
+    networks:
+      - goki-network
+    restart: unless-stopped
+
+  dev-tools-frontend:
+    build:
+      context: .
+      dockerfile: Dockerfile.frontend
+    container_name: goki-dev-tools-frontend
+    ports:
+      - "9001:80"     # Frontend UI
+    labels:
+      - "goki.service=dev-tools-frontend"
+    depends_on:
+      - dev-tools-backend
+    networks:
+      - goki-network
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD-SHELL", "wget --quiet --tries=1 --spider http://127.0.0.1/health || exit 1"]
+      interval: 30s
+      timeout: 3s
+      start_period: 10s
+      retries: 3
+
+  redis:
+    image: redis:7-alpine
+    container_name: goki-redis
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis-data:/data
+    networks:
+      - goki-network
+    restart: unless-stopped
+    labels:
+      - "goki.service=redis"
+
+  postgres:
+    image: postgres:15-alpine
+    container_name: goki-postgres
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres-data:/var/lib/postgresql/data
+    networks:
+      - goki-network
+    restart: unless-stopped
+    labels:
+      - "goki.service=postgres"
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+    profiles:
+      - postgres
+
+  elasticsearch:
+    image: docker.elastic.co/elasticsearch/elasticsearch:8.12.0
+    container_name: goki-elasticsearch
+    environment:
+      - discovery.type=single-node
+      - xpack.security.enabled=false
+      - ES_JAVA_OPTS=-Xms1g -Xmx1g
+    ports:
+      - "9200:9200"
+    volumes:
+      - elasticsearch-data:/usr/share/elasticsearch/data
+    networks:
+      - goki-network
+    restart: unless-stopped
+    labels:
+      - "goki.service=elasticsearch"
+    deploy:
+      resources:
+        limits:
+          memory: 2g
+    healthcheck:
+      test: ["CMD-SHELL", "curl -sf http://localhost:9200/_cluster/health || exit 1"]
+      interval: 10s
+      timeout: 5s
+      retries: 10
+      start_period: 30s
+    profiles:
+      - elasticsearch
+
+  kibana:
+    image: docker.elastic.co/kibana/kibana:8.12.0
+    container_name: goki-kibana
+    environment:
+      - ELASTICSEARCH_HOSTS=http://elasticsearch:9200
+    ports:
+      - "5601:5601"
+    depends_on:
+      elasticsearch:
+        condition: service_healthy
+    networks:
+      - goki-network
+    restart: unless-stopped
+    labels:
+      - "goki.service=kibana"
+    deploy:
+      resources:
+        limits:
+          memory: 1g
+    healthcheck:
+      test: ["CMD-SHELL", "curl -sf http://localhost:5601/api/status || exit 1"]
+      interval: 10s
+      timeout: 5s
+      retries: 10
+      start_period: 60s
+    profiles:
+      - kibana
+
+networks:
+  goki-network:
+    name: goki-network
+    driver: bridge
+
+volumes:
+  redis-data:
+  postgres-data:
+  firestore-data:
+  elasticsearch-data:

package/nginx.conf

@@ -0,0 +1,41 @@
+server {
+    listen 80;
+    server_name localhost;
+    root /usr/share/nginx/html;
+    index index.html;
+
+    # Gzip compression
+    gzip on;
+    gzip_vary on;
+    gzip_min_length 1024;
+    gzip_types text/plain text/css text/xml text/javascript application/x-javascript application/xml+rss application/json application/javascript;
+
+    # Security headers
+    add_header X-Frame-Options "SAMEORIGIN" always;
+    add_header X-Content-Type-Options "nosniff" always;
+    add_header X-XSS-Protection "1; mode=block" always;
+
+    # Serve static files
+    location / {
+        try_files $uri $uri/ /index.html;
+    }
+
+    # Cache static assets
+    location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot)$ {
+        expires 1y;
+        add_header Cache-Control "public, immutable";
+    }
+
+    # Don't cache index.html
+    location = /index.html {
+        add_header Cache-Control "no-store, no-cache, must-revalidate";
+        expires 0;
+    }
+
+    # Health check endpoint
+    location /health {
+        access_log off;
+        return 200 "healthy\n";
+        add_header Content-Type text/plain;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gokiteam/goki-dev",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Unified local development platform for Goki services",
   "type": "module",
   "main": "./client/dist/index.js",
@@ -29,6 +29,14 @@
     "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/",
@@ -42,7 +50,10 @@
     "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",
+    "prepublishOnly": "npm run ui:build && npm run build:client",
+    "release": "npm version patch && npm run build:client && npm publish",
+    "release:minor": "npm version minor && npm run build:client && npm publish",
+    "release:major": "npm version major && npm run build: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'",

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/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

@@ -147,8 +147,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"]