@xyo-network/xl1-cli 1.6.2

package/src/orchestration/actor/model/Actor.ts

@@ -0,0 +1,113 @@
+import type { TracerProvider } from '@opentelemetry/api'
+import type { BaseParams } from '@xylabs/base'
+import { BaseEmitter } from '@xylabs/events'
+import { forget } from '@xylabs/forget'
+import { IdLogger } from '@xylabs/logger'
+import type { Promisable } from '@xylabs/promise'
+import { span, spanAsync } from '@xylabs/telemetry'
+
+export interface IActor {
+  start(): Promise<void>
+  stop(): Promise<void>
+}
+
+export type ActorParams = BaseParams<{
+  traceProvider?: TracerProvider
+}>
+
+export class Actor<TParams extends ActorParams = ActorParams> extends BaseEmitter<TParams> implements IActor {
+  protected readonly _timers: Map<string, ReturnType<typeof setTimeout>> = new Map()
+  private _active = false
+  private readonly _displayName: string
+  private readonly _id: string
+
+  constructor(id: string, displayName: string = 'Actor', params: TParams) {
+    const logger = params.logger ?? new IdLogger(console, () => `[${displayName} (${id})] `)
+    super({ ...params, logger })
+    this._displayName = displayName
+    this._id = id
+  }
+
+  get displayName() {
+    return this._displayName
+  }
+
+  get id() {
+    return this._id
+  }
+
+  get name() {
+    return this.constructor.name
+  }
+
+  protected get logPrefix() {
+    return `[${this.displayName} (${this.id})] `
+  }
+
+  /**
+   * The timer runs until the actor is deactivated (or you manually stop it).
+   */
+  registerTimer(timerName: string, callback: () => Promisable<void>, dueTimeMs: number, periodMs: number) {
+    if (!this._active) {
+      this.logger?.warn(
+        `Cannot register timer '${timerName}' because actor is not active.`,
+      )
+      return
+    }
+
+    // Function to handle recursive scheduling
+    const schedulePeriodicRun = async () => {
+      // Stop if actor is deactivated or timer is removed
+      if (!this._active || !this._timers.has(timerName)) return
+      try {
+        // Run the callback
+        await callback()
+      } catch (error) {
+        // Catch and log any errors
+        this.logger?.error(`Error in timer '${this.name}:${timerName}': ${error}`)
+      } finally {
+        // Always schedule subsequent executions based on the desired period
+        this._timers.set(timerName, setTimeout(() => forget(schedulePeriodicRun(), { name: `schedulePeriodicRun:${this.name}:${timerName}` }), periodMs))
+      }
+    }
+
+    // Schedule the 1st execution after the desired initial delay
+    this._timers.set(timerName, setTimeout(() => forget(schedulePeriodicRun(), { name: `schedulePeriodicRun(initial):${this.name}:${timerName}` }), dueTimeMs))
+
+    this.logger?.log(
+      `Timer '${this.name}:${timerName}' registered: first call after ${dueTimeMs}ms, recurring every ${periodMs}ms.`,
+    )
+  }
+
+  span<T>(name: string, fn: () => T): T {
+    return span(`${this.name}:${name}`, fn, this.tracer)
+  }
+
+  async spanAsync<T>(name: string, fn: () => Promise<T>): Promise<T> {
+    return await spanAsync(`${this.name}:${name}`, fn, this.tracer)
+  }
+
+  /**
+   * Called by the Orchestrator when the actor is activated.
+   */
+  async start() {
+    await Promise.resolve()
+    this._active = true
+    this.logger?.log('Started.')
+  }
+
+  /**
+   * Called by the Orchestrator when the actor is deactivated.
+   * Stop all running timers.
+   */
+  async stop() {
+    await Promise.resolve()
+    this._active = false
+    this.logger?.log('Stopping all timers...')
+    for (const [, timerRef] of this._timers.entries()) {
+      clearTimeout(timerRef)
+    }
+    this._timers.clear()
+    this.logger?.log('Stopped.')
+  }
+}

package/src/orchestration/actor/model/Orchestrator.ts

