agent-messenger 2.20.2 → 2.20.4

package/src/platforms/webex/kms-key-provider.ts

@@ -0,0 +1,99 @@
+import { DeviceManager, KmsClient, MercurySocket, noopLogger } from 'webex-message-handler'
+import WebSocket from 'ws'
+
+interface KmsKeyProviderOptions {
+  token: string
+  logger?: { debug(message: string): void }
+}
+
+interface Registration {
+  webSocketUrl: string
+  deviceUrl: string
+  userId: string
+  encryptionServiceUrl: string
+}
+
+type HttpRequest = {
+  url: string
+  method: string
+  headers: Record<string, string>
+  body?: string
+}
+
+export class KmsKeyProvider {
+  private token: string
+  private logger?: { debug(message: string): void }
+  private mercury: MercurySocket | null = null
+  private kms: KmsClient | null = null
+  private readyPromise: Promise<void> | null = null
+
+  constructor(options: KmsKeyProviderOptions) {
+    this.token = options.token
+    this.logger = options.logger
+  }
+
+  async fetchKey(keyUri: string): Promise<string | null> {
+    try {
+      await this.ensureReady()
+      const key = await this.kms?.getKey(keyUri)
+      if (!key) return null
+      return JSON.stringify({ uri: keyUri, jwk: key.toJSON(true) })
+    } catch (error) {
+      this.logger?.debug(`Webex KMS key fetch failed: ${error instanceof Error ? error.message : String(error)}`)
+      await this.close()
+      this.readyPromise = null
+      return null
+    }
+  }
+
+  async close(): Promise<void> {
+    await this.mercury?.disconnect().catch(() => undefined)
+    this.mercury = null
+    this.kms = null
+    this.readyPromise = null
+  }
+
+  private async ensureReady(): Promise<void> {
+    this.readyPromise ??= this.initialize()
+    await this.readyPromise
+  }
+
+  private async initialize(): Promise<void> {
+    const httpDo = async (req: HttpRequest) => {
+      const res = await fetch(req.url, {
+        method: req.method,
+        headers: req.headers,
+        body: req.body,
+      })
+      return {
+        status: res.status,
+        ok: res.ok,
+        json: () => res.json(),
+        text: () => res.text(),
+      }
+    }
+    const wsFactory = (url: string) => new WebSocket(url) as never
+    const dm = new DeviceManager({ logger: noopLogger, httpDo })
+    const reg = (await dm.register(this.token)) as Registration
+    const mercury = new MercurySocket({ logger: noopLogger, wsFactory })
+    const kms = new KmsClient({
+      token: this.token,
+      deviceUrl: reg.deviceUrl,
+      userId: reg.userId,
+      encryptionServiceUrl: reg.encryptionServiceUrl,
+      logger: noopLogger,
+      httpDo,
+    })
+    mercury.on('kms:response', (data: unknown) => kms.handleKmsMessage(data))
+    await mercury.connect(reg.webSocketUrl, this.token)
+    this.mercury = mercury
+    try {
+      await kms.initialize()
+    } catch (error) {
+      await mercury.disconnect().catch(() => undefined)
+      this.mercury = null
+      throw error
+    }
+    this.kms = kms
+  }
+}

package/src/platforms/webex/typings/webex-message-handler.d.ts

@@ -0,0 +1,45 @@
+export {}
+
+declare module 'webex-message-handler' {
+  import type * as jose from 'node-jose'
+
+  type Logger = Record<string, (...args: unknown[]) => void>
+  type HttpRequest = { url: string; method: string; headers: Record<string, string>; body?: string }
+  type HttpResponse = { status: number; ok: boolean; json(): Promise<unknown>; text(): Promise<string> }
+  type HttpDo = (req: HttpRequest) => Promise<HttpResponse>
+
+  export const noopLogger: Logger
+  export const consoleLogger: Logger
+
+  export class DeviceManager {
+    constructor(options: { logger: Logger; httpDo: HttpDo })
+    register(token: string): Promise<{
+      webSocketUrl: string
+      deviceUrl: string
+      userId: string
+      services: unknown
+      encryptionServiceUrl: string
+    }>
+  }
+
+  export class MercurySocket {
+    constructor(options: { logger: Logger; wsFactory: (url: string) => unknown })
+    on(event: 'kms:response', handler: (data: unknown) => void): void
+    connect(webSocketUrl: string, token: string): Promise<void>
+    disconnect(): Promise<void>
+  }
+
+  export class KmsClient {
+    constructor(options: {
+      token: string
+      deviceUrl: string
+      userId: string
+      encryptionServiceUrl: string
+      logger: Logger
+      httpDo: HttpDo
+    })
+    initialize(): Promise<void>
+    getKey(keyUri: string): Promise<jose.JWK.Key | null>
+    handleKmsMessage(data: unknown): void
+  }
+}