@gokiteam/goki-dev 0.2.0

package/src/api/snapshots/Logic.js

@@ -0,0 +1,797 @@
+import { execa } from 'execa'
+import fs from 'fs/promises'
+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'
+import { Logger } from '../../singletons/Logger.js'
+import { Application } from '../../configs/Application.js'
+import { SqliteStore } from '../../singletons/SqliteStore.js'
+import {
+  PUBSUB_TOPICS,
+  PUBSUB_SUBSCRIPTIONS,
+  PUBSUB_TOPIC_REGISTRY,
+  FIRESTORE_METADATA,
+  WEBHOOK_ROUTES,
+  WEBHOOK_SETTINGS,
+  LOGGING_ENTRIES,
+  LOGGING_LOGS,
+  HTTP_TRAFFIC,
+  MQTT_MESSAGES,
+  PUBSUB_MESSAGES,
+  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')
+
+// Ensure snapshot directories exist
+async function ensureSnapshotDirs () {
+  await fs.mkdir(path.join(SNAPSHOTS_DIR, 'postgres'), { recursive: true })
+  await fs.mkdir(path.join(SNAPSHOTS_DIR, 'firestore'), { recursive: true })
+  await fs.mkdir(path.join(SNAPSHOTS_DIR, 'sqlite'), { recursive: true })
+}
+
+// Configuration tables to snapshot (important metadata)
+const CONFIG_TABLES = [
+  PUBSUB_TOPICS,
+  PUBSUB_SUBSCRIPTIONS,
+  PUBSUB_TOPIC_REGISTRY,
+  FIRESTORE_METADATA,
+  WEBHOOK_ROUTES,
+  WEBHOOK_SETTINGS
+]
+
+// Log/traffic tables to clear (not restore - fresh start for tests)
+const LOG_TABLES = [
+  LOGGING_ENTRIES,
+  LOGGING_LOGS,
+  HTTP_TRAFFIC,
+  MQTT_MESSAGES,
+  PUBSUB_MESSAGES,
+  PUBSUB_MESSAGE_HISTORY
+]
+
+// Generate snapshot ID
+function generateSnapshotId () {
+  const now = new Date()
+  const timestamp = now.toISOString().replace(/[:.]/g, '-').replace('Z', '').replace('T', '_')
+  return `e2e_${timestamp}`
+}
+
+// Get snapshot metadata file path
+function getMetadataPath () {
+  return path.join(SNAPSHOTS_DIR, 'metadata.json')
+}
+
+// Read metadata
+async function readMetadata () {
+  try {
+    const data = await fs.readFile(getMetadataPath(), 'utf8')
+    return JSON.parse(data)
+  } catch (error) {
+    return { snapshots: [] }
+  }
+}
+
+// Write metadata
+async function writeMetadata (metadata) {
+  await fs.writeFile(getMetadataPath(), JSON.stringify(metadata, null, 2))
+}
+
+// Get file size
+async function getFileSize (filePath) {
+  try {
+    const stats = await fs.stat(filePath)
+    return stats.size
+  } catch {
+    return 0
+  }
+}
+
+// PostgreSQL snapshot functions
+async function createPostgresSnapshot (database, snapshotId, traceId) {
+  const dumpPath = path.join(SNAPSHOTS_DIR, 'postgres', `${snapshotId}.dump`)
+  try {
+    Logger.log({
+      level: 'info',
+      message: 'Creating PostgreSQL snapshot',
+      data: { database, snapshotId, traceId }
+    })
+    await execa('pg_dump', [
+      '-h', Application.postgres.host,
+      '-p', String(Application.postgres.port),
+      '-U', Application.postgres.user,
+      '-F', 'c', // custom format
+      '-f', dumpPath,
+      database
+    ], {
+      env: { PGPASSWORD: Application.postgres.password }
+    })
+    const size = await getFileSize(dumpPath)
+    Logger.log({
+      level: 'info',
+      message: 'PostgreSQL snapshot created',
+      data: { database, size, traceId }
+    })
+    return { path: dumpPath, size, database }
+  } catch (error) {
+    Logger.log({
+      level: 'error',
+      message: 'Failed to create PostgreSQL snapshot',
+      data: { database, error: error.message, traceId }
+    })
+    throw new Error(`PostgreSQL snapshot failed: ${error.message}`)
+  }
+}
+
+async function restorePostgresSnapshot (database, snapshotId, traceId) {
+  const dumpPath = path.join(SNAPSHOTS_DIR, 'postgres', `${snapshotId}.dump`)
+  try {
+    Logger.log({
+      level: 'info',
+      message: 'Restoring PostgreSQL snapshot',
+      data: { database, snapshotId, traceId }
+    })
+    await execa('pg_restore', [
+      '--clean',
+      '--if-exists',
+      '-h', Application.postgres.host,
+      '-p', String(Application.postgres.port),
+      '-U', Application.postgres.user,
+      '-d', database,
+      dumpPath
+    ], {
+      env: { PGPASSWORD: Application.postgres.password }
+    })
+    Logger.log({
+      level: 'info',
+      message: 'PostgreSQL snapshot restored',
+      data: { database, traceId }
+    })
+  } catch (error) {
+    Logger.log({
+      level: 'error',
+      message: 'Failed to restore PostgreSQL snapshot',
+      data: { database, error: error.message, traceId }
+    })
+    throw new Error(`PostgreSQL restore failed: ${error.message}`)
+  }
+}
+
+// Firestore snapshot functions
+async function createFirestoreSnapshot (snapshotId, traceId) {
+  const exportPath = path.join(SNAPSHOTS_DIR, 'firestore', `${snapshotId}.json`)
+  try {
+    Logger.log({
+      level: 'info',
+      message: 'Creating Firestore snapshot',
+      data: { snapshotId, traceId }
+    })
+    const collectionsResult = await FirestoreLogic.listCollections({ traceId })
+    const collections = collectionsResult.collections || []
+    const exportData = {}
+    let totalDocuments = 0
+    // Export collections in parallel for better performance
+    await Promise.all(collections.map(async (collection) => {
+      const docsResult = await FirestoreLogic.listDocuments({
+        collectionPath: collection,
+        page: { limit: 10000 },
+        traceId
+      })
+      const documents = docsResult.documents || []
+      exportData[collection] = documents
+      totalDocuments += documents.length
+    }))
+    await fs.writeFile(exportPath, JSON.stringify(exportData, null, 2))
+    const size = await getFileSize(exportPath)
+    Logger.log({
+      level: 'info',
+      message: 'Firestore snapshot created',
+      data: { collections: collections.length, documents: totalDocuments, size, traceId }
+    })
+    return { path: exportPath, collections: collections.length, documents: totalDocuments, size }
+  } catch (error) {
+    Logger.log({
+      level: 'error',
+      message: 'Failed to create Firestore snapshot',
+      data: { error: error.message, traceId }
+    })
+    throw new Error(`Firestore snapshot failed: ${error.message}`)
+  }
+}
+
+async function restoreFirestoreSnapshot (snapshotId, traceId) {
+  const exportPath = path.join(SNAPSHOTS_DIR, 'firestore', `${snapshotId}.json`)
+  try {
+    Logger.log({
+      level: 'info',
+      message: 'Restoring Firestore snapshot',
+      data: { snapshotId, traceId }
+    })
+    const data = await fs.readFile(exportPath, 'utf8')
+    const exportData = JSON.parse(data)
+    // Clear all collections first
+    for (const collection in exportData) {
+      await FirestoreLogic.clearCollection({ collectionPath: collection, traceId })
+    }
+    // Restore documents in parallel batches for better performance
+    let restoredCount = 0
+    const BATCH_SIZE = 20
+    for (const collection in exportData) {
+      const documents = exportData[collection]
+      // Process documents in batches of 20 in parallel
+      for (let i = 0; i < documents.length; i += BATCH_SIZE) {
+        const batch = documents.slice(i, i + BATCH_SIZE)
+        await Promise.all(batch.map(async (doc) => {
+          const docId = doc.name.split('/').pop()
+          const fields = doc.fields || {}
+          await FirestoreLogic.createDocument({
+            collectionPath: collection,
+            documentId: docId,
+            fields,
+            traceId
+          })
+        }))
+        restoredCount += batch.length
+      }
+    }
+    Logger.log({
+      level: 'info',
+      message: 'Firestore snapshot restored',
+      data: { collections: Object.keys(exportData).length, documents: restoredCount, traceId }
+    })
+  } catch (error) {
+    Logger.log({
+      level: 'error',
+      message: 'Failed to restore Firestore snapshot',
+      data: { error: error.message, traceId }
+    })
+    throw new Error(`Firestore restore failed: ${error.message}`)
+  }
+}
+
+// Redis is in-memory only, no need to snapshot
+
+// SQLite snapshot functions
+async function createSqliteSnapshot (snapshotId, traceId) {
+  const exportPath = path.join(SNAPSHOTS_DIR, 'sqlite', `${snapshotId}.json`)
+  try {
+    Logger.log({
+      level: 'info',
+      message: 'Creating SQLite snapshot',
+      data: { snapshotId, traceId }
+    })
+    const exportData = {}
+    let totalRecords = 0
+    let snapshotedTables = 0
+    // Snapshot config tables (skip if table doesn't exist)
+    for (const tableName of CONFIG_TABLES) {
+      try {
+        const result = SqliteStore.list(tableName)
+        exportData[tableName] = result.data || []
+        totalRecords += exportData[tableName].length
+        snapshotedTables++
+      } catch (error) {
+        // Table doesn't exist - skip it
+        Logger.log({
+          level: 'debug',
+          message: 'Skipping non-existent table',
+          data: { tableName, traceId }
+        })
+      }
+    }
+    // Also export Pub/Sub data using internal APIs
+    const pubsubData = await exportPubSubData(traceId)
+    exportData._pubsub_data = pubsubData
+    totalRecords += pubsubData.topics.length + pubsubData.subscriptions.length
+    await fs.writeFile(exportPath, JSON.stringify(exportData, null, 2))
+    const size = await getFileSize(exportPath)
+    Logger.log({
+      level: 'info',
+      message: 'SQLite snapshot created',
+      data: { tables: snapshotedTables, records: totalRecords, pubsubTopics: pubsubData.topics.length, pubsubSubs: pubsubData.subscriptions.length, size, traceId }
+    })
+    return { path: exportPath, tables: snapshotedTables, records: totalRecords, size }
+  } catch (error) {
+    Logger.log({
+      level: 'error',
+      message: 'Failed to create SQLite snapshot',
+      data: { error: error.message, traceId }
+    })
+    throw new Error(`SQLite snapshot failed: ${error.message}`)
+  }
+}
+
+async function restoreSqliteSnapshot (snapshotId, traceId) {
+  const exportPath = path.join(SNAPSHOTS_DIR, 'sqlite', `${snapshotId}.json`)
+  try {
+    Logger.log({
+      level: 'info',
+      message: 'Restoring SQLite snapshot',
+      data: { snapshotId, traceId }
+    })
+    const data = await fs.readFile(exportPath, 'utf8')
+    const exportData = JSON.parse(data)
+    // Clear config tables first (delete all records)
+    for (const tableName of CONFIG_TABLES) {
+      try {
+        // Get all records and delete by ID to ensure they're gone
+        const result = SqliteStore.list(tableName)
+        const records = result.data || []
+        for (const record of records) {
+          try {
+            SqliteStore.delete(tableName, record._id)
+          } catch (err) {
+            // Ignore delete errors
+          }
+        }
+      } catch (error) {
+        // Table doesn't exist - skip
+      }
+    }
+    // Restore config tables (skip _pubsub_data which is not a table)
+    let restoredCount = 0
+    for (const tableName in exportData) {
+      // Skip special fields that aren't SQLite tables
+      if (tableName.startsWith('_')) continue
+      const records = exportData[tableName] || []
+      if (!Array.isArray(records)) continue
+      for (const record of records) {
+        try {
+          // Remove _id field before creating (let SQLite generate new IDs)
+          const { _id, ...recordData } = record
+          SqliteStore.create(tableName, recordData)
+          restoredCount++
+        } catch (error) {
+          // Skip duplicates or other errors
+          if (!error.message.includes('UNIQUE constraint')) {
+            Logger.log({
+              level: 'warn',
+              message: 'Failed to restore record',
+              data: { tableName, error: error.message, traceId }
+            })
+          }
+        }
+      }
+    }
+    // Clear log/traffic tables (fresh start for tests, skip if don't exist)
+    for (const tableName of LOG_TABLES) {
+      try {
+        SqliteStore.deleteWhere(tableName, {})
+      } catch (error) {
+        // Table doesn't exist - skip
+      }
+    }
+    Logger.log({
+      level: 'info',
+      message: 'SQLite snapshot restored',
+      data: { records: restoredCount, traceId }
+    })
+    // Return Pub/Sub data for re-registration
+    return exportData._pubsub_data || { topics: [], subscriptions: [] }
+  } catch (error) {
+    Logger.log({
+      level: 'error',
+      message: 'Failed to restore SQLite snapshot',
+      data: { error: error.message, traceId }
+    })
+    throw new Error(`SQLite restore failed: ${error.message}`)
+  }
+}
+
+// Export Pub/Sub data directly from emulator (source of truth)
+async function exportPubSubData (traceId) {
+  const PUBSUB_API = `http://${Application.pubsub.emulatorHost}:${Application.pubsub.emulatorPort}`
+  const PROJECT_ID = Application.pubsub.projectId
+  const exportData = { topics: [], subscriptions: [] }
+  try {
+    // Get all topics from emulator
+    const topicsRes = await fetch(`${PUBSUB_API}/v1/projects/${PROJECT_ID}/topics`)
+    if (topicsRes.ok) {
+      const topicsData = await topicsRes.json()
+      exportData.topics = topicsData.topics || []
+    }
+    // Get all subscriptions from emulator
+    const subsRes = await fetch(`${PUBSUB_API}/v1/projects/${PROJECT_ID}/subscriptions`)
+    if (subsRes.ok) {
+      const subsData = await subsRes.json()
+      exportData.subscriptions = subsData.subscriptions || []
+    }
+    Logger.log({
+      level: 'info',
+      message: 'Pub/Sub data exported from emulator',
+      data: { topics: exportData.topics.length, subscriptions: exportData.subscriptions.length, traceId }
+    })
+    return exportData
+  } catch (error) {
+    Logger.log({
+      level: 'warn',
+      message: 'Failed to export Pub/Sub data from emulator',
+      data: { error: error.message, traceId }
+    })
+    return exportData
+  }
+}
+
+// Restore Pub/Sub topics and subscriptions directly to emulator
+async function restorePubSubData (pubsubData, traceId) {
+  const PUBSUB_API = `http://${Application.pubsub.emulatorHost}:${Application.pubsub.emulatorPort}`
+  try {
+    Logger.log({
+      level: 'info',
+      message: 'Restoring Pub/Sub data to emulator',
+      data: { topics: pubsubData.topics?.length || 0, subscriptions: pubsubData.subscriptions?.length || 0, traceId }
+    })
+    // Re-create topics via emulator HTTP API
+    for (const topic of (pubsubData.topics || [])) {
+      try {
+        await fetch(`${PUBSUB_API}/v1/${topic.name}`, {
+          method: 'PUT',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ name: topic.name, labels: topic.labels || {} })
+        })
+      } catch (error) {
+        // Ignore errors (topic may already exist)
+      }
+    }
+    // Re-create subscriptions via emulator HTTP API
+    for (const sub of (pubsubData.subscriptions || [])) {
+      try {
+        await fetch(`${PUBSUB_API}/v1/${sub.name}`, {
+          method: 'PUT',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            name: sub.name,
+            topic: sub.topic,
+            pushConfig: sub.pushConfig || {},
+            ackDeadlineSeconds: sub.ackDeadlineSeconds || 10
+          })
+        })
+      } catch (error) {
+        // Ignore errors (subscription may already exist)
+      }
+    }
+    Logger.log({
+      level: 'info',
+      message: 'Pub/Sub data restored to emulator',
+      data: { traceId }
+    })
+  } catch (error) {
+    Logger.log({
+      level: 'error',
+      message: 'Failed to restore Pub/Sub data to emulator',
+      data: { error: error.message, traceId }
+    })
+    throw new Error(`Pub/Sub restore failed: ${error.message}`)
+  }
+}
+
+// Get microservice containers (excluding infrastructure)
+async function getMicroserviceContainers (traceId) {
+  const result = await DockerLogic.listContainers({ traceId })
+  const containers = result.data || []
+  // Filter for microservices only (not infrastructure)
+  return containers.filter(c => c.category === 'microservice' && c.status === 'running')
+}
+
+// Stop microservices
+async function stopMicroservices (traceId) {
+  const containers = await getMicroserviceContainers(traceId)
+  Logger.log({
+    level: 'info',
+    message: 'Stopping microservices',
+    data: { count: containers.length, traceId }
+  })
+  for (const container of containers) {
+    await DockerLogic.stopContainer({ containerName: container.name, traceId })
+  }
+  return containers.map(c => c.name)
+}
+
+// Start microservices
+async function startMicroservices (containerNames, traceId) {
+  Logger.log({
+    level: 'info',
+    message: 'Starting microservices',
+    data: { count: containerNames.length, traceId }
+  })
+  for (const containerName of containerNames) {
+    await DockerLogic.startContainer({ containerName, traceId })
+  }
+}
+
+export const Logic = {
+  async createSnapshot (params) {
+    const { services = [], traceId } = params
+    const snapshotId = generateSnapshotId()
+    const timestamp = new Date().toISOString()
+    const snapshotData = {
+      id: snapshotId,
+      timestamp,
+      services: {}
+    }
+    try {
+      await ensureSnapshotDirs()
+      // Determine which services to snapshot
+      const snapshotPostgres = services.length === 0 || services.includes('postgres')
+      const snapshotFirestore = services.length === 0 || services.includes('firestore')
+      const snapshotSqlite = services.length === 0 || services.includes('sqlite')
+      // Create snapshots (only if service is configured and reachable)
+      if (snapshotPostgres && Application.postgres.database) {
+        try {
+          snapshotData.services.postgres = await createPostgresSnapshot(
+            Application.postgres.database,
+            snapshotId,
+            traceId
+          )
+        } catch (error) {
+          // PostgreSQL not available - skip with warning
+          Logger.log({
+            level: 'warn',
+            message: 'PostgreSQL snapshot skipped (service not available)',
+            data: { error: error.message, traceId }
+          })
+        }
+      }
+      if (snapshotFirestore) {
+        snapshotData.services.firestore = await createFirestoreSnapshot(snapshotId, traceId)
+      }
+      if (snapshotSqlite) {
+        snapshotData.services.sqlite = await createSqliteSnapshot(snapshotId, traceId)
+      }
+      // Save metadata
+      const metadata = await readMetadata()
+      metadata.snapshots.push(snapshotData)
+      await writeMetadata(metadata)
+      Logger.log({
+        level: 'info',
+        message: 'Snapshot created successfully',
+        data: { snapshotId, traceId }
+      })
+      return {
+        snapshotId,
+        timestamp,
+        services: snapshotData.services,
+        traceId
+      }
+    } catch (error) {
+      Logger.log({
+        level: 'error',
+        message: 'Failed to create snapshot',
+        data: { error: error.message, traceId }
+      })
+      return {
+        status: 'error',
+        message: `Snapshot creation failed: ${error.message}`,
+        traceId
+      }
+    }
+  },
+
+  async restoreSnapshot (params) {
+    const { snapshotId, restartServices = true, traceId } = params
+    const restoredServices = []
+    const errors = []
+    let stoppedContainers = []
+    try {
+      const metadata = await readMetadata()
+      const snapshot = metadata.snapshots.find(s => s.id === snapshotId)
+      if (!snapshot) {
+        return {
+          status: 'error',
+          message: `Snapshot not found: ${snapshotId}`,
+          traceId
+        }
+      }
+      // Stop microservices first to ensure they reload data
+      if (restartServices) {
+        stoppedContainers = await stopMicroservices(traceId)
+      }
+      // Restore PostgreSQL
+      if (snapshot.services.postgres) {
+        try {
+          await restorePostgresSnapshot(snapshot.services.postgres.database, snapshotId, traceId)
+          restoredServices.push('postgres')
+        } catch (error) {
+          errors.push({ service: 'postgres', error: error.message })
+        }
+      }
+      // Restore Firestore
+      if (snapshot.services.firestore) {
+        try {
+          await restoreFirestoreSnapshot(snapshotId, traceId)
+          restoredServices.push('firestore')
+        } catch (error) {
+          errors.push({ service: 'firestore', error: error.message })
+        }
+      }
+      // Restore SQLite
+      let pubsubDataToRestore = null
+      if (snapshot.services.sqlite) {
+        try {
+          pubsubDataToRestore = await restoreSqliteSnapshot(snapshotId, traceId)
+          restoredServices.push('sqlite')
+        } catch (error) {
+          errors.push({ service: 'sqlite', error: error.message })
+        }
+      }
+      // Re-register Pub/Sub topics/subscriptions before restarting services
+      if (pubsubDataToRestore && (pubsubDataToRestore.topics?.length > 0 || pubsubDataToRestore.subscriptions?.length > 0)) {
+        try {
+          await restorePubSubData(pubsubDataToRestore, traceId)
+        } catch (error) {
+          errors.push({ service: 'pubsub-registration', error: error.message })
+        }
+      }
+      // Restart microservices (now that Pub/Sub topics are ready)
+      if (restartServices && stoppedContainers.length > 0) {
+        await startMicroservices(stoppedContainers, traceId)
+      }
+      Logger.log({
+        level: 'info',
+        message: 'Snapshot restored successfully',
+        data: { snapshotId, restoredServices, traceId }
+      })
+      return {
+        restored: true,
+        services: restoredServices,
+        errors: errors.length > 0 ? errors : undefined,
+        traceId
+      }
+    } catch (error) {
+      // Try to restart services even if restore failed
+      if (restartServices && stoppedContainers.length > 0) {
+        try {
+          await startMicroservices(stoppedContainers, traceId)
+        } catch (restartError) {
+          Logger.log({
+            level: 'error',
+            message: 'Failed to restart services after failed restore',
+            data: { error: restartError.message, traceId }
+          })
+        }
+      }
+      Logger.log({
+        level: 'error',
+        message: 'Failed to restore snapshot',
+        data: { error: error.message, traceId }
+      })
+      return {
+        status: 'error',
+        message: `Snapshot restore failed: ${error.message}`,
+        errors,
+        traceId
+      }
+    }
+  },
+
+  async listSnapshots (params) {
+    const { traceId } = params
+    try {
+      const metadata = await readMetadata()
+      return {
+        snapshots: metadata.snapshots.map(s => ({
+          id: s.id,
+          timestamp: s.timestamp,
+          services: Object.keys(s.services),
+          size: Object.values(s.services).reduce((sum, svc) => sum + (svc.size || 0), 0)
+        })),
+        total: metadata.snapshots.length,
+        traceId
+      }
+    } catch (error) {
+      Logger.log({
+        level: 'error',
+        message: 'Failed to list snapshots',
+        data: { error: error.message, traceId }
+      })
+      return {
+        snapshots: [],
+        total: 0,
+        traceId
+      }
+    }
+  },
+
+  async getSnapshotDetails (params) {
+    const { snapshotId, traceId } = params
+    try {
+      const metadata = await readMetadata()
+      const snapshot = metadata.snapshots.find(s => s.id === snapshotId)
+      if (!snapshot) {
+        return {
+          status: 'error',
+          message: `Snapshot not found: ${snapshotId}`,
+          traceId
+        }
+      }
+      return {
+        snapshot,
+        traceId
+      }
+    } catch (error) {
+      Logger.log({
+        level: 'error',
+        message: 'Failed to get snapshot details',
+        data: { error: error.message, traceId }
+      })
+      return {
+        status: 'error',
+        message: `Failed to get snapshot details: ${error.message}`,
+        traceId
+      }
+    }
+  },
+
+  async deleteSnapshot (params) {
+    const { snapshotId, traceId } = params
+    try {
+      const metadata = await readMetadata()
+      const snapshot = metadata.snapshots.find(s => s.id === snapshotId)
+      if (!snapshot) {
+        // If no specific snapshot ID, delete all
+        if (!snapshotId) {
+          // Delete all snapshot files
+          await fs.rm(path.join(SNAPSHOTS_DIR, 'postgres'), { recursive: true, force: true })
+          await fs.rm(path.join(SNAPSHOTS_DIR, 'firestore'), { recursive: true, force: true })
+          await fs.rm(path.join(SNAPSHOTS_DIR, 'sqlite'), { recursive: true, force: true })
+          await ensureSnapshotDirs()
+          await writeMetadata({ snapshots: [] })
+          Logger.log({
+            level: 'info',
+            message: 'All snapshots deleted',
+            data: { traceId }
+          })
+          return {
+            deleted: true,
+            message: 'All snapshots deleted',
+            traceId
+          }
+        }
+        return {
+          status: 'error',
+          message: `Snapshot not found: ${snapshotId}`,
+          traceId
+        }
+      }
+      // Delete snapshot files
+      if (snapshot.services.postgres) {
+        await fs.unlink(snapshot.services.postgres.path).catch(() => {})
+      }
+      if (snapshot.services.firestore) {
+        await fs.unlink(snapshot.services.firestore.path).catch(() => {})
+      }
+      if (snapshot.services.sqlite) {
+        await fs.unlink(snapshot.services.sqlite.path).catch(() => {})
+      }
+      // Remove from metadata
+      metadata.snapshots = metadata.snapshots.filter(s => s.id !== snapshotId)
+      await writeMetadata(metadata)
+      Logger.log({
+        level: 'info',
+        message: 'Snapshot deleted',
+        data: { snapshotId, traceId }
+      })
+      return {
+        deleted: true,
+        snapshotId,
+        traceId
+      }
+    } catch (error) {
+      Logger.log({
+        level: 'error',
+        message: 'Failed to delete snapshot',
+        data: { error: error.message, traceId }
+      })
+      return {
+        status: 'error',
+        message: `Failed to delete snapshot: ${error.message}`,
+        traceId
+      }
+    }
+  }
+}