@jokio/sdk 0.0.1

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@jokio/sdk",
+  "version": "0.0.1",
+  "main": "dist/jokio.sdk.umd.js",
+  "module": "dist/jokio.sdk.es.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "start": "npm run build && vite",
+    "build": "vite build && tsc"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "typescript": "5.8.3",
+    "vite": "6.3.5"
+  },
+  "dependencies": {
+    "@simplewebauthn/browser": "13.1.0",
+    "nats.ws": "1.30.3"
+  }
+}

package/src/auth.service.ts

@@ -0,0 +1,109 @@
+import {
+  startAuthentication,
+  startRegistration,
+} from '@simplewebauthn/browser'
+
+type Config = {
+  authUrl: string
+}
+
+export class AuthService {
+  constructor(private config: Config) { }
+
+  async requestEmailLogin(email: string, returnUrl: string) {
+    const res = await fetch(
+      this.config.authUrl +
+      `/email-verification-request/${email}?returnUrl=${returnUrl}`,
+      { credentials: 'include' },
+    ).then(processResponse)
+
+    return res as boolean
+  }
+
+  async completeEmailLogin(email: string, otpCode: string) {
+    const res = await fetch(
+      this.config.authUrl +
+      `/email-verification-complete/${email}/${otpCode}`,
+      { credentials: 'include' },
+    ).then(processResponse)
+
+    return res as IdentityUser
+  }
+
+  async requestPasskeyLogin(
+    displayName: string = '',
+    isRegistration: boolean = false,
+    addAsAdditionalDevice = false,
+  ) {
+    // 1. get challenge options
+    const opts = await fetch(
+      this.config.authUrl +
+      `/webauth-challenge-request?registration=${isRegistration ? 'true' : ''
+      }&displayName=${displayName}`,
+      { credentials: 'include' },
+    ).then(processResponse)
+
+    // 2. ask user to register
+    let attResp
+    try {
+      if (!opts.user?.id) {
+        attResp = await startAuthentication({ optionsJSON: opts })
+      } else {
+        attResp = await startRegistration({ optionsJSON: opts })
+      }
+    } catch (error: any) {
+      if (error.name === 'InvalidStateError') {
+        alert(
+          'Error: Authenticator was probably already registered by user',
+        )
+      } else {
+        alert(error.message)
+      }
+
+      throw error
+    }
+
+    // 3. verify response
+    const res = await fetch(
+      this.config.authUrl +
+      `/webauth-challenge-complete?displayName=${displayName}&addAsAdditionalDevice=${addAsAdditionalDevice ? 'true' : ''
+      }`,
+      {
+        method: 'POST',
+        body: JSON.stringify(attResp),
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        credentials: 'include',
+      },
+    ).then(processResponse)
+
+    return res as IdentityUser
+  }
+
+  async signOut() {
+    // 1. get challenge options
+    const res = await fetch(this.config.authUrl + `/sign-out`, {
+      credentials: 'include',
+    }).then(processResponse)
+
+    return res as IdentityUser
+  }
+}
+
+export type IdentityUser = {
+  name: string
+  email: string
+  userId: string
+  sessionId: string
+  verified: boolean
+}
+const processResponse = async (x: Response) => {
+  const data = await x.json()
+
+  if (!x.ok) {
+    throw new Error(data.message)
+  }
+
+  return data
+}

package/src/common/playAudioFromBuffer.ts

@@ -0,0 +1,15 @@
+export function playAudioFromBuffer(buffer: ArrayBuffer) {
+  const blob = new Blob([buffer], { type: 'audio/mpeg' }) // or 'audio/wav' depending on your format
+  const url = URL.createObjectURL(blob)
+
+  const audio = new Audio()
+  audio.src = url
+  //   audio.play()
+
+  // Optional: cleanup after playback
+  audio.onended = () => {
+    URL.revokeObjectURL(url)
+  }
+
+  return audio
+}

package/src/crypto.service.ts