@@ -0,0 +1,65 @@
+export interface IOrchestrator {
+  start(): Promise<void>
+  stop(): Promise<void>
+}
+
+import type { IActor } from './Actor.ts'
+
+// TODO: Inject logger
+export class Orchestrator implements IOrchestrator {
+  private actors: IActor[] = []
+  private keepAliveHandle: NodeJS.Timeout | null = null
+  private running = false
+
+  /**
+   * Registers an actor.
+   * (We won't activate the actor until `start()` is called.)
+   */
+  async registerActor(actor: IActor) {
+    if (this.running) {
+      // If the orchestrator is already running, activate the actor immediately
+      await actor.start()
+    }
+    this.actors.push(actor)
+  }
+
+  /**
+   * Starts the orchestrator: activates all actors.
+   */
+  async start() {
+    await Promise.resolve()
+    if (this.running) {
+      console.log('[Orchestrator] Already started.')
+      return
+    }
+
+    console.log('[Orchestrator] Starting...')
+    this.running = true
+    for (const actor of this.actors) {
+      await actor.start()
+    }
+    // This interval will fire every 24.8 days (2^31 - 1 ms), effectively never finishing
+    this.keepAliveHandle = setInterval(() => {
+      // No-op
+    }, 2_147_483_647)
+  }
+
+  /**
+   * Stops the orchestrator: deactivates all actors.
+   */
+  async stop() {
+    await Promise.resolve()
+    if (!this.running) {
+      console.log('[Orchestrator] Already stopped.')
+      return
+    }
+
+    console.log('[Orchestrator] Stopping...')
+    for (const actor of this.actors) {
+      await actor.stop()
+    }
+    this.running = false
+    if (this.keepAliveHandle) clearInterval(this.keepAliveHandle)
+    console.log('[Orchestrator] Stopped...')
+  }
+}

package/src/orchestration/actor/model/index.ts

@@ -0,0 +1,2 @@
+export * from './Actor.ts'
+export * from './Orchestrator.ts'

package/src/orchestration/archivists/ChainFinalized/archivist.ts

@@ -0,0 +1,27 @@
+import type { TracerProvider } from '@opentelemetry/api'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import { initArchivistSync } from '@xyo-network/chain-orchestration'
+import { startupSpanAsync } from '@xyo-network/chain-utils'
+import { Mutex } from 'async-mutex'
+
+import { initLocalChainFinalizedArchivist } from './local.ts'
+import { initRemoteChainFinalizedArchivist } from './remote.ts'
+
+const mutex = new Mutex()
+let singleton: ArchivistInstance | undefined
+
+export async function initChainFinalizedArchivist(traceProvider: TracerProvider) {
+  return await mutex.runExclusive(async () => {
+    if (singleton) return singleton
+    const [remote, local] = await Promise.all([
+      startupSpanAsync('ChainFinalizedArchivist:initRemote', () => initRemoteChainFinalizedArchivist()),
+      startupSpanAsync('ChainFinalizedArchivist:initLocal', () => initLocalChainFinalizedArchivist()),
+    ])
+    await startupSpanAsync(
+      'ChainFinalizedArchivist:initArchivistSync',
+      () => initArchivistSync('ChainFinalizedArchivist', remote, local, 200, Number.MAX_SAFE_INTEGER, traceProvider),
+    )
+    singleton = local
+    return singleton
+  })
+}

package/src/orchestration/archivists/ChainFinalized/index.ts

@@ -0,0 +1 @@
+export * from './archivist.ts'

package/src/orchestration/archivists/ChainFinalized/local.ts

@@ -0,0 +1,16 @@
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import type { Initializable } from '@xyo-network/xl1-protocol'
+import { Mutex } from 'async-mutex'
+
+import { getLocalPersistentArchivist } from '../lib/index.ts'
+
+const mutex = new Mutex()
+let singleton: ArchivistInstance | undefined
+
+export const initLocalChainFinalizedArchivist: Initializable<void, ArchivistInstance> = async (): Promise<ArchivistInstance> => {
+  return await mutex.runExclusive(async () => {
+    if (singleton) return singleton
+    singleton = await getLocalPersistentArchivist('chain', 'finalized')
+    return singleton
+  })
+}

package/src/orchestration/archivists/ChainFinalized/remote.ts

