@xyo-network/os-runtime 3.0.0

package/src/event/bus/Connection.ts

@@ -0,0 +1,31 @@
+import { assertEx } from '@xylabs/assert'
+import type { BaseParams } from '@xylabs/object'
+import { BaseEmitter } from '@xyo-network/module-abstract'
+import type { EventData } from '@xyo-network/module-events'
+import type { EventBusConnectionInterface, EventBusConnectionRequest, EventBusConnectionType } from '@xyo-network/os-model'
+
+/**
+ * A Generic Connection to add to an EventBus
+ * @param  {EventBusConnectionRequest} request
+ */
+export class EventBusConnection<TEventData extends EventData = EventData>
+  extends BaseEmitter<BaseParams, TEventData>
+  implements EventBusConnectionInterface<TEventData> {
+  _id?: string
+  description?: string
+  type: EventBusConnectionType
+
+  constructor(request: EventBusConnectionRequest) {
+    super({})
+    this.description = request.description
+    this.type = request.type
+  }
+
+  get id() {
+    return assertEx(this._id, () => 'Connection ID not set.  Did you forget to call buildConnection()?')
+  }
+
+  buildConnection(id: string) {
+    this._id = id
+  }
+}

package/src/event/bus/EventBus.ts

@@ -0,0 +1,145 @@
+import { assertEx } from '@xylabs/assert'
+import { forget } from '@xylabs/forget'
+import type { ArchivistModuleEventData } from '@xyo-network/archivist'
+import { asArchivistInstance, MemoryArchivist, MemoryArchivistConfigSchema } from '@xyo-network/archivist'
+import type {
+  EventBusConnectionInterface,
+  EventBusEvent,
+  EventBusInterface,
+  EventBusPubSubConnectionInterface,
+  PublisherEventListener } from '@xyo-network/os-model'
+import {
+  isEventBusEvent,
+  isPubSubConnections,
+} from '@xyo-network/os-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import { v4 as uuid } from 'uuid'
+
+/**
+ * Event Bus implementation inspired by the DBus protocol used in Linux desktop systems for inter-process communication.
+ *
+ * General flow:
+ * 1. Connection Added
+ * 2. Publisher and Subscriber Callbacks added
+ * 3. Events occurs and stored internally
+ * 4. Subscriber Callbacks called based off stored events
+ */
+export class EventBus implements EventBusInterface {
+  // Internal Archivist to store event data
+  private _archivist: MemoryArchivist | undefined
+
+  // Store all connections
+  private connections: Record<string, EventBusConnectionInterface> = {}
+
+  // Store all publisher callbacks for later removal
+  private publisherCallbacks: Record<string, PublisherEventListener> = {}
+
+  get archivist() {
+    return asArchivistInstance(
+      assertEx(this._archivist, () => 'Archivist not found.  Did you forget to call start()?'),
+      'not a valid archivist instance',
+    )
+  }
+
+  addConnection(connection: EventBusConnectionInterface) {
+    // unique connection id
+    const id = uuid()
+
+    // store in local cache
+    this.connections[id] = connection
+
+    // update the connection id with the generated id
+    connection.buildConnection(id)
+
+    // let existing connections know about newly published events
+    if (isPubSubConnections(connection)) {
+      this.handlePublisherAdd(connection)
+    } else {
+      throw new Error('Unsupported connection type. Must be PubSub')
+    }
+    return connection
+  }
+
+  removeConnection(connectionId: string) {
+    // find the existing connection
+    const connection = this.connections[connectionId]
+    if (!connection) {
+      throw new Error('Connection not found ' + connectionId)
+    }
+
+    if (connection && isPubSubConnections(connection)) {
+      this.handlePublisherRemove(connection)
+    }
+
+    delete this.connections[connectionId]
+  }
+
+  async start(storeName = 'EventBusArchivist') {
+    // Later versions could include a node that has a payload diviner to query past events
+    this._archivist = await MemoryArchivist.create({ config: { name: storeName, schema: MemoryArchivistConfigSchema } })
+
+    // start listening to inserted events from publishers
+    // NOTE: This is a very basic implementation and could be optimized by indexing on connection, eventName, and callback
+    // for faster lookups by event name
+    this.archivist.on('inserted', ({ payloads }: ArchivistModuleEventData['inserted']) => {
+      // confirm an eventBusPayload was inserted
+      const eventBusEvent = payloads.find(isEventBusEvent)
+      // if not an eventBusPayload, return
+      if (!eventBusEvent) return
+      // Loop through all connections
+      for (const connectionId in this.connections) {
+        const connection = this.connections[connectionId]
+        // Target PubSub connections
+        if (isPubSubConnections(connection) && connection.subscribableEvents) {
+          // Loop through all subscribable events
+          for (const [eventName, callback] of connection.subscribableEvents.entries()) {
+            // check if the event name matches the payload name
+            if (eventName !== eventBusEvent.name) continue
+            // pass the event payloads to the callback
+            if (callback) {
+              const forgettable = async () => await callback({ payloads })
+              forget(forgettable())
+            }
+          }
+        }
+      }
+    })
+  }
+
+  private handlePublisherAdd(connection: EventBusPubSubConnectionInterface) {
+    // Loop through all publishable events
+    for (const eventName of connection.publishableEvents ?? []) {
+      // Create publisher callback
+      const connectionPublisherCallback: PublisherEventListener = async ({ payloads }) => {
+        // build the event payload
+        const event: EventBusEvent = { name: eventName, schema: 'network.xyo.event.bus.event' }
+        const eventPayloads = payloads ?? []
+        event.sources = await PayloadBuilder.dataHashes(eventPayloads)
+        // Sync events to archivist
+        try {
+          await this.archivist.insert([event, ...(payloads ?? [])])
+        } catch (e) {
+          console.error('Error inserting event into archivist', e)
+        }
+      }
+      // Subscribe the publisher callback to the connection
+      connection.on(eventName, connectionPublisherCallback)
+
+      // store the publisher callback for later removal
+      const callbackId = connection.id + eventName
+      this.publisherCallbacks[callbackId] = connectionPublisherCallback
+    }
+  }
+
+  private handlePublisherRemove(connection: EventBusPubSubConnectionInterface) {
+    // Loop through all publishable events
+    for (const [, event] of connection.publishableEvents?.entries() ?? []) {
+      // find the publisher callback
+      const id = connection.id + event
+      const callback = this.publisherCallbacks[id]
+
+      // unsubscribe the publisher callback from the connection
+      if (callback) connection.off(event, callback)
+    }
+  }
+}

