@gokiteam/goki-dev 0.2.0

package/src/singletons/TickService.js

@@ -0,0 +1,151 @@
+// TickService - Publishes one-minute tick messages to Pub/Sub
+// Simple toggle service for simulating Cloud Scheduler behavior
+
+import { Application } from '../configs/Application.js'
+import { Logger } from './Logger.js'
+
+const { pubsub } = Application
+const PUBSUB_API = `http://${pubsub.emulatorHost}:${pubsub.emulatorPort}`
+const PROJECT_ID = pubsub.projectId
+
+class TickServiceClass {
+  constructor () {
+    this.interval = null
+    this.running = false
+    this.topic = 'systemOneMinuteTick'
+    this.lastTickAt = null
+    this.tickCount = 0
+  }
+
+  async start () {
+    if (this.running) {
+      return { success: false, message: 'Already running' }
+    }
+    this.running = true
+    this.tickCount = 0
+    // Ensure topic exists
+    await this.ensureTopic()
+    // Publish immediately, then every minute
+    await this.publishTick()
+    this.interval = setInterval(() => this.publishTick(), 60000)
+    Logger.log({
+      level: 'info',
+      message: 'Tick service started',
+      data: { topic: this.topic, intervalMs: 60000 }
+    })
+    return { success: true, message: 'Tick service started' }
+  }
+
+  stop () {
+    if (!this.running) {
+      return { success: false, message: 'Not running' }
+    }
+    clearInterval(this.interval)
+    this.interval = null
+    this.running = false
+    Logger.log({
+      level: 'info',
+      message: 'Tick service stopped',
+      data: { topic: this.topic, totalTicks: this.tickCount }
+    })
+    return { success: true, message: 'Tick service stopped' }
+  }
+
+  async ensureTopic () {
+    try {
+      // Check if topic exists
+      const response = await fetch(`${PUBSUB_API}/v1/projects/${PROJECT_ID}/topics/${this.topic}`)
+      if (response.status === 404) {
+        // Create topic
+        await fetch(`${PUBSUB_API}/v1/projects/${PROJECT_ID}/topics/${this.topic}`, {
+          method: 'PUT',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({})
+        })
+        // Create shadow subscription for message capture
+        await fetch(`${PUBSUB_API}/v1/projects/${PROJECT_ID}/subscriptions/${this.topic}-devtools-shadow`, {
+          method: 'PUT',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ topic: `projects/${PROJECT_ID}/topics/${this.topic}` })
+        })
+        Logger.log({
+          level: 'info',
+          message: 'Created tick topic and shadow subscription',
+          data: { topic: this.topic }
+        })
+      }
+    } catch (error) {
+      Logger.log({
+        level: 'error',
+        message: 'Failed to ensure tick topic',
+        data: { error: error.message }
+      })
+    }
+  }
+
+  generateUuid () {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0
+      const v = c === 'x' ? r : (r & 0x3 | 0x8)
+      return v.toString(16)
+    })
+  }
+
+  async publishTick () {
+    try {
+      const now = new Date()
+      const traceId = this.generateUuid()
+      const tickPayload = {
+        type: 'systemOneMinuteTick',
+        tickNumber: this.tickCount + 1,
+        timestamp: now.toISOString()
+      }
+      const messageData = Buffer.from(JSON.stringify(tickPayload)).toString('base64')
+      const response = await fetch(`${PUBSUB_API}/v1/projects/${PROJECT_ID}/topics/${this.topic}:publish`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          messages: [{
+            data: messageData,
+            attributes: {
+              traceId
+            }
+          }]
+        })
+      })
+      if (response.ok) {
+        this.lastTickAt = now
+        this.tickCount++
+        Logger.log({
+          level: 'debug',
+          message: 'Published tick message',
+          data: { topic: this.topic, tickNumber: this.tickCount }
+        })
+      } else {
+        const error = await response.json()
+        Logger.log({
+          level: 'error',
+          message: 'Failed to publish tick',
+          data: { error: error.error?.message || response.status }
+        })
+      }
+    } catch (error) {
+      Logger.log({
+        level: 'error',
+        message: 'Failed to publish tick',
+        data: { error: error.message }
+      })
+    }
+  }
+
+  getStatus () {
+    return {
+      running: this.running,
+      topic: this.topic,
+      lastTickAt: this.lastTickAt?.toISOString() || null,
+      tickCount: this.tickCount
+    }
+  }
+}
+
+export const TickService = new TickServiceClass()

