@jokio/sdk 0.0.1 → 0.0.3

package/dist/nats.service.d.ts

@@ -1,4 +1,8 @@
+type Config = {
+    natsUrl: string;
+};
 export declare class NatsService<TApi> {
+    private config;
     onStatusChange?: (isConnected: boolean) => void;
     private nc?;
     private sessionId;
@@ -6,7 +10,12 @@ export declare class NatsService<TApi> {
     private globalPrefix;
     private resolveConnected;
     isConnected: Promise<unknown>;
-    connect(natsServerUrls: string[], user: IdentityUser, prefix?: string): Promise<void>;
+    constructor(config: Config);
+    connect(opts: {
+        natsWsServerUrls?: string[];
+        user?: IdentityUser;
+        prefix?: string;
+    }): Promise<void>;
     disconnect(): Promise<void>;
     publish<TSubject extends keyof TApi & string>(subject: TSubject, data: InferReturnType<TApi, TSubject>): Promise<void>;
     call<TSubject extends keyof TApi & string>(subject: TSubject, data: InferProps<TApi, TSubject>, opts?: {
@@ -17,6 +26,9 @@ export declare class NatsService<TApi> {
         userId: string;
         sessionId: string;
     }) => void): Promise<() => void>;
+    /**
+     * Reqiores permission to publish response in `_INBOX.>`. If you need to just listen events, use `on`.
+     */
     handler<TSubject extends keyof TApi & string>(subject: TSubject, cb: (data: InferProps<TApi, TSubject>, ctx: {
         subject: string;
         userId: string;
@@ -24,10 +36,7 @@ export declare class NatsService<TApi> {
     }) => Promise<InferReturnType<TApi, TSubject>>): Promise<() => void>;
     private buildSubject;
 }
-export declare const nats: NatsService<unknown>;
 type IdentityUser = {
-    jwt: string;
-    seed: string;
     userId: string;
     sessionId: string;
 };

package/dist/tts.service.d.ts

@@ -1,11 +1,13 @@
-type Config = {
-    voicevoxUrl: string;
-};
-export declare class VoicevoxTtsService {
-    private config;
-    constructor(config: Config);
-    getAudioBuffer(text: string, voice: string): Promise<ArrayBuffer | null>;
-    getAudio(text: string, voice: string): Promise<HTMLAudioElement | null>;
+export declare class EdgeTtsService {
+    getAudioBuffer(text: string, voice: string, options?: {
+        pitch?: string;
+        rate?: string;
+        volume?: string;
+    }): Promise<ArrayBuffer>;
+    getAudio(text: string, voice: string, options?: {
+        pitch?: string;
+        rate?: string;
+        volume?: string;
+    }): Promise<HTMLAudioElement>;
     getVoices(): Promise<any[]>;
 }
-export {};

package/dist/voicevoxTts.d.ts

@@ -0,0 +1,11 @@
+type Config = {
+    voicevoxUrl: string;
+};
+export declare class VoicevoxTtsService {
+    private config;
+    constructor(config: Config);
+    getAudioBuffer(text: string, voice: string): Promise<ArrayBuffer | null>;
+    getAudio(text: string, voice: string): Promise<HTMLAudioElement | null>;
+    getVoices(): Promise<any[]>;
+}
+export {};

package/package.json

@@ -1,6 +1,8 @@
 {
   "name": "@jokio/sdk",
-  "version": "0.0.1",
+  "description": "pure js sdk for building decentralised localfirst web apps. Provides tts ai model integrations, realtime p2p communication & crypto encryptions.",
+  "version": "0.0.3",
+  "license": "MIT",
   "main": "dist/jokio.sdk.umd.js",
   "module": "dist/jokio.sdk.es.js",
   "types": "dist/index.d.ts",

package/src/auth.service.ts

@@ -7,13 +7,15 @@ type Config = {
   authUrl: string
 }
 
+const USER_STORAGE_KEY = 'LAST_AUTH_DATA'
+
 export class AuthService {
-  constructor(private config: Config) { }
+  constructor(private config: Config) {}
 
   async requestEmailLogin(email: string, returnUrl: string) {
     const res = await fetch(
       this.config.authUrl +
-      `/email-verification-request/${email}?returnUrl=${returnUrl}`,
+        `/email-verification-request/${email}?returnUrl=${returnUrl}`,
       { credentials: 'include' },
     ).then(processResponse)
 
@@ -23,10 +25,12 @@ export class AuthService {
   async completeEmailLogin(email: string, otpCode: string) {
     const res = await fetch(
       this.config.authUrl +
-      `/email-verification-complete/${email}/${otpCode}`,
+        `/email-verification-complete/${email}/${otpCode}`,
       { credentials: 'include' },
     ).then(processResponse)
 
+    localStorage.setItem(USER_STORAGE_KEY, JSON.stringify(res))
+
     return res as IdentityUser
   }
 
@@ -38,8 +42,9 @@ export class AuthService {
     // 1. get challenge options
     const opts = await fetch(
       this.config.authUrl +
-      `/webauth-challenge-request?registration=${isRegistration ? 'true' : ''
-      }&displayName=${displayName}`,
+        `/webauth-challenge-request?registration=${
+          isRegistration ? 'true' : ''
+        }&displayName=${displayName}`,
       { credentials: 'include' },
     ).then(processResponse)
 
@@ -66,8 +71,9 @@ export class AuthService {
     // 3. verify response
     const res = await fetch(
       this.config.authUrl +
-      `/webauth-challenge-complete?displayName=${displayName}&addAsAdditionalDevice=${addAsAdditionalDevice ? 'true' : ''
-      }`,
+        `/webauth-challenge-complete?displayName=${displayName}&addAsAdditionalDevice=${
+          addAsAdditionalDevice ? 'true' : ''
+        }`,
       {
         method: 'POST',
         body: JSON.stringify(attResp),
@@ -78,17 +84,39 @@ export class AuthService {
       },
     ).then(processResponse)
 
+    localStorage.setItem(USER_STORAGE_KEY, JSON.stringify(res))
+
     return res as IdentityUser
   }
 
-  async signOut() {
-    // 1. get challenge options
+  async guestSignIn() {
     const res = await fetch(this.config.authUrl + `/sign-out`, {
       credentials: 'include',
     }).then(processResponse)
 
+    localStorage.setItem(USER_STORAGE_KEY, JSON.stringify(res))
+
     return res as IdentityUser
   }
+
+  async clearLoginData() {
+    localStorage.removeItem(USER_STORAGE_KEY)
+  }
+
+  getLastLoginData() {
+    const s = localStorage.getItem(USER_STORAGE_KEY)
+    if (!s) {
+      return null
+    }
+
+    try {
+      const res = JSON.parse(s)
+
+      return res || null
+    } catch {
+      return null
+    }
+  }
 }
 
 export type IdentityUser = {

package/src/index.ts

@@ -1,21 +1,21 @@
 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'
+import { EdgeTtsService } from './tts.service'
 
 export { NatsService } from './nats.service'
+export { VoicevoxTtsService } from './voicevoxTts'
 
 type Config = {
   debug: boolean
   authUrl: string
-  voicevoxUrl: string
+  natsUrl: string
 }
 
 const defaultConfig: Config = {
   debug: false,
   authUrl: 'https://auth.jok.io',
-  voicevoxUrl: 'https://voicevox.fly.dev',
+  natsUrl: 'https://natsx.jok.io',
 }
 
 export const jok = {
@@ -23,15 +23,17 @@ export const jok = {
     if (config.authUrl) {
       this.auth = new AuthService({ authUrl: config.authUrl })
     }
+
+    if (config.natsUrl) {
+      this.nats = new NatsService({ natsUrl: config.natsUrl })
+    }
   },
 
   auth: new AuthService(defaultConfig),
 
-  edgeTts: new EdgeTtsService(),
-
-  voicevoxTts: new VoicevoxTtsService(defaultConfig),
+  tts: new EdgeTtsService(),
 
-  nats: new NatsService(),
+  nats: new NatsService(defaultConfig),
 
   crypto: new CryptoService(),
 }

package/src/nats.service.ts

@@ -5,6 +5,11 @@ import {
   JSONCodec,
   type NatsConnection,
 } from 'nats.ws'
+import { AuthService } from './auth.service'
+
+type Config = {
+  natsUrl: string
+}
 
 const jsonCodec = JSONCodec()
 
@@ -22,17 +27,34 @@ export class NatsService<TApi> {
     resolve => (this.resolveConnected = resolve),
   )
 
-  async connect(
-    natsServerUrls: string[],
-    user: IdentityUser,
-    prefix?: string,
-  ) {
+  constructor(private config: Config) {}
+
+  async connect(opts: {
+    natsWsServerUrls?: string[]
+    user?: IdentityUser
+    prefix?: string
+  }) {
+    const { natsWsServerUrls, user, prefix } = opts
+
+    const finalNatsServerUrls = natsWsServerUrls ?? [
+      this.config.natsUrl,
+    ]
+
     this.nc = await connect({
-      servers: natsServerUrls,
+      servers: finalNatsServerUrls,
     })
 
-    this.userId = user.userId
-    this.sessionId = user.sessionId
+    const userInfo =
+      user ?? new AuthService({ authUrl: '' }).getLastLoginData()
+
+    if (!userInfo) {
+      throw new Error(
+        'Please authenticate first by calling `auth` apis',
+      )
+    }
+
+    this.userId = userInfo.userId
+    this.sessionId = userInfo.sessionId
 
     this.globalPrefix = prefix ?? ''
 
@@ -197,6 +219,9 @@ export class NatsService<TApi> {
     return () => subscription.unsubscribe()
   }
 
+  /**
+   * Reqiores permission to publish response in `_INBOX.>`. If you need to just listen events, use `on`.
+   */
   async handler<TSubject extends keyof TApi & string>(
     subject: TSubject,
     cb: (
@@ -249,33 +274,33 @@ export class NatsService<TApi> {
 
           const decodedMessage = jsonCodec.decode(message.data)
 
-          cb(decodedMessage as any, {
-            subject,
-            userId,
-            sessionId,
-          })
-            .then(res => {
-              if (message.reply) {
-                message.respond(
-                  jsonCodec.encode({
-                    ok: true,
-                    data: res,
-                  }),
-                )
-              }
-            })
-            .catch(err => {
-              console.error('[nats] handle', err)
-
-              if (message.reply) {
-                message.respond(
-                  jsonCodec.encode({
-                    ok: false,
-                    message: err.message,
-                  }),
-                )
-              }
+          try {
+            const res = await cb(decodedMessage as any, {
+              subject,
+              userId,
+              sessionId,
             })
+
+            if (message.reply) {
+              message.respond(
+                jsonCodec.encode({
+                  ok: true,
+                  data: res,
+                }),
+              )
+            }
+          } catch (err: any) {
+            console.error('[nats] handle', err)
+
+            if (message.reply) {
+              message.respond(
+                jsonCodec.encode({
+                  ok: false,
+                  message: err.message,
+                }),
+              )
+            }
+          }
         } catch (err: any) {
           console.error('[nats] handle', err)
 
@@ -301,11 +326,7 @@ export class NatsService<TApi> {
   }
 }
 
-export const nats = new NatsService()
-
 type IdentityUser = {
-  jwt: string
-  seed: string
   userId: string
   sessionId: string
 }

package/src/tts.service.ts

@@ -1,94 +1,153 @@
 import { playAudioFromBuffer } from './common/playAudioFromBuffer'
 
-type Config = {
-  voicevoxUrl: string
-}
-
-export class VoicevoxTtsService {
-  constructor(private config: Config) {}
-
-  async getAudioBuffer(text: string, voice: string) {
-    const audioQueryResponse = await fetch(
-      `${
-        this.config.voicevoxUrl
-      }/audio_query?text=${encodeURIComponent(text)}&speaker=${
-        voice || 3
-      }`,
-      {
-        method: 'POST',
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-    )
+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
 
-    if (!audioQueryResponse.ok) {
-      throw new Error(
-        `Audio query failed: ${audioQueryResponse.statusText}`,
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(
+        `${Constants.WSS_URL}?trustedclienttoken=${Constants.TRUSTED_CLIENT_TOKEN}&ConnectionId=${reqId}`,
       )
-    }
 
-    const audioQuery = await audioQueryResponse.json()
-
-    // Step 2: Synthesize the speech
-    const synthesisResponse = await fetch(
-      `${this.config.voicevoxUrl}/synthesis?speaker=${voice}`,
-      {
-        method: 'POST',
-        headers: {
-          Accept: 'audio/wav',
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify(audioQuery),
-      },
-    )
+      ws.binaryType = 'arraybuffer'
 
-    if (!synthesisResponse.body) {
-      return null
-    }
+      const SSML_text = getSSML(text, voice, options)
 
-    const reader = synthesisResponse.body.getReader()
-    const chunks = []
+      ws.addEventListener('open', () => {
+        const configMessage = buildTTSConfigMessage()
+        ws.send(configMessage)
 
-    // Step 1: Read all the chunks
-    while (true) {
-      const { done, value } = await reader.read()
-      if (done) break
-      chunks.push(value)
-    }
+        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
 
-    // Step 2: Concatenate into one Uint8Array
-    const totalLength = chunks.reduce(
-      (acc, chunk) => acc + chunk.length,
-      0,
-    )
-    const audioData = new Uint8Array(totalLength)
-    let offset = 0
-    for (const chunk of chunks) {
-      audioData.set(chunk, offset)
-      offset += chunk.length
-    }
+        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
+        }
 
-    return audioData.buffer
+        // 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) {
-    return this.getAudioBuffer(text, voice).then(x =>
-      x ? playAudioFromBuffer(x) : null,
+  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 speakers = await fetch(
-      `${this.config.voicevoxUrl}/speakers`,
-    ).then(x => x.json())
-
-    return speakers.flatMap((x: any) =>
-      x.styles.map((y: any) => ({
-        id: y.id.toString(),
-        locale: 'ja-JP',
-        description: `${x.name} - ${y.name}`,
-      })),
+    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/voicevoxTts.ts

@@ -0,0 +1,94 @@
+import { playAudioFromBuffer } from './common/playAudioFromBuffer'
+
+type Config = {
+  voicevoxUrl: string
+}
+
+export class VoicevoxTtsService {
+  constructor(private config: Config) {}
+
+  async getAudioBuffer(text: string, voice: string) {
+    const audioQueryResponse = await fetch(
+      `${
+        this.config.voicevoxUrl
+      }/audio_query?text=${encodeURIComponent(text)}&speaker=${
+        voice || 3
+      }`,
+      {
+        method: 'POST',
+        headers: {
+          Accept: 'application/json',
+        },
+      },
+    )
+
+    if (!audioQueryResponse.ok) {
+      throw new Error(
+        `Audio query failed: ${audioQueryResponse.statusText}`,
+      )
+    }
+
+    const audioQuery = await audioQueryResponse.json()
+
+    // Step 2: Synthesize the speech
+    const synthesisResponse = await fetch(
+      `${this.config.voicevoxUrl}/synthesis?speaker=${voice}`,
+      {
+        method: 'POST',
+        headers: {
+          Accept: 'audio/wav',
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(audioQuery),
+      },
+    )
+
+    if (!synthesisResponse.body) {
+      return null
+    }
+
+    const reader = synthesisResponse.body.getReader()
+    const chunks = []
+
+    // Step 1: Read all the chunks
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      chunks.push(value)
+    }
+
+    // Step 2: Concatenate into one Uint8Array
+    const totalLength = chunks.reduce(
+      (acc, chunk) => acc + chunk.length,
+      0,
+    )
+    const audioData = new Uint8Array(totalLength)
+    let offset = 0
+    for (const chunk of chunks) {
+      audioData.set(chunk, offset)
+      offset += chunk.length
+    }
+
+    return audioData.buffer
+  }
+
+  async getAudio(text: string, voice: string) {
+    return this.getAudioBuffer(text, voice).then(x =>
+      x ? playAudioFromBuffer(x) : null,
+    )
+  }
+
+  async getVoices(): Promise<any[]> {
+    const speakers = await fetch(
+      `${this.config.voicevoxUrl}/speakers`,
+    ).then(x => x.json())
+
+    return speakers.flatMap((x: any) =>
+      x.styles.map((y: any) => ({
+        id: y.id.toString(),
+        locale: 'ja-JP',
+        description: `${x.name} - ${y.name}`,
+      })),
+    )
+  }
+}