package/src/event/bus/PubSubConnection.ts

@@ -0,0 +1,28 @@
+import type {
+  EventBusPubSubConnectionInterface,
+  EventBusPubSubConnectionRequest,
+  PublisherEventListenerEventData,
+  SubscribableEventListeners,
+} from '@xyo-network/os-model'
+
+import { EventBusConnection } from './Connection.ts'
+
+/**
+ * A PubSub Connection to add to an EventBus
+ * @param  {EventBusPubSubConnectionRequest} request
+ */
+export class EventBusPubSubConnection<TPublisherEventData extends PublisherEventListenerEventData = PublisherEventListenerEventData>
+  extends EventBusConnection<TPublisherEventData>
+  implements EventBusPubSubConnectionInterface {
+  publishableEvents?: string[]
+  subscribableEvents?: SubscribableEventListeners
+
+  constructor(request: EventBusPubSubConnectionRequest) {
+    super(request)
+    if (request.type !== 'PubSub') {
+      throw new Error('Invalid connection type. Must be PubSub')
+    }
+    this.publishableEvents = request.publishableEvents
+    this.subscribableEvents = request.subscribableEvents
+  }
+}

package/src/event/bus/index.ts

@@ -0,0 +1,3 @@
+export * from './Connection.ts'
+export * from './EventBus.ts'
+export * from './PubSubConnection.ts'