package/src/singletons/WebhookProxy.js

@@ -0,0 +1,223 @@
+import httpProxy from 'http-proxy'
+import { v4 as uuidv4 } from 'uuid'
+import { SqliteStore } from './SqliteStore.js'
+import { Logger } from './Logger.js'
+import { LogBroadcaster } from './LogBroadcaster.js'
+import { WEBHOOK_ROUTES, WEBHOOK_SETTINGS } from '../db/Tables.js'
+import { ServiceNames } from '../enums/ServiceNames.js'
+
+class WebhookProxyClass {
+  constructor () {
+    this.routes = new Map()
+    this.proxy = null
+  }
+
+  initialize () {
+    this.proxy = httpProxy.createProxyServer({
+      changeOrigin: true,
+      xfwd: true,
+      proxyTimeout: 30000
+    })
+    this.proxy.on('error', (err, req, res) => {
+      Logger.log({
+        level: 'error',
+        message: 'Webhook proxy error',
+        data: { error: err.message, url: req.url, method: req.method }
+      })
+    })
+    this.loadRoutes()
+    Logger.log({
+      level: 'info',
+      message: 'WebhookProxy initialized',
+      data: { routeCount: this.routes.size }
+    })
+  }
+
+  loadRoutes () {
+    const { data } = SqliteStore.list(WEBHOOK_ROUTES)
+    for (const route of data) {
+      this.routes.set(route.prefix, {
+        target: route.target,
+        pathRewrite: route.pathRewrite,
+        description: route.description,
+        enabled: !!route.enabled
+      })
+    }
+  }
+
+  register (config) {
+    const { prefix, target, pathRewrite, description } = config
+    const existing = SqliteStore.get(WEBHOOK_ROUTES, prefix, 'prefix')
+    if (existing) {
+      SqliteStore.update(WEBHOOK_ROUTES, prefix, {
+        target,
+        pathRewrite: pathRewrite || null,
+        description: description || null,
+        updatedAt: Math.floor(Date.now() / 1000)
+      }, 'prefix')
+    } else {
+      SqliteStore.create(WEBHOOK_ROUTES, {
+        prefix,
+        target,
+        pathRewrite: pathRewrite || null,
+        description: description || null,
+        enabled: true
+      })
+    }
+    this.routes.set(prefix, {
+      target,
+      pathRewrite: pathRewrite || null,
+      description: description || null,
+      enabled: true
+    })
+    Logger.log({
+      level: 'info',
+      message: `Webhook route registered: ${prefix} -> ${target}${pathRewrite || ''}`,
+      data: { prefix, target, pathRewrite }
+    })
+  }
+
+  remove (prefix) {
+    try {
+      SqliteStore.delete(WEBHOOK_ROUTES, prefix, 'prefix')
+    } catch {
+      // Ignore if not found
+    }
+    this.routes.delete(prefix)
+    Logger.log({
+      level: 'info',
+      message: `Webhook route removed: ${prefix}`,
+      data: { prefix }
+    })
+  }
+
+  getRoute (prefix) {
+    return this.routes.get(prefix)
+  }
+
+  listRoutes () {
+    return SqliteStore.list(WEBHOOK_ROUTES, { orderBy: 'created_at DESC' })
+  }
+
+  resolveTarget (path) {
+    const proxyMatch = path.match(/^\/v1\/webhooks\/proxy(\/.*)$/)
+    if (!proxyMatch) return null
+    const pathAfterProxy = proxyMatch[1]
+    // Try to find route by matching pathRewrite against the path after /proxy/
+    for (const [prefix, route] of this.routes.entries()) {
+      if (!route.enabled) continue
+      if (route.pathRewrite && pathAfterProxy.startsWith(route.pathRewrite)) {
+        const remainingPath = pathAfterProxy.substring(route.pathRewrite.length)
+        return {
+          prefix,
+          target: route.target,
+          path: route.pathRewrite + remainingPath,
+          fullUrl: route.target + route.pathRewrite + remainingPath
+        }
+      }
+    }
+    // Fallback: try prefix-based lookup for backward compatibility
+    const prefixMatch = pathAfterProxy.match(/^\/([^/]+)(\/.*)?$/)
+    if (prefixMatch) {
+      const prefix = prefixMatch[1]
+      const remainingPath = prefixMatch[2] || ''
+      const route = this.routes.get(prefix)
+      if (route && route.enabled) {
+        const targetPath = route.pathRewrite
+          ? route.pathRewrite + remainingPath
+          : remainingPath || '/'
+        return {
+          prefix,
+          target: route.target,
+          path: targetPath,
+          fullUrl: route.target + targetPath
+        }
+      }
+    }
+    return null
+  }
+
+  logRequest (entry) {
+    const {
+      prefix, method, originalPath, targetUrl,
+      statusCode, responseTimeMs, error,
+      queryParams, requestBody, responseBody
+    } = entry
+    const now = new Date().toISOString()
+    const severity = error || (statusCode && statusCode >= 400) ? 'ERROR' : 'INFO'
+    const statusText = error ? `ERR ${error}` : `${statusCode}`
+    const textPayload = `${method} ${originalPath} → ${statusText} (${responseTimeMs}ms)`
+    const jsonPayload = {
+      prefix,
+      method,
+      originalPath,
+      targetUrl,
+      statusCode,
+      responseTimeMs,
+      error: error || null,
+      ...(queryParams && { queryParams }),
+      ...(requestBody && { requestBody }),
+      ...(responseBody && { responseBody })
+    }
+    const logEntry = {
+      _id: uuidv4(),
+      logName: 'projects/dev-tools/logs/webhook',
+      source: ServiceNames.WEBHOOK_PROXY,
+      serviceName: ServiceNames.WEBHOOK_PROXY,
+      severity,
+      textPayload,
+      jsonPayload,
+      timestamp: now,
+      receiveTimestamp: now,
+      insertId: uuidv4(),
+      createdAt: now
+    }
+    try {
+      SqliteStore.create('logging_entries', logEntry)
+    } catch (err) {
+      Logger.log({ level: 'error', message: 'Failed to store webhook log', data: { error: err.message } })
+    }
+    LogBroadcaster.broadcast(logEntry)
+    // Update request count on route
+    try {
+      const route = SqliteStore.get(WEBHOOK_ROUTES, prefix, 'prefix')
+      if (route) {
+        SqliteStore.update(WEBHOOK_ROUTES, prefix, {
+          requestCount: (route.requestCount || 0) + 1,
+          lastRequestAt: Math.floor(Date.now() / 1000)
+        }, 'prefix')
+      }
+    } catch {
+      // Non-critical
+    }
+  }
+
+  // Settings helpers for ngrok domain etc.
+  getSetting (key) {
+    const row = SqliteStore.get(WEBHOOK_SETTINGS, key, 'key')
+    return row?.value || null
+  }
+
+  setSetting (key, value) {
+    const existing = SqliteStore.get(WEBHOOK_SETTINGS, key, 'key')
+    if (existing) {
+      SqliteStore.update(WEBHOOK_SETTINGS, key, {
+        value,
+        updatedAt: Math.floor(Date.now() / 1000)
+      }, 'key')
+    } else {
+      SqliteStore.create(WEBHOOK_SETTINGS, { key, value })
+    }
+  }
+
+  getSettings () {
+    const { data } = SqliteStore.list(WEBHOOK_SETTINGS)
+    const settings = {}
+    for (const row of data) {
+      settings[row.key] = row.value
+    }
+    return settings
+  }
+}
+
+export const WebhookProxy = new WebhookProxyClass()