@@ -0,0 +1,100 @@
+const uint2hex = (x: Uint8Array) =>
+  [...x].map(x => x.toString(16).padStart(2, '0')).join('')
+
+const hex2uint = (hex: string) =>
+  new Uint8Array(
+    hex.match(/.{1,2}/g)!.map(byte => parseInt(byte, 16)),
+  )
+
+const ab2b64 = (ab: any) =>
+  btoa(String.fromCharCode(...new Uint8Array(ab)))
+
+const b642ab = (str: string) =>
+  Uint8Array.from(atob(str), c => c.charCodeAt(0)).buffer
+
+const sha256 = async (buffer: ArrayBuffer) =>
+  await crypto.subtle.digest('SHA-256', buffer)
+
+const textEncoder = new TextEncoder()
+
+export class CryptoService {
+  async createSessionKeyPair() {
+    return await crypto.subtle.generateKey(
+      {
+        name: 'ECDH',
+        namedCurve: 'P-256',
+      },
+      false, // non-extractable private key
+      ['deriveKey', 'deriveBits'],
+    )
+  }
+
+  async exportPublicKey(publicKey: CryptoKey): Promise<string> {
+    const spki = await crypto.subtle.exportKey('spki', publicKey)
+
+    return ab2b64(spki)
+  }
+
+  async deriveAESKey(privateKey: CryptoKey, publicKeyString: string) {
+    const spki = b642ab(publicKeyString)
+
+    const publicKey = await crypto.subtle.importKey(
+      'spki',
+      spki,
+      { name: 'ECDH', namedCurve: 'P-256' },
+      false,
+      [],
+    )
+
+    // Derive key directly
+    const aesKey = await crypto.subtle.deriveKey(
+      {
+        name: 'ECDH',
+        public: publicKey,
+      },
+      privateKey,
+      { name: 'AES-GCM', length: 256 },
+      false,
+      ['encrypt', 'decrypt'],
+    )
+
+    return aesKey
+  }
+
+  async exportRawKey(key: CryptoKey) {
+    const raw = await crypto.subtle.exportKey('raw', key)
+    return uint2hex(new Uint8Array(raw))
+  }
+
+  async encrypt(text: string, key: CryptoKey) {
+    const iv = crypto.getRandomValues(new Uint8Array(12))
+    const encoded = new TextEncoder().encode(text)
+    const ciphertext = await crypto.subtle.encrypt(
+      { name: 'AES-GCM', iv },
+      key,
+      encoded,
+    )
+
+    return `${uint2hex(new Uint8Array(ciphertext))}_${uint2hex(iv)}`
+  }
+
+  async decrypt(encryptedText: string, key: CryptoKey) {
+    const parts = encryptedText.split('_')
+
+    const ciphertext = hex2uint(parts[0]).buffer
+    const iv = hex2uint(parts[1])
+
+    const decrypted = await crypto.subtle.decrypt(
+      { name: 'AES-GCM', iv },
+      key,
+      ciphertext,
+    )
+    return new TextDecoder().decode(decrypted)
+  }
+
+  async hashString(text: string) {
+    const hashBuffer = await sha256(textEncoder.encode(text).buffer)
+
+    return ab2b64(hashBuffer)
+  }
+}

package/src/edgeTts.service.ts