package/src/event/connections/DappAccessRequest.ts

@@ -0,0 +1,11 @@
+import type { EventBusPubSubConnectionRequest } from '@xyo-network/os-model'
+
+import { EventBusPubSubConnection } from '../bus/index.ts'
+
+export const DappAccessRequestEvent = 'dappAccessRequest'
+
+const dappAccessRequestConnectionRequest: EventBusPubSubConnectionRequest = {
+  publishableEvents: [DappAccessRequestEvent],
+  type: 'PubSub',
+}
+export const dappAccessRequestConnection = () => new EventBusPubSubConnection(dappAccessRequestConnectionRequest)

package/src/event/connections/DappsReady.ts

@@ -0,0 +1,9 @@
+import type { EventBusPubSubConnectionRequest } from '@xyo-network/os-model'
+
+import { EventBusPubSubConnection } from '../bus/index.ts'
+
+const dappsReadyConnectionRequest: EventBusPubSubConnectionRequest = {
+  publishableEvents: ['dappsReady'],
+  type: 'PubSub',
+}
+export const dappsReadyConnection = () => new EventBusPubSubConnection(dappsReadyConnectionRequest)

package/src/event/connections/ExposeDappRequest.ts

@@ -0,0 +1,11 @@
+import type { EventBusPubSubConnectionRequest } from '@xyo-network/os-model'
+
+import { EventBusPubSubConnection } from '../bus/index.ts'
+
+export const ExposeDappRequestEvent = 'exposeDappRequest'
+
+const exposeDappConnectionRequest: EventBusPubSubConnectionRequest = {
+  publishableEvents: [ExposeDappRequestEvent],
+  type: 'PubSub',
+}
+export const exposeDappRequestConnection = () => new EventBusPubSubConnection(exposeDappConnectionRequest)

package/src/event/connections/OsPubSubNetworkReady.ts

@@ -0,0 +1,12 @@
+import type { EventBusPubSubConnectionRequest } from '@xyo-network/os-model'
+
+import { EventBusPubSubConnection } from '../bus/index.ts'
+
+export const OsPubSubNetworkReadyEvent = 'osPubSubNetworkReady'
+
+const osPubSubNetworkConnectionRequest: EventBusPubSubConnectionRequest = {
+  publishableEvents: [OsPubSubNetworkReadyEvent],
+  type: 'PubSub',
+}
+
+export const osPubSubNetworkReadyConnection = () => new EventBusPubSubConnection(osPubSubNetworkConnectionRequest)

package/src/event/connections/OsSettingsReady.ts

@@ -0,0 +1,12 @@
+import type { EventBusPubSubConnectionRequest } from '@xyo-network/os-model'
+
+import { EventBusPubSubConnection } from '../bus/index.ts'
+
+export const OsSettingsReadyEvent = 'osSettingsReady'
+
+const osSettingsConnectionRequest: EventBusPubSubConnectionRequest = {
+  publishableEvents: [OsSettingsReadyEvent],
+  type: 'PubSub',
+}
+
+export const osSettingsReadyConnection = () => new EventBusPubSubConnection(osSettingsConnectionRequest)

package/src/event/connections/OsXyoPublicReady.ts

@@ -0,0 +1,12 @@
+import type { EventBusPubSubConnectionRequest } from '@xyo-network/os-model'
+
+import { EventBusPubSubConnection } from '../bus/index.ts'
+
+export const OsXyoPublicNetworkReadyEvent = 'osXyoPublicNetworkReady'
+
+const osXyoPublicNetworkConnectionRequest: EventBusPubSubConnectionRequest = {
+  publishableEvents: [OsXyoPublicNetworkReadyEvent],
+  type: 'PubSub',
+}
+
+export const osXyoPublicNetworkReadyConnection = () => new EventBusPubSubConnection(osXyoPublicNetworkConnectionRequest)