@@ -0,0 +1,18 @@
+import { assertEx } from '@xylabs/assert'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import { initBridge, initBridgedArchivistModule } from '@xyo-network/chain-orchestration'
+import type { Initializable } from '@xyo-network/xl1-protocol'
+import { Mutex } from 'async-mutex'
+
+const nodeUrl = process.env.XYO_CHAIN_ARCHIVIST_NODE_URL ?? 'http://localhost:8080'
+const mutex = new Mutex()
+let singleton: ArchivistInstance | undefined
+
+export const initRemoteChainFinalizedArchivist: Initializable<void, ArchivistInstance> = async (): Promise<ArchivistInstance> => {
+  return await mutex.runExclusive(async () => {
+    if (singleton) return singleton
+    const bridge = await initBridge(nodeUrl)
+    singleton = await initBridgedArchivistModule({ bridge, moduleName: 'XYOChain:Chain:Finalized' })
+    return assertEx(singleton, () => 'Error: RemoteChainFinalizedArchivist failed to initialize')
+  })
+}

package/src/orchestration/archivists/ChainSubmissions/archivist.ts

@@ -0,0 +1,19 @@
+import { assertEx } from '@xylabs/assert'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import { startupSpanAsync } from '@xyo-network/chain-utils'
+import type { Initializable } from '@xyo-network/xl1-protocol'
+import { Mutex } from 'async-mutex'
+
+import { initRemoteChainSubmissionsArchivist } from './remote.ts'
+
+const mutex = new Mutex()
+let singleton: ArchivistInstance | undefined
+
+export const initChainSubmissionsArchivist: Initializable<void, ArchivistInstance> = async (): Promise<ArchivistInstance> => {
+  return await mutex.runExclusive(async () => {
+    if (singleton) return singleton
+    const remote = await startupSpanAsync('ChainSubmissionsArchivist:initRemote', () => initRemoteChainSubmissionsArchivist())
+    singleton = remote
+    return assertEx(singleton, () => new Error('Failed to initialize ChainSubmissionsArchivist'))
+  })
+}

package/src/orchestration/archivists/ChainSubmissions/index.ts

@@ -0,0 +1 @@
+export * from './archivist.ts'

package/src/orchestration/archivists/ChainSubmissions/remote.ts

@@ -0,0 +1,18 @@
+import { assertEx } from '@xylabs/assert'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import { initBridge, initBridgedArchivistModule } from '@xyo-network/chain-orchestration'
+import type { Initializable } from '@xyo-network/xl1-protocol'
+import { Mutex } from 'async-mutex'
+
+const nodeUrl = process.env.XYO_CHAIN_ARCHIVIST_NODE_URL ?? 'http://localhost:8080'
+const mutex = new Mutex()
+let singleton: ArchivistInstance | undefined
+
+export const initRemoteChainSubmissionsArchivist: Initializable<void, ArchivistInstance> = async (): Promise<ArchivistInstance> => {
+  return await mutex.runExclusive(async () => {
+    if (singleton) return singleton
+    const bridge = await initBridge(nodeUrl)
+    singleton = await initBridgedArchivistModule({ bridge, moduleName: 'XYOChain:Chain:Submissions' })
+    return assertEx(singleton, () => new Error('Failed to initialize RemoteChainSubmissionsArchivist'))
+  })
+}

package/src/orchestration/archivists/PendingTransactions/archivist.ts