@@ -0,0 +1,153 @@
+import { playAudioFromBuffer } from './common/playAudioFromBuffer'
+
+export class EdgeTtsService {
+  async getAudioBuffer(
+    text: string,
+    voice: string,
+    options?: { pitch?: string; rate?: string; volume?: string },
+  ): Promise<ArrayBuffer> {
+    const audioChunks: Uint8Array[] = []
+    const reqId = crypto.randomUUID() // Supported in most modern browsers
+
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(
+        `${Constants.WSS_URL}?trustedclienttoken=${Constants.TRUSTED_CLIENT_TOKEN}&ConnectionId=${reqId}`,
+      )
+
+      ws.binaryType = 'arraybuffer'
+
+      const SSML_text = getSSML(text, voice, options)
+
+      ws.addEventListener('open', () => {
+        const configMessage = buildTTSConfigMessage()
+        ws.send(configMessage)
+
+        const speechMessage =
+          `X-RequestId:${reqId}\r\n` +
+          `Content-Type:application/ssml+xml\r\n` +
+          `X-Timestamp:${new Date().toISOString()}Z\r\n` +
+          `Path:ssml\r\n\r\n` +
+          SSML_text
+
+        ws.send(speechMessage)
+      })
+
+      ws.addEventListener('message', event => {
+        const data = event.data
+
+        if (data instanceof ArrayBuffer) {
+          const buffer = new Uint8Array(data)
+          const needle = new TextEncoder().encode('Path:audio\r\n')
+
+          const index = findSubarray(buffer, needle)
+          if (index !== -1) {
+            const audioData = buffer.subarray(index + needle.length)
+            audioChunks.push(audioData)
+          }
+
+          const textData = new TextDecoder().decode(buffer)
+          if (textData.includes('Path:turn.end')) {
+            ws.close()
+          }
+        } else {
+          if (data.includes('Path:turn.end')) {
+            ws.close()
+          }
+        }
+      })
+
+      ws.addEventListener('close', () => {
+        if (!audioChunks.length) {
+          reject('No audio data available to save.')
+          return
+        }
+
+        // Combine all Uint8Arrays into one ArrayBuffer
+        const totalLength = audioChunks.reduce(
+          (acc, chunk) => acc + chunk.length,
+          0,
+        )
+        const finalBuffer = new Uint8Array(totalLength)
+        let offset = 0
+        for (const chunk of audioChunks) {
+          finalBuffer.set(chunk, offset)
+          offset += chunk.length
+        }
+
+        resolve(finalBuffer.buffer) // ArrayBuffer
+      })
+
+      ws.addEventListener('error', err => {
+        reject(err)
+      })
+    })
+  }
+
+  async getAudio(
+    text: string,
+    voice: string,
+    options?: { pitch?: string; rate?: string; volume?: string },
+  ) {
+    return this.getAudioBuffer(text, voice, options).then(x =>
+      playAudioFromBuffer(x),
+    )
+  }
+
+  async getVoices(): Promise<any[]> {
+    const response = await fetch(
+      `${Constants.VOICES_URL}?trustedclienttoken=${Constants.TRUSTED_CLIENT_TOKEN}`,
+    )
+    const data = await response.json()
+    return data.map((voice: any) => ({
+      id: voice.ShortName,
+      locale: voice.Locale,
+      description: voice.FriendlyName,
+    }))
+  }
+}
+
+const Constants = {
+  TRUSTED_CLIENT_TOKEN: '6A5AA1D4EAFF4E9FB37E23D68491D6F4',
+  WSS_URL:
+    'wss://speech.platform.bing.com/consumer/speech/synthesize/readaloud/edge/v1',
+  VOICES_URL:
+    'https://speech.platform.bing.com/consumer/speech/synthesize/readaloud/voices/list',
+}
+
+const buildTTSConfigMessage = (): string => {
+  return (
+    `X-Timestamp:${new Date().toISOString()}Z\r\nContent-Type:application/json; charset=utf-8\r\nPath:speech.config\r\n\r\n` +
+    `{"context":{"synthesis":{"audio":{"metadataoptions":{"sentenceBoundaryEnabled":false,"wordBoundaryEnabled":true},"outputFormat":"audio-24khz-48kbitrate-mono-mp3"}}}}`
+  )
+}
+
+const getSSML = (
+  text: string,
+  voice: string,
+  options: any = {},
+): string => {
+  options.pitch = options.pitch?.replace('hz', 'Hz')
+  const pitch = options.pitch || '0Hz' // this.validatePitch(options.pitch || '0Hz');
+  const rate = options.rate || '0%' // this.validateRate(options.rate || '0%');
+  const volume = options.volume || '0%' // this.validateVolume(options.volume || '0%');
+
+  return `<speak version='1.0' xml:lang='en-US'><voice name='${voice}'><prosody pitch='${pitch}' rate='${rate}' volume='${volume}'>${text}</prosody></voice></speak>`
+}
+
+// Helper: Finds a subarray inside another Uint8Array
+function findSubarray(
+  haystack: Uint8Array,
+  needle: Uint8Array,
+): number {
+  for (let i = 0; i <= haystack.length - needle.length; i++) {
+    let match = true
+    for (let j = 0; j < needle.length; j++) {
+      if (haystack[i + j] !== needle[j]) {
+        match = false
+        break
+      }
+    }
+    if (match) return i
+  }
+  return -1
+}

package/src/index.ts

@@ -0,0 +1,37 @@
+import { AuthService } from './auth.service'
+import { CryptoService } from './crypto.service'
+import { EdgeTtsService } from './edgeTts.service'
+import { NatsService } from './nats.service'
+import { VoicevoxTtsService } from './tts.service'
+
+export { NatsService } from './nats.service'
+
+type Config = {
+  debug: boolean
+  authUrl: string
+  voicevoxUrl: string
+}
+
+const defaultConfig: Config = {
+  debug: false,
+  authUrl: 'https://auth.jok.io',
+  voicevoxUrl: 'https://voicevox.fly.dev',
+}
+
+export const jok = {
+  setup(config: Partial<Config>) {
+    if (config.authUrl) {
+      this.auth = new AuthService({ authUrl: config.authUrl })
+    }
+  },
+
+  auth: new AuthService(defaultConfig),
+
+  edgeTts: new EdgeTtsService(),
+
+  voicevoxTts: new VoicevoxTtsService(defaultConfig),
+
+  nats: new NatsService(),
+
+  crypto: new CryptoService(),
+}