package/src/event/connections/index.ts

@@ -0,0 +1,6 @@
+export * from './DappAccessRequest.ts'
+export * from './DappsReady.ts'
+export * from './ExposeDappRequest.ts'
+export * from './OsPubSubNetworkReady.ts'
+export * from './OsSettingsReady.ts'
+export * from './OsXyoPublicReady.ts'

package/src/event/index.ts

@@ -0,0 +1,2 @@
+export * from './bus/index.ts'
+export * from './connections/index.ts'

package/src/helpers/index.ts

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

package/src/helpers/monitor/XyOsMonitor.ts

@@ -0,0 +1,52 @@
+import type { XyOsGlobal } from '@xyo-network/os-model'
+
+import type { MonitorEventConfig } from './types.ts'
+
+// See - https://developer.mozilla.org/en-US/docs/Web/API/NetworkInformation
+export type Connection = { downlink: number; effectiveType: string; rtt: number }
+
+const DEFAULT_MONITORING_EVENT_NAME = 'System Task Duration'
+
+globalThis.getXyOsGlobal
+  = globalThis.getXyOsGlobal
+  ?? ((): XyOsGlobal => {
+    return {
+      tracking: {
+        trackEvent: (_event: string, _properties?: Record<string, unknown>) => void {},
+      },
+    }
+  })
+
+// TODO: Make this node compatible
+const xyOsGlobal = globalThis.getXyOsGlobal()
+
+export abstract class XyOsMonitor {
+  static trackEvent = xyOsGlobal.tracking.trackEvent
+
+  private performanceTimers = new Map<string, number>()
+
+  startTimer(name: string): void {
+    this.performanceTimers.set(name, performance.now())
+  }
+
+  stopTimer(eventConfig: MonitorEventConfig): void {
+    const { additionalProperties, name } = eventConfig
+    const start = this.performanceTimers.get(name)
+    if (start) {
+      const end = performance.now()
+      const duration = end - start
+      this.performanceTimers.delete(name)
+      const connection = this.connection()
+      XyOsMonitor.trackEvent(DEFAULT_MONITORING_EVENT_NAME, {
+        downloadSpeedMbps: connection?.downlink,
+        duration: duration.toString(),
+        effectiveConnectionSpeed: connection?.effectiveType,
+        name,
+        roundTripTime: connection?.rtt,
+        ...additionalProperties,
+      })
+    }
+  }
+
+  protected abstract connection(): Connection | undefined
+}

package/src/helpers/monitor/index.ts

@@ -0,0 +1,2 @@
+export * from './types.ts'
+export * from './XyOsMonitor.ts'

package/src/helpers/monitor/types.ts

@@ -0,0 +1,5 @@
+import type { JsonObject } from '@xylabs/object'
+
+export type MonitorEventNames = 'Load XyOs' | 'Install System dApps' | 'Expose dApps' | 'Loading dApp'
+
+export type MonitorEventConfig = { additionalProperties?: JsonObject; name: MonitorEventNames }

package/src/index.ts

@@ -0,0 +1,22 @@
+export * from './access-interfaces/index.ts'
+export * from './adapter/index.ts'
+export * from './adapters/index.ts'
+export * from './Caller.ts'
+export * from './classes/index.ts'
+export * from './DappCallerBase.ts'
+export * from './DefaultsQueries.ts'
+export * from './event/index.ts'
+export * from './helpers/index.ts'
+export * from './intent/index.ts'
+export * from './lib/index.ts'
+export * from './loadOsNode.ts'
+export * from './manifest/index.ts'
+export * from './OsCallerBase.ts'
+export * from './profileModuleEvents.ts'
+export * from './PubSubBridgeCaller.ts'
+export * from './stack/index.ts'
+export * from './utils/index.ts'
+export * from './wallet/index.ts'
+export * from './XyOs.ts'
+export * from './XyOsBase.ts'
+export * from './XyOsDapp.ts'