@@ -0,0 +1,29 @@
+import type { TracerProvider } from '@opentelemetry/api'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import { initArchivistSync } from '@xyo-network/chain-orchestration'
+import { startupSpanAsync } from '@xyo-network/chain-utils'
+import { Mutex } from 'async-mutex'
+
+import { initLocalPendingTransactionsArchivist } from './local.ts'
+import { initRemotePendingTransactionsArchivist } from './remote.ts'
+
+const mutex = new Mutex()
+let singleton: [local: ArchivistInstance, remote: ArchivistInstance] | undefined
+
+export async function initPendingBundledTransactionsArchivist(_: TracerProvider): Promise<[local: ArchivistInstance, remote: ArchivistInstance]> {
+  return await mutex.runExclusive(async () => {
+    if (singleton) return singleton
+    const remote = await startupSpanAsync('PendingBundledTransactionsArchivist:initRemote', () => initRemotePendingTransactionsArchivist())
+    const local = await startupSpanAsync('PendingBundledTransactionsArchivist:initLocal', () => initLocalPendingTransactionsArchivist())
+    // Grab the most recent payload from the remote archivist
+    const start = await remote.next({ limit: 1, order: 'desc' })
+    // Write it locally so we have a starting point for syncing
+    await local.insert(start)
+    await startupSpanAsync(
+      'PendingBundledTransactionsArchivist:initArchivistSync',
+      () => initArchivistSync('PendingBundledTransactionsArchivist', remote, local),
+    )
+    singleton = [local, remote]
+    return singleton
+  })
+}

package/src/orchestration/archivists/PendingTransactions/index.ts

@@ -0,0 +1 @@
+export * from './archivist.ts'

package/src/orchestration/archivists/PendingTransactions/local.ts

@@ -0,0 +1,20 @@
+import { MemoryArchivist, MemoryArchivistConfigSchema } from '@xyo-network/archivist-memory'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import type { Initializable } from '@xyo-network/xl1-protocol'
+import { Mutex } from 'async-mutex'
+
+const mutex = new Mutex()
+let singleton: ArchivistInstance | undefined
+
+export const initLocalPendingTransactionsArchivist: Initializable<void, ArchivistInstance> = async (): Promise<ArchivistInstance> => {
+  return await mutex.runExclusive(async () => {
+    if (singleton) return singleton
+    singleton = await MemoryArchivist.create({
+      account: 'random',
+      config: {
+        schema: MemoryArchivistConfigSchema, max: 1000, name: 'localPendingTransactions',
+      },
+    })
+    return singleton
+  })
+}

package/src/orchestration/archivists/PendingTransactions/remote.ts

@@ -0,0 +1,18 @@
+import { assertEx } from '@xylabs/assert'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import { initBridge, initBridgedArchivistModule } from '@xyo-network/chain-orchestration'
+import type { Initializable } from '@xyo-network/xl1-protocol'
+import { Mutex } from 'async-mutex'
+
+const bridgeUrl = process.env.XYO_PENDING_ARCHIVIST_NODE_URL ?? 'http://localhost:8080'
+const mutex = new Mutex()
+let singleton: ArchivistInstance | undefined
+
+export const initRemotePendingTransactionsArchivist: Initializable<void, ArchivistInstance> = async (): Promise<ArchivistInstance> => {
+  return await mutex.runExclusive(async () => {
+    if (singleton) return singleton
+    const bridge = await initBridge(bridgeUrl)
+    singleton = await initBridgedArchivistModule({ bridge, moduleName: 'XYOChain:Pending:PendingTransactions' })
+    return assertEx(singleton, () => 'Error: RemotePendingBundledTransactionsArchivist is undefined')
+  })
+}

package/src/orchestration/archivists/RejectedTransactions/archivist.ts

@@ -0,0 +1,18 @@
+import type { TracerProvider } from '@opentelemetry/api'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import { startupSpanAsync } from '@xyo-network/chain-utils'
+import { Mutex } from 'async-mutex'
+
+import { initLocalRejectedTransactionsArchivist } from './local.ts'
+
+const mutex = new Mutex()
+let singleton: ArchivistInstance | undefined
+
+export async function initRejectedTransactionsArchivist(_traceProvider: TracerProvider) {
+  return await mutex.runExclusive(async () => {
+    if (singleton) return singleton
+    const local = await startupSpanAsync('RejectedTransactionsArchivist:initLocal', () => initLocalRejectedTransactionsArchivist())
+    singleton = local
+    return singleton
+  })
+}

package/src/orchestration/archivists/RejectedTransactions/index.ts

@@ -0,0 +1 @@
+export * from './archivist.ts'

package/src/orchestration/archivists/RejectedTransactions/local.ts

