@gokiteam/goki-dev 0.2.0

package/src/api/functions/Logic.js

@@ -0,0 +1,710 @@
+import { v4 as uuid } from 'uuid'
+import fs from 'fs'
+import path from 'path'
+import { exec } from 'child_process'
+import { promisify } from 'util'
+import { SqliteStore } from '../../singletons/SqliteStore.js'
+import { FunctionsService } from '../../singletons/FunctionsService.js'
+import { FunctionTriggerDispatcher } from '../../singletons/FunctionTriggerDispatcher.js'
+import { CLOUD_FUNCTIONS, CLOUD_FUNCTION_INVOCATIONS } from '../../db/Tables.js'
+import { Application } from '../../configs/Application.js'
+import { FunctionTriggerTypes, FunctionTriggerTypeList } from '../../enums/FunctionTriggerTypes.js'
+import { FunctionStatuses } from '../../enums/FunctionStatuses.js'
+
+const DEFAULT_SOURCE_DIR = path.resolve(Application.storage.dataDir || './data', 'functions')
+const CONTAINER_PROJECT_DIR = '/app'
+
+function resolveHostPath (containerPath) {
+  const hostProjectDir = Application.hostProjectDir
+  if (!hostProjectDir || !containerPath) return containerPath
+  if (containerPath.startsWith(CONTAINER_PROJECT_DIR + '/')) {
+    return path.join(hostProjectDir, containerPath.slice(CONTAINER_PROJECT_DIR.length))
+  }
+  return containerPath
+}
+
+function buildFileTree (baseDir, currentDir) {
+  const entries = fs.readdirSync(currentDir, { withFileTypes: true })
+  const result = []
+  for (const entry of entries) {
+    if (entry.name === 'node_modules' || entry.name === '.git') continue
+    const relativePath = path.relative(baseDir, path.join(currentDir, entry.name))
+    if (entry.isDirectory()) {
+      result.push({
+        name: entry.name,
+        path: relativePath,
+        type: 'directory',
+        children: buildFileTree(baseDir, path.join(currentDir, entry.name))
+      })
+    } else {
+      const ext = path.extname(entry.name).slice(1)
+      result.push({
+        name: entry.name,
+        path: relativePath,
+        type: 'file',
+        language: getLanguageFromExt(ext)
+      })
+    }
+  }
+  // Sort: directories first, then files, both alphabetically
+  result.sort((a, b) => {
+    if (a.type !== b.type) return a.type === 'directory' ? -1 : 1
+    return a.name.localeCompare(b.name)
+  })
+  return result
+}
+
+function getLanguageFromExt (ext) {
+  const map = {
+    js: 'javascript', mjs: 'javascript', cjs: 'javascript',
+    ts: 'typescript', tsx: 'typescript',
+    json: 'json',
+    md: 'markdown',
+    yaml: 'yaml', yml: 'yaml',
+    html: 'html',
+    css: 'css',
+    sh: 'shell', bash: 'shell',
+    env: 'plaintext', txt: 'plaintext'
+  }
+  return map[ext] || 'plaintext'
+}
+
+/**
+ * Ensure functions directory has a package.json with type=commonjs
+ * so that .js files can use `exports` / `module.exports` syntax
+ * (the main project has "type": "module" which would break CJS functions)
+ */
+function ensureFunctionsPackageJson (dir) {
+  const pkgPath = path.join(dir, 'package.json')
+  if (!fs.existsSync(pkgPath)) {
+    fs.writeFileSync(pkgPath, JSON.stringify({
+      name: 'cloud-functions',
+      version: '1.0.0',
+      type: 'commonjs',
+      private: true
+    }, null, 2))
+  }
+}
+
+function resolveFunction (params) {
+  const { id, name, traceId } = params
+  if (id) {
+    const fn = SqliteStore.get(CLOUD_FUNCTIONS, id)
+    if (!fn) return { success: false, message: `Function not found with id: ${id}`, traceId }
+    return fn
+  }
+  if (name) {
+    const matches = SqliteStore.find(CLOUD_FUNCTIONS, { name })
+    if (matches.length === 0) return { success: false, message: `Function not found: ${name}`, traceId }
+    return matches[0]
+  }
+  return { success: false, message: 'id or name is required', traceId }
+}
+
+function mergeLiveStatus (fn) {
+  const statuses = FunctionsService.getAllStatuses()
+  const live = statuses.find(s => s.name === fn.name)
+  if (live) {
+    return { ...fn, status: live.status, port: live.port, pid: live.pid, uptime: live.uptime }
+  }
+  return fn
+}
+
+export const Logic = {
+  async create (params) {
+    const { name, source, sourcePath, entryPoint, triggerType, triggerConfig, signatureType, runtime, environmentVariables, timeoutSeconds, description, traceId } = params
+    if (!name) return { success: false, message: 'name is required', traceId }
+    if (!source && !sourcePath) return { success: false, message: 'source or sourcePath is required', traceId }
+    if (!entryPoint) return { success: false, message: 'entryPoint is required', traceId }
+    if (!triggerType) return { success: false, message: 'triggerType is required', traceId }
+    if (!FunctionTriggerTypeList.includes(triggerType)) {
+      return { success: false, message: `Invalid triggerType. Must be one of: ${FunctionTriggerTypeList.join(', ')}`, traceId }
+    }
+    const existing = SqliteStore.find(CLOUD_FUNCTIONS, { name })
+    if (existing.length > 0) {
+      return { success: false, message: `Function with name '${name}' already exists`, traceId }
+    }
+    let resolvedSourcePath = sourcePath
+    let resolvedSource = source
+    if (!sourcePath && source) {
+      const funcDir = path.join(DEFAULT_SOURCE_DIR, name)
+      if (!fs.existsSync(funcDir)) {
+        fs.mkdirSync(funcDir, { recursive: true })
+      }
+      ensureFunctionsPackageJson(funcDir)
+      resolvedSourcePath = funcDir
+      const sourceFile = path.join(funcDir, 'index.js')
+      fs.writeFileSync(sourceFile, source)
+      resolvedSource = 'index.js'
+    }
+    const id = uuid()
+    const record = {
+      id,
+      name,
+      source: resolvedSource,
+      sourcePath: resolvedSourcePath || null,
+      entryPoint,
+      triggerType,
+      triggerConfig: triggerConfig || {},
+      signatureType: signatureType || 'cloudevent',
+      runtime: runtime || 'nodejs20',
+      environmentVariables: environmentVariables || {},
+      timeoutSeconds: timeoutSeconds || 60,
+      description: description || '',
+      status: FunctionStatuses.STOPPED,
+      enabled: 1,
+      invocationCount: 0,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString()
+    }
+    SqliteStore.create(CLOUD_FUNCTIONS, record)
+    try {
+      await FunctionsService.deployFunction(record)
+      FunctionTriggerDispatcher.registerFunction(record)
+    } catch (error) {
+      // Function created in DB but failed to start - record error status
+      SqliteStore.update(CLOUD_FUNCTIONS, id, {
+        status: FunctionStatuses.ERROR,
+        errorMessage: error.message
+      })
+    }
+    const created = SqliteStore.get(CLOUD_FUNCTIONS, id)
+    return {
+      data: { function: mergeLiveStatus(created) },
+      message: 'Function created',
+      traceId
+    }
+  },
+
+  list (params) {
+    const { filter, limit, offset, traceId } = params
+    const options = {
+      orderBy: 'created_at DESC'
+    }
+    if (limit !== undefined) options.limit = limit
+    if (offset !== undefined) options.offset = offset
+    if (filter) {
+      const where = {}
+      if (filter.triggerType) where.triggerType = filter.triggerType
+      if (filter.status) where.status = filter.status
+      if (filter.enabled !== undefined) where.enabled = filter.enabled ? 1 : 0
+      if (Object.keys(where).length > 0) options.where = where
+    }
+    const { data, total } = SqliteStore.list(CLOUD_FUNCTIONS, options)
+    const functions = data.map(fn => mergeLiveStatus(fn))
+    return { data: { functions, total }, traceId }
+  },
+
+  details (params) {
+    const fn = resolveFunction(params)
+    if (fn.success === false) return fn
+    const fnData = mergeLiveStatus(fn)
+    fnData.hostSourcePath = resolveHostPath(fn.sourcePath)
+    return { data: { function: fnData }, traceId: params.traceId }
+  },
+
+  async update (params) {
+    const { id, name, traceId, ...updates } = params
+    const fn = resolveFunction({ id, name, traceId })
+    if (fn.success === false) return fn
+    const allowedFields = ['description', 'triggerConfig', 'enabled', 'environmentVariables', 'timeoutSeconds', 'entryPoint', 'signatureType']
+    const cleanUpdates = {}
+    for (const field of allowedFields) {
+      if (updates[field] !== undefined) cleanUpdates[field] = updates[field]
+    }
+    if (Object.keys(cleanUpdates).length === 0) {
+      return { success: false, message: 'No valid fields to update', traceId }
+    }
+    cleanUpdates.updatedAt = new Date().toISOString()
+    const triggerConfigChanged = cleanUpdates.triggerConfig !== undefined &&
+      JSON.stringify(cleanUpdates.triggerConfig) !== JSON.stringify(fn.triggerConfig)
+    const enabledChanged = cleanUpdates.enabled !== undefined && cleanUpdates.enabled !== fn.enabled
+    SqliteStore.update(CLOUD_FUNCTIONS, fn.id, cleanUpdates)
+    if (triggerConfigChanged) {
+      FunctionTriggerDispatcher.unregisterFunction(fn)
+      const updatedFn = SqliteStore.get(CLOUD_FUNCTIONS, fn.id)
+      FunctionTriggerDispatcher.registerFunction(updatedFn)
+    }
+    if (enabledChanged) {
+      if (cleanUpdates.enabled) {
+        try {
+          await FunctionsService.startFunction(fn.name)
+          const updatedFn = SqliteStore.get(CLOUD_FUNCTIONS, fn.id)
+          FunctionTriggerDispatcher.registerFunction(updatedFn)
+        } catch (error) {
+          SqliteStore.update(CLOUD_FUNCTIONS, fn.id, {
+            status: FunctionStatuses.ERROR,
+            errorMessage: error.message
+          })
+        }
+      } else {
+        try {
+          await FunctionsService.stopFunction(fn.name)
+        } catch {
+          // may not be running
+        }
+        FunctionTriggerDispatcher.unregisterFunction(fn)
+      }
+    }
+    const updated = SqliteStore.get(CLOUD_FUNCTIONS, fn.id)
+    return {
+      data: { function: mergeLiveStatus(updated) },
+      message: 'Function updated',
+      traceId
+    }
+  },
+
+  async delete (params) {
+    const fn = resolveFunction(params)
+    if (fn.success === false) return fn
+    try {
+      await FunctionsService.removeFunction(fn.name)
+    } catch {
+      // may not be running
+    }
+    FunctionTriggerDispatcher.unregisterFunction(fn)
+    // Delete invocations for this function
+    try {
+      const invocations = SqliteStore.find(CLOUD_FUNCTION_INVOCATIONS, { functionId: fn.id })
+      for (const inv of invocations) {
+        SqliteStore.delete(CLOUD_FUNCTION_INVOCATIONS, inv.id)
+      }
+    } catch {
+      // Ignore cleanup errors
+    }
+    SqliteStore.delete(CLOUD_FUNCTIONS, fn.id)
+    return { message: `Function '${fn.name}' deleted`, traceId: params.traceId }
+  },
+
+  async start (params) {
+    const fn = resolveFunction(params)
+    if (fn.success === false) return fn
+    try {
+      const status = await FunctionsService.startFunction(fn.name)
+      return {
+        data: { function: mergeLiveStatus(SqliteStore.get(CLOUD_FUNCTIONS, fn.id)), status },
+        message: `Function '${fn.name}' started`,
+        traceId: params.traceId
+      }
+    } catch (error) {
+      return { success: false, message: `Failed to start function: ${error.message}`, traceId: params.traceId }
+    }
+  },
+
+  async stop (params) {
+    const fn = resolveFunction(params)
+    if (fn.success === false) return fn
+    try {
+      await FunctionsService.stopFunction(fn.name)
+      return {
+        data: { function: mergeLiveStatus(SqliteStore.get(CLOUD_FUNCTIONS, fn.id)) },
+        message: `Function '${fn.name}' stopped`,
+        traceId: params.traceId
+      }
+    } catch (error) {
+      return { success: false, message: `Failed to stop function: ${error.message}`, traceId: params.traceId }
+    }
+  },
+
+  async restart (params) {
+    const fn = resolveFunction(params)
+    if (fn.success === false) return fn
+    try {
+      const status = await FunctionsService.restartFunction(fn.name)
+      return {
+        data: { function: mergeLiveStatus(SqliteStore.get(CLOUD_FUNCTIONS, fn.id)), status },
+        message: `Function '${fn.name}' restarted`,
+        traceId: params.traceId
+      }
+    } catch (error) {
+      return { success: false, message: `Failed to restart function: ${error.message}`, traceId: params.traceId }
+    }
+  },
+
+  readSource (params) {
+    const fn = resolveFunction(params)
+    if (fn.success === false) return fn
+    if (!fn.sourcePath || !fn.source) {
+      return { success: false, message: 'Function has no source path configured', traceId: params.traceId }
+    }
+    const filePath = path.isAbsolute(fn.source)
+      ? fn.source
+      : path.join(fn.sourcePath, fn.source)
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8')
+      return {
+        data: { source: content, filePath },
+        traceId: params.traceId
+      }
+    } catch (error) {
+      return { success: false, message: `Failed to read source: ${error.message}`, traceId: params.traceId }
+    }
+  },
+
+  async updateSource (params) {
+    const { content, traceId } = params
+    const fn = resolveFunction(params)
+    if (fn.success === false) return fn
+    if (!content) return { success: false, message: 'content is required', traceId }
+    if (!fn.sourcePath || !fn.source) {
+      return { success: false, message: 'Function has no source path configured', traceId }
+    }
+    const filePath = path.isAbsolute(fn.source)
+      ? fn.source
+      : path.join(fn.sourcePath, fn.source)
+    try {
+      fs.writeFileSync(filePath, content)
+      SqliteStore.update(CLOUD_FUNCTIONS, fn.id, { updatedAt: new Date().toISOString() })
+    } catch (error) {
+      return { success: false, message: `Failed to write source: ${error.message}`, traceId }
+    }
+    // Restart function to pick up changes
+    try {
+      await FunctionsService.restartFunction(fn.name)
+    } catch {
+      // Function may not be running
+    }
+    return {
+      data: { filePath },
+      message: 'Source updated and function restarted',
+      traceId
+    }
+  },
+
+  readDependencies (params) {
+    const fn = resolveFunction(params)
+    if (fn.success === false) return fn
+    const dir = fn.sourcePath || DEFAULT_SOURCE_DIR
+    const pkgPath = path.join(dir, 'package.json')
+    try {
+      if (!fs.existsSync(pkgPath)) {
+        return {
+          data: {
+            packageJson: JSON.stringify({
+              name: 'cloud-functions',
+              version: '1.0.0',
+              type: 'commonjs',
+              private: true,
+              dependencies: {}
+            }, null, 2),
+            exists: false
+          },
+          traceId: params.traceId
+        }
+      }
+      const content = fs.readFileSync(pkgPath, 'utf-8')
+      return { data: { packageJson: content, exists: true }, traceId: params.traceId }
+    } catch (error) {
+      return { success: false, message: `Failed to read package.json: ${error.message}`, traceId: params.traceId }
+    }
+  },
+
+  async updateDependencies (params) {
+    const { packageJson, install, traceId } = params
+    const fn = resolveFunction(params)
+    if (fn.success === false) return fn
+    if (!packageJson) return { success: false, message: 'packageJson is required', traceId }
+    const dir = fn.sourcePath || DEFAULT_SOURCE_DIR
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true })
+    }
+    const pkgPath = path.join(dir, 'package.json')
+    try {
+      JSON.parse(packageJson)
+    } catch {
+      return { success: false, message: 'packageJson must be valid JSON', traceId }
+    }
+    try {
+      fs.writeFileSync(pkgPath, packageJson)
+    } catch (error) {
+      return { success: false, message: `Failed to write package.json: ${error.message}`, traceId }
+    }
+    let installResult = null
+    if (install !== false) {
+      try {
+        const execAsync = promisify(exec)
+        const { stdout, stderr } = await execAsync('npm install --production', {
+          cwd: dir,
+          timeout: 60000
+        })
+        installResult = { success: true, stdout: stdout.trim(), stderr: stderr.trim() }
+      } catch (error) {
+        installResult = { success: false, error: error.message }
+      }
+    }
+    // Restart function to pick up new dependencies
+    try {
+      await FunctionsService.restartFunction(fn.name)
+    } catch {
+      // Function may not be running
+    }
+    return {
+      data: { filePath: pkgPath, installResult },
+      message: install !== false ? 'Dependencies updated and installed' : 'package.json updated',
+      traceId
+    }
+  },
+
+  listFiles (params) {
+    const fn = resolveFunction(params)
+    if (fn.success === false) return fn
+    const dir = fn.sourcePath || path.join(DEFAULT_SOURCE_DIR, fn.name)
+    try {
+      if (!fs.existsSync(dir)) {
+        return { data: { files: [], basePath: dir }, traceId: params.traceId }
+      }
+      const tree = buildFileTree(dir, dir)
+      return { data: { files: tree, basePath: dir }, traceId: params.traceId }
+    } catch (error) {
+      return { success: false, message: `Failed to list files: ${error.message}`, traceId: params.traceId }
+    }
+  },
+
+  readFile (params) {
+    const { filePath, traceId } = params
+    const fn = resolveFunction(params)
+    if (fn.success === false) return fn
+    const dir = fn.sourcePath || DEFAULT_SOURCE_DIR
+    // Security: prevent path traversal
+    const resolved = path.resolve(dir, filePath)
+    if (!resolved.startsWith(path.resolve(dir))) {
+      return { success: false, message: 'Invalid file path: path traversal not allowed', traceId }
+    }
+    try {
+      const content = fs.readFileSync(resolved, 'utf-8')
+      const ext = path.extname(filePath).slice(1)
+      return { data: { content, filePath, language: getLanguageFromExt(ext) }, traceId }
+    } catch (error) {
+      return { success: false, message: `Failed to read file: ${error.message}`, traceId }
+    }
+  },
+
+  async writeFile (params) {
+    const { filePath, content, traceId } = params
+    const fn = resolveFunction(params)
+    if (fn.success === false) return fn
+    const dir = fn.sourcePath || DEFAULT_SOURCE_DIR
+    // Security: prevent path traversal
+    const resolved = path.resolve(dir, filePath)
+    if (!resolved.startsWith(path.resolve(dir))) {
+      return { success: false, message: 'Invalid file path: path traversal not allowed', traceId }
+    }
+    try {
+      // Ensure parent directory exists
+      const parentDir = path.dirname(resolved)
+      if (!fs.existsSync(parentDir)) {
+        fs.mkdirSync(parentDir, { recursive: true })
+      }
+      fs.writeFileSync(resolved, content)
+      return { data: { filePath }, message: 'File saved', traceId }
+    } catch (error) {
+      return { success: false, message: `Failed to write file: ${error.message}`, traceId }
+    }
+  },
+
+  deleteFile (params) {
+    const { filePath, traceId } = params
+    const fn = resolveFunction(params)
+    if (fn.success === false) return fn
+    const dir = fn.sourcePath || DEFAULT_SOURCE_DIR
+    const resolved = path.resolve(dir, filePath)
+    if (!resolved.startsWith(path.resolve(dir))) {
+      return { success: false, message: 'Invalid file path: path traversal not allowed', traceId }
+    }
+    // Prevent deleting the main source file or package.json
+    const basename = path.basename(resolved)
+    if (basename === 'package.json' || resolved === path.resolve(dir, fn.source)) {
+      return { success: false, message: 'Cannot delete the main source file or package.json', traceId }
+    }
+    try {
+      if (!fs.existsSync(resolved)) {
+        return { success: false, message: `File not found: ${filePath}`, traceId }
+      }
+      fs.unlinkSync(resolved)
+      // Clean up empty parent directories
+      const parentDir = path.dirname(resolved)
+      if (parentDir !== path.resolve(dir) && fs.readdirSync(parentDir).length === 0) {
+        fs.rmdirSync(parentDir)
+      }
+      return { data: { filePath }, message: 'File deleted', traceId }
+    } catch (error) {
+      return { success: false, message: `Failed to delete file: ${error.message}`, traceId }
+    }
+  },
+
+  async invoke (params) {
+    const { payload, traceId } = params
+    const fn = resolveFunction(params)
+    if (fn.success === false) return fn
+    const cloudEvent = FunctionTriggerDispatcher.buildManualCloudEvent(payload)
+    try {
+      const result = await FunctionTriggerDispatcher.invokeFunction(fn, cloudEvent, 'manual')
+      return {
+        data: { invocation: result },
+        message: `Function '${fn.name}' invoked`,
+        traceId
+      }
+    } catch (error) {
+      return { success: false, message: `Invocation failed: ${error.message}`, traceId }
+    }
+  },
+
+  async callHttpFunction (params) {
+    const { functionName, method, headers, body, path: subPath, query, traceId } = params
+    const matches = SqliteStore.find(CLOUD_FUNCTIONS, { name: functionName })
+    if (matches.length === 0) {
+      return { success: false, message: `Function not found: ${functionName}`, traceId }
+    }
+    const fn = matches[0]
+    if (fn.triggerType !== FunctionTriggerTypes.HTTP) {
+      return { success: false, message: `Function '${functionName}' is not an HTTP function`, traceId }
+    }
+    const endpointUrl = FunctionsService.getEndpointUrl(fn.name)
+    if (!endpointUrl) {
+      return { success: false, message: `Function '${functionName}' is not running`, traceId }
+    }
+    const targetUrl = new URL(endpointUrl)
+    if (subPath) targetUrl.pathname = `/${subPath}`
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        targetUrl.searchParams.set(key, value)
+      }
+    }
+    const startMs = Date.now()
+    const invocationId = uuid()
+    const startedAt = new Date().toISOString()
+    try {
+      const fetchOptions = {
+        method,
+        headers: {
+          'Content-Type': headers['content-type'] || 'application/json'
+        },
+        signal: AbortSignal.timeout((fn.timeoutSeconds || 60) * 1000)
+      }
+      if (method !== 'GET' && method !== 'HEAD' && body) {
+        fetchOptions.body = typeof body === 'string' ? body : JSON.stringify(body)
+      }
+      const response = await fetch(targetUrl.toString(), fetchOptions)
+      const responseTimeMs = Date.now() - startMs
+      const responseBody = await response.text()
+      const responseHeaders = {}
+      response.headers.forEach((value, key) => {
+        responseHeaders[key] = value
+      })
+      // Record invocation
+      try {
+        SqliteStore.create(CLOUD_FUNCTION_INVOCATIONS, {
+          id: invocationId,
+          functionId: fn.id,
+          functionName: fn.name,
+          triggerType: FunctionTriggerTypes.HTTP,
+          triggerSource: `http:${method} ${subPath || '/'}`,
+          responseStatus: response.status,
+          responseBody,
+          responseTimeMs,
+          startedAt,
+          completedAt: new Date().toISOString()
+        })
+        SqliteStore.update(CLOUD_FUNCTIONS, fn.id, {
+          invocationCount: (fn.invocationCount || 0) + 1,
+          lastInvokedAt: new Date().toISOString(),
+          lastStatus: response.status
+        })
+      } catch {
+        // Ignore recording errors
+      }
+      FunctionsService.broadcastInvocation({
+        id: invocationId,
+        functionName: fn.name,
+        triggerType: FunctionTriggerTypes.HTTP,
+        responseStatus: response.status,
+        responseTimeMs,
+        completedAt: new Date().toISOString()
+      })
+      return {
+        status: response.status,
+        headers: responseHeaders,
+        body: responseBody
+      }
+    } catch (error) {
+      const responseTimeMs = Date.now() - startMs
+      try {
+        SqliteStore.create(CLOUD_FUNCTION_INVOCATIONS, {
+          id: invocationId,
+          functionId: fn.id,
+          functionName: fn.name,
+          triggerType: FunctionTriggerTypes.HTTP,
+          triggerSource: `http:${method} ${subPath || '/'}`,
+          error: error.message,
+          responseTimeMs,
+          startedAt,
+          completedAt: new Date().toISOString()
+        })
+      } catch {
+        // Ignore
+      }
+      return { success: false, message: `HTTP call failed: ${error.message}`, traceId }
+    }
+  },
+
+  listInvocations (params) {
+    const { functionId, functionName, triggerType, limit, offset, traceId } = params
+    const options = {
+      orderBy: 'started_at DESC',
+      limit: limit || 50,
+      offset: offset || 0
+    }
+    const where = {}
+    if (functionId) where.functionId = functionId
+    if (functionName) where.functionName = functionName
+    if (triggerType) where.triggerType = triggerType
+    if (Object.keys(where).length > 0) options.where = where
+    const { data, total } = SqliteStore.list(CLOUD_FUNCTION_INVOCATIONS, options)
+    return { data: { invocations: data, total }, traceId }
+  },
+
+  invocationDetails (params) {
+    const { id, traceId } = params
+    if (!id) return { success: false, message: 'id is required', traceId }
+    const invocation = SqliteStore.get(CLOUD_FUNCTION_INVOCATIONS, id)
+    if (!invocation) return { success: false, message: `Invocation not found: ${id}`, traceId }
+    return { data: { invocation }, traceId }
+  },
+
+  clearInvocations (params) {
+    const { functionId, traceId } = params
+    if (functionId) {
+      const invocations = SqliteStore.find(CLOUD_FUNCTION_INVOCATIONS, { functionId })
+      for (const inv of invocations) {
+        SqliteStore.delete(CLOUD_FUNCTION_INVOCATIONS, inv.id)
+      }
+      return { message: `Cleared ${invocations.length} invocations for function`, traceId }
+    }
+    SqliteStore.clear(CLOUD_FUNCTION_INVOCATIONS)
+    return { message: 'All invocations cleared', traceId }
+  },
+
+  stats (params) {
+    const { traceId } = params
+    const { data: allFunctions } = SqliteStore.list(CLOUD_FUNCTIONS, {})
+    const byTriggerType = {}
+    const byStatus = {}
+    for (const fn of allFunctions) {
+      byTriggerType[fn.triggerType] = (byTriggerType[fn.triggerType] || 0) + 1
+      const liveStatus = mergeLiveStatus(fn).status
+      byStatus[liveStatus] = (byStatus[liveStatus] || 0) + 1
+    }
+    const { total: totalInvocations } = SqliteStore.list(CLOUD_FUNCTION_INVOCATIONS, { limit: 0 })
+    const runtimeStatuses = FunctionsService.getAllStatuses()
+    return {
+      data: {
+        totalFunctions: allFunctions.length,
+        totalInvocations,
+        byTriggerType,
+        byStatus,
+        runningProcesses: runtimeStatuses.length
+      },
+      traceId
+    }
+  }
+}