package/src/intent/Caller.ts

@@ -0,0 +1,72 @@
+import { PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
+import type { DappId, DappIntent, DappIntentTypes, XyOsContext } from '@xyo-network/os-model'
+import { DappIntentSchema, DappMode } from '@xyo-network/os-model'
+import type { WithMeta } from '@xyo-network/payload-model'
+
+import { DappCallerBase } from '../DappCallerBase.ts'
+
+export class DappIntentCaller extends DappCallerBase {
+  static OsDappName = 'XyOs'
+  constructor(context: XyOsContext) {
+    super(context)
+  }
+
+  /**
+   * Build a new intent
+   * @param  {DappId} sourceDappId
+   * @param  {DappIntentTypes} intent
+   * @param  {DappId} targetDappId
+   * @param  {DappMode} targetMode
+   * @param  {DappIntent['params']} params?
+   * @returns DappIntent
+   */
+  static buildIntent(
+    sourceDappId: DappId,
+    intent: DappIntentTypes,
+    targetDappId?: DappId,
+    targetMode: DappMode = DappMode.Window,
+    params?: DappIntent['params'],
+  ): DappIntent {
+    return {
+      intent,
+      params: params || '',
+      schema: DappIntentSchema,
+      sourceDappId,
+      targetDappId,
+      targetMode: targetMode || DappMode.Window,
+      timestamp: Date.now(),
+    }
+  }
+
+  // Add a new intent
+  async addIntent(id: DappId, intent: DappIntentTypes, mode: DappMode) {
+    const intentArchivist = await this.getDappIntentArchivist()
+    const newIntent = DappIntentCaller.buildIntent(id, intent, mode)
+    await intentArchivist.insert([newIntent])
+  }
+
+  // Get all intents
+  async allIntents() {
+    const archivist = await this.getDappIntentArchivist()
+    return await archivist.all()
+  }
+
+  // Get the latest intent saved to the archivist
+  async latestIntent() {
+    const archivist = await this.getDappIntentArchivist()
+    return (await archivist.all()).at(-1) as WithMeta<DappIntent>
+  }
+
+  // Get the latest intent for a dapp
+  async latestIntentForDappName(dappName: DappId) {
+    const diviner = await this.getDappIntentArchivistPayloadDiviner()
+    const query = {
+      limit: 1,
+      order: 'desc',
+      schema: PayloadDivinerQuerySchema,
+      sourceDappId: dappName,
+    }
+
+    return (await diviner.divine([query])) as WithMeta<DappIntent>[]
+  }
+}

package/src/intent/Resource.ts

@@ -0,0 +1,66 @@
+import { assertEx } from '@xylabs/assert'
+import type { DappIntent, XyOsContext } from '@xyo-network/os-model'
+import { isDappIntent } from '@xyo-network/os-model'
+import type { WithMeta } from '@xyo-network/payload-model'
+
+import { DappCallerBase } from '../DappCallerBase.ts'
+import type { Listener, ResourceStore } from '../lib/index.ts'
+import { PayloadStore } from '../lib/index.ts'
+
+export type DappIntentViews = 'latestDappIntent' | 'allDappIntents'
+const NO_RESULTS: [] = []
+
+export class DappIntentResource extends DappCallerBase implements ResourceStore<DappIntentViews> {
+  private _allDappIntents: PayloadStore<DappIntent> | undefined
+  private _latestDappIntent: PayloadStore<DappIntent> | undefined
+
+  constructor(context: XyOsContext) {
+    super(context)
+  }
+
+  get allDappIntents() {
+    return assertEx(this._allDappIntents, () => 'allDappIntents not set')
+  }
+
+  get latestDappIntent() {
+    return assertEx(this._latestDappIntent, () => 'latestDappIntent not set')
+  }
+
+  get subscriptions() {
+    return {
+      allDappIntents: (cb: Listener) => this.allDappIntents.subscribe(cb),
+      latestDappIntent: (cb: Listener) => this.latestDappIntent.subscribe(cb),
+    }
+  }
+
+  get views() {
+    return {
+      allDappIntents: () => this.allDappIntents.getSnapshot(),
+      latestDappIntent: () => this.latestDappIntent.getSnapshot(),
+    }
+  }
+
+  cleanupListeners() {
+    this.latestDappIntent.cleanupListeners()
+    this.allDappIntents.cleanupListeners()
+  }
+
+  async start() {
+    const archivist = await this.getDappIntentArchivist()
+
+    this._allDappIntents = await PayloadStore.create<DappIntent>({
+      archivist,
+      getLatest: async () => (await archivist.all()) as WithMeta<DappIntent>[],
+      idFunction: isDappIntent,
+    })
+    this._latestDappIntent = await PayloadStore.create<DappIntent>({
+      archivist,
+      getLatest: async () => {
+        const all = await archivist.all()
+        const result = all.length > 0 ? [all.at(-1)] : NO_RESULTS
+        return result as WithMeta<DappIntent>[]
+      },
+      idFunction: isDappIntent,
+    })
+  }
+}

package/src/intent/index.ts

@@ -0,0 +1,2 @@
+export * from './Caller.ts'
+export * from './Resource.ts'

package/src/lib/ExternalStore.ts

@@ -0,0 +1,7 @@
+import type { Payload } from '@xyo-network/payload-model'
+
+export interface ExternalStore<T extends Payload = Payload> {
+  getSnapshot: () => T[]
+  latest: T[]
+  subscribe: (onStoreChange: () => void) => () => void
+}

package/src/lib/Listener.ts

@@ -0,0 +1 @@
+export type Listener = (...args: Array<unknown>) => void

package/src/lib/ModuleAccountPaths.ts

@@ -0,0 +1,29 @@
+import { DevelopArchivist, NodeSentinel } from './ModuleNames.ts'
+
+export const RemoteNodeArchivistOffsetPaths: Record<string, Record<string, string>> = {
+  Kerplunk: {
+    [DevelopArchivist]: '118',
+  },
+  Local: {
+    [DevelopArchivist]: '115',
+  },
+  Main: {
+    [DevelopArchivist]: '121',
+  },
+}
+
+export const ModuleOffsetPaths: Record<string, string> = {
+  IdWitness: '1',
+  DomainWitness: '2',
+  LocationWitness: '3',
+  SchemaWitness: '4',
+  CryptoCardsGameWitness: '5',
+  CryptoCardsMoveWitness: '6',
+  EthereumGasEtherchainV2Witness: '7',
+  CoingeckoCryptoMarketWitness: '8',
+  UniswapCryptoMarketWitness: '9',
+  EthereumGasEtherscanWitness: '10',
+  [NodeSentinel]: '11',
+  [DevelopArchivist]: '12',
+  BowserSystemInfoPluginWitness: '13',
+}

package/src/lib/ModuleNames.ts

@@ -0,0 +1,3 @@
+export const DevelopArchivist = 'DevelopArchivist'
+
+export const NodeSentinel = 'NodeSentinel'

package/src/lib/NameTransforms.ts

@@ -0,0 +1,31 @@
+export class NameTransforms {
+  constructor(private value: string) {}
+
+  static deSlug(value: string) {
+    return value
+      .replaceAll('-', ' ')
+      .split(' ')
+      .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+      .join(' ')
+  }
+
+  static moduleName(value: string) {
+    return value.replaceAll(' ', '')
+  }
+
+  static slug(value: string) {
+    return value.replaceAll(' ', '-').toLocaleLowerCase()
+  }
+
+  deSlug() {
+    return NameTransforms.deSlug(this.value)
+  }
+
+  moduleName() {
+    return NameTransforms.moduleName(this.value)
+  }
+
+  slug() {
+    return NameTransforms.slug(this.value)
+  }
+}