@@ -0,0 +1,20 @@
+import { MemoryArchivist, MemoryArchivistConfigSchema } from '@xyo-network/archivist-memory'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import type { Initializable } from '@xyo-network/xl1-protocol'
+import { Mutex } from 'async-mutex'
+
+const mutex = new Mutex()
+let singleton: ArchivistInstance | undefined
+
+export const initLocalRejectedTransactionsArchivist: Initializable<void, ArchivistInstance> = async (): Promise<ArchivistInstance> => {
+  return await mutex.runExclusive(async () => {
+    if (singleton) return singleton
+    singleton = await MemoryArchivist.create({
+      account: 'random',
+      config: {
+        schema: MemoryArchivistConfigSchema, max: 1000, name: 'localRejectedTransactions',
+      },
+    })
+    return singleton
+  })
+}

package/src/orchestration/archivists/StakeIntentState/archivist.ts

@@ -0,0 +1,19 @@
+import { assertEx } from '@xylabs/assert'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import { startupSpanAsync } from '@xyo-network/chain-utils'
+import type { Initializable } from '@xyo-network/xl1-protocol'
+import { Mutex } from 'async-mutex'
+
+import { initLocalStakeIntentStateArchivist } from './local.ts'
+
+const mutex = new Mutex()
+let singleton: ArchivistInstance | undefined
+
+export const initStakeIntentStateArchivist: Initializable<void, ArchivistInstance> = async (): Promise<ArchivistInstance> => {
+  return await mutex.runExclusive(async () => {
+    if (singleton) return singleton
+    const local = await startupSpanAsync('StakeIntentStateArchivist:initLocal', () => initLocalStakeIntentStateArchivist())
+    singleton = local
+    return assertEx(singleton, () => 'Error: StakeIntentStateArchivist is undefined')
+  })
+}

package/src/orchestration/archivists/StakeIntentState/index.ts

@@ -0,0 +1 @@
+export * from './archivist.ts'

package/src/orchestration/archivists/StakeIntentState/local.ts

@@ -0,0 +1,19 @@
+import { assertEx } from '@xylabs/assert'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import type { Initializable } from '@xyo-network/xl1-protocol'
+import { Mutex } from 'async-mutex'
+
+import { getLocalPersistentArchivist } from '../lib/index.ts'
+
+const mutex = new Mutex()
+let singleton: ArchivistInstance | undefined
+
+export const initLocalStakeIntentStateArchivist: Initializable<void, ArchivistInstance> = async (): Promise<ArchivistInstance> => {
+  return await mutex.runExclusive(async () => {
+    if (singleton) return singleton
+    console.log('[InitServices:LocalStakeIntentStateArchivist:Initializing]')
+    singleton = await getLocalPersistentArchivist('stakeIntent', 'state')
+    console.log('[InitServices:LocalStakeIntentStateArchivist:Initialized]')
+    return assertEx(singleton, () => new Error('Failed to initialize stake intent state archivist'))
+  })
+}

package/src/orchestration/archivists/index.ts

@@ -0,0 +1,5 @@
+export * from './ChainFinalized/index.ts'
+export * from './ChainSubmissions/index.ts'
+export * from './PendingTransactions/index.ts'
+export * from './RejectedTransactions/index.ts'
+export * from './StakeIntentState/index.ts'

package/src/orchestration/archivists/lib/index.ts

@@ -0,0 +1 @@
+export * from './localPersistentArchivist.ts'

package/src/orchestration/archivists/lib/localPersistentArchivist.ts

@@ -0,0 +1,44 @@
+import { rm } from 'node:fs/promises'
+
+import { LmdbArchivist, LmdbArchivistConfigSchema } from '@xyo-network/archivist-lmdb'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+
+import type { StoreKind } from '../../store/index.ts'
+import { getStoreDirectory } from '../../store/index.ts'
+
+/**
+ * Returns a local persistent archivist
+ * @param dbName The name of the database
+ * @param storeName The name of the store
+ * @param kind The kind of the archivist
+ * @returns an archivist instance
+ */
+export const getLocalPersistentArchivist = (dbName: string, storeName: string, kind: StoreKind = 'lmdb'): Promise<ArchivistInstance> => {
+  switch (kind) {
+    case 'lmdb': {
+      return LmdbArchivist.create({
+        account: 'random',
+        config: {
+          clearStoreOnStart: false,
+          dbName,
+          location: getStoreDirectory(dbName, 'lmdb'),
+          schema: LmdbArchivistConfigSchema,
+          storeName,
+        },
+      })
+    }
+  }
+}
+
+export const deleteLocalPersistentArchivist = async (dbName: string, _storeName: string, kind: StoreKind = 'lmdb'): Promise<void> => {
+  await Promise.resolve()
+  console.warn(`Deleting local persistent archivist for ${dbName} of kind ${kind}.`)
+  let location = ''
+  switch (kind) {
+    case 'lmdb': {
+      location = getStoreDirectory(dbName, 'lmdb')
+      break
+    }
+  }
+  await rm(location, { recursive: true, force: true })
+}

package/src/orchestration/health/index.ts

@@ -0,0 +1 @@
+export * from './initHealthEndpoints.ts'

package/src/orchestration/health/initHealthEndpoints.ts

@@ -0,0 +1,70 @@
+import type {
+  IncomingMessage, Server, ServerResponse,
+} from 'node:http'
+import http from 'node:http'
+
+import type { CreatableStatus } from '@xylabs/creatable'
+import { isDefined, isEmptyString } from '@xylabs/typeof'
+import type { Initializable } from '@xyo-network/xl1-protocol'
+
+import type { RuntimeStatusMonitor } from '../status/index.ts'
+
+const sendStatus = (res: ServerResponse, status: CreatableStatus, errorCode: number) => {
+  const statusCode = status === 'started' ? 200 : errorCode
+  res.writeHead(statusCode, { 'Content-Type': 'application/json' })
+  res.end(JSON.stringify({ status }))
+}
+
+const notFound = (res: ServerResponse) => {
+  res.writeHead(404, { 'Content-Type': 'application/json' })
+  res.end(JSON.stringify({ status: 'not found' }))
+}
+
+/**
+ * Starts an HTTP server with Kubernetes health endpoints:
+ * - /healthz
+ * - /livez
+ * - /readyz
+ * @param port The port to listen on (default: 8080)
+ */
+const createHealthServer = (port: number = 8080, statusMonitor: RuntimeStatusMonitor) => {
+  const server = http.createServer((req: IncomingMessage, res: ServerResponse) => {
+    const url = req.url ?? ''
+
+    const status = statusMonitor.getGlobalStatus()
+
+    switch (url) {
+      case '/healthz': {
+        sendStatus(res, status, 500)
+        break
+      }
+      case '/livez': {
+        sendStatus(res, status, 503)
+        break
+      }
+      case '/readyz': {
+        sendStatus(res, status, 503)
+        break
+      }
+      default: {
+        notFound(res)
+      }
+    }
+  })
+
+  server.listen(port, () => {
+    console.log(`Health server running on http://localhost:${port}`)
+    console.log(' - /healthz')
+    console.log(' - /livez')
+    console.log(' - /readyz')
+  })
+  return server
+}
+
+export const initHealthEndpoints: Initializable<{ statusReporter: RuntimeStatusMonitor }, Server | undefined> = (params) => {
+  const healthCheckEnvVarPort = process.env.XYO_PRODUCER_HEALTH_CHECK_PORT
+  if (isDefined(healthCheckEnvVarPort) && !isEmptyString(healthCheckEnvVarPort)) {
+    const healthCheckPort = Number.parseInt(healthCheckEnvVarPort, 10)
+    return createHealthServer(healthCheckPort, params.statusReporter)
+  }
+}

package/src/orchestration/host/implementation/DefaultHost.ts

@@ -0,0 +1,25 @@
+import type { Host, ServiceProvider } from '../model/index.ts'
+
+/**
+ * A generic host implementation that can be used as a starting point for
+ * more complex host implementations.
+ */
+export class GenericHost implements Host {
+  services: ServiceProvider
+
+  constructor(services: ServiceProvider) {
+    this.services = services
+  }
+
+  async start(): Promise<void> {
+    await Promise.resolve()
+    // Initialize or start your services here
+    console.log('Host is starting...')
+  }
+
+  async stop(): Promise<void> {
+    await Promise.resolve()
+    // Stop or clean up services here
+    console.log('Host is stopping...')
+  }
+}