@jokio/sdk 0.0.1

package/src/nats.service.ts

@@ -0,0 +1,325 @@
+import {
+  connect,
+  DebugEvents,
+  Events,
+  JSONCodec,
+  type NatsConnection,
+} from 'nats.ws'
+
+const jsonCodec = JSONCodec()
+
+export class NatsService<TApi> {
+  onStatusChange?: (isConnected: boolean) => void
+
+  private nc?: NatsConnection
+  private sessionId: string = ''
+  private userId: string = ''
+
+  private globalPrefix = ''
+
+  private resolveConnected = (_: unknown) => {}
+  isConnected = new Promise(
+    resolve => (this.resolveConnected = resolve),
+  )
+
+  async connect(
+    natsServerUrls: string[],
+    user: IdentityUser,
+    prefix?: string,
+  ) {
+    this.nc = await connect({
+      servers: natsServerUrls,
+    })
+
+    this.userId = user.userId
+    this.sessionId = user.sessionId
+
+    this.globalPrefix = prefix ?? ''
+
+    this.resolveConnected(true)
+
+    this.onStatusChange?.(true)
+    console.log(
+      '[nats] connected.',
+      this.globalPrefix ? `(prefix: ${this.globalPrefix})` : '',
+    )
+
+    // Monitor connection status
+    ;(async () => {
+      for await (const status of this.nc!.status()) {
+        if (status.type !== DebugEvents.PingTimer) {
+          console.log('[nats] connection status:', status.type)
+        }
+
+        switch (status.type) {
+          case Events.Reconnect:
+            this.onStatusChange?.(true)
+            break
+
+          case Events.Disconnect:
+          case Events.Error:
+          case DebugEvents.Reconnecting:
+            this.onStatusChange?.(false)
+            break
+        }
+      }
+    })()
+  }
+
+  async disconnect() {
+    await this.nc?.drain()
+    await this.nc?.close()
+  }
+
+  async publish<TSubject extends keyof TApi & string>(
+    subject: TSubject,
+    data: InferReturnType<TApi, TSubject>,
+  ) {
+    await this.isConnected
+
+    if (!this.nc) {
+      throw new Error('[nats] not connected')
+    }
+
+    try {
+      const finalSubject = this.buildSubject(subject)
+
+      console.debug('[nats]>>', finalSubject)
+
+      this.nc.publish(finalSubject, jsonCodec.encode(data))
+    } catch (error) {
+      console.error('[nats] publish failed:', error)
+      throw error
+    }
+  }
+
+  async call<TSubject extends keyof TApi & string>(
+    subject: TSubject,
+    data: InferProps<TApi, TSubject>,
+    opts?: { timeoutInMs?: number },
+  ): Promise<InferReturnType<TApi, TSubject>> {
+    await this.isConnected
+
+    if (!this.nc) {
+      throw new Error('[nats] not connected')
+    }
+
+    try {
+      const finalSubject = this.buildSubject(subject)
+
+      console.debug('[nats]>>', finalSubject)
+
+      const response = await this.nc.request(
+        finalSubject,
+        jsonCodec.encode(data),
+        { timeout: opts?.timeoutInMs ?? 5000 },
+      )
+      const result:
+        | { ok: true; data: any }
+        | { ok: false; message: string } = jsonCodec.decode(
+        response.data,
+      ) as any
+
+      if (!result.ok) {
+        throw new Error(result.message)
+      }
+
+      return result.data
+    } catch (error) {
+      console.error('[nats] request failed:', error)
+      throw new Error('Api call failed.')
+    }
+  }
+
+  async on<TSubject extends keyof TApi & string>(
+    subject: TSubject,
+    cb: (
+      data: InferReturnType<TApi, TSubject>,
+      ctx: {
+        subject: string
+        userId: string
+        sessionId: string
+      },
+    ) => void,
+  ) {
+    await this.isConnected
+
+    if (!this.nc) {
+      throw new Error('[nats] not connected')
+    }
+
+    const prefix = this.globalPrefix ? `${this.globalPrefix}.` : ''
+    const finalSubject = prefix + subject + '.>'
+
+    const subscription = this.nc!.subscribe(finalSubject)
+
+    ;(async () => {
+      for await (const message of subscription) {
+        try {
+          console.debug('[nats]<<', message.subject)
+
+          const subjectParts = message.subject.split('.')
+
+          // -- process prefix --
+          if (
+            this.globalPrefix &&
+            subjectParts[0] !== this.globalPrefix
+          ) {
+            console.log('[nats]', 'Skipped - ' + message.subject)
+            continue
+          }
+
+          if (subjectParts[0] === 'dev') {
+            // remove the first element / prefix
+            subjectParts.shift()
+          }
+          // -- process prefix --
+
+          const subject = subjectParts
+            .slice(0, subjectParts.length - 2)
+            .join('.')
+          const userId = subjectParts[subjectParts.length - 2]
+          const sessionId = subjectParts[subjectParts.length - 1]
+
+          const decodedMessage = jsonCodec.decode(message.data)
+
+          cb(decodedMessage as any, {
+            subject,
+            userId,
+            sessionId,
+          })
+        } catch (err) {
+          console.error('[nats] subscribe error', err)
+        }
+      }
+    })()
+
+    return () => subscription.unsubscribe()
+  }
+
+  async handler<TSubject extends keyof TApi & string>(
+    subject: TSubject,
+    cb: (
+      data: InferProps<TApi, TSubject>,
+      ctx: {
+        subject: string
+        userId: string
+        sessionId: string
+      },
+    ) => Promise<InferReturnType<TApi, TSubject>>,
+  ) {
+    await this.isConnected
+
+    if (!this.nc) {
+      throw new Error('[nats] not connected')
+    }
+
+    const prefix = this.globalPrefix ? `${this.globalPrefix}.` : ''
+    const finalSubject = prefix + subject + '.>'
+
+    const subscription = this.nc!.subscribe(finalSubject)
+
+    ;(async () => {
+      for await (const message of subscription) {
+        try {
+          console.debug('[nats]<<', message.subject)
+
+          const subjectParts = message.subject.split('.')
+
+          // -- process prefix --
+          if (
+            this.globalPrefix &&
+            subjectParts[0] !== this.globalPrefix
+          ) {
+            console.log('[nats]', 'Skipped - ' + message.subject)
+            continue
+          }
+
+          if (subjectParts[0] === 'dev') {
+            // remove the first element / prefix
+            subjectParts.shift()
+          }
+          // -- process prefix --
+
+          const subject = subjectParts
+            .slice(0, subjectParts.length - 2)
+            .join('.')
+          const userId = subjectParts[subjectParts.length - 2]
+          const sessionId = subjectParts[subjectParts.length - 1]
+
+          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,
+                  }),
+                )
+              }
+            })
+        } catch (err: any) {
+          console.error('[nats] handle', err)
+
+          if (message.reply) {
+            message.respond(
+              jsonCodec.encode({
+                ok: false,
+                message: err.message,
+              }),
+            )
+          }
+        }
+      }
+    })()
+
+    return () => subscription.unsubscribe()
+  }
+
+  private buildSubject(subject: string) {
+    return [this.globalPrefix, subject, this.userId, this.sessionId]
+      .filter(x => x)
+      .join('.')
+  }
+}
+
+export const nats = new NatsService()
+
+type IdentityUser = {
+  jwt: string
+  seed: string
+  userId: string
+  sessionId: string
+}
+
+type InferProps<
+  TApi,
+  TSubject extends keyof TApi,
+> = TApi[TSubject] extends (args: infer TProps) => unknown
+  ? TProps
+  : {}
+
+type InferReturnType<
+  TApi,
+  TSubject extends keyof TApi,
+> = TApi[TSubject] extends (args: any) => infer TResult
+  ? TResult
+  : TApi[TSubject]

package/src/tts.service.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}`,
+      })),
+    )
+  }
+}

package/test/index.html

@@ -0,0 +1,63 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8" />
+    <title>MyLibrary Test</title>
+</head>
+
+<body>
+    <h1>Library Test</h1>
+
+    <button onclick="playAudio()">Edge TTS</button>
+
+    <button onclick="playAudio2()">Voicevox TTS</button>
+
+    <script type="module">
+        import { jok } from './dist/jokio.sdk.es.js';
+        window.jok = jok
+        // jok.voicevoxTts.getVoices().then(console.log)
+        // document.body.innerHTML += `<p>${}</p>`;
+
+        window.playAudio = async function () {
+            const audio = await jok.edgeTts.getAudio("Hello there, how are you?", "en-US-AvaNeural")
+
+            audio.play()
+        }
+
+
+        window.playAudio2 = async function () {
+            const audio = await jok.voicevoxTts.getAudio("こんにちわ、おげんきですか？あなたはあたまがいいですね。", 3)
+
+            audio.play()
+        }
+
+
+        window.p2pChat = async function () {
+            const k1 = await jok.crypto.createSessionKeyPair()
+            const k2 = await jok.crypto.createSessionKeyPair()
+
+            const p1 = await jok.crypto.exportPublicKey(k1.publicKey)
+            const p2 = await jok.crypto.exportPublicKey(k2.publicKey)
+
+            console.log({ p1, p2 })
+
+            const shared1 = await jok.crypto.deriveAESKey(k1.privateKey, p2)
+            const shared2 = await jok.crypto.deriveAESKey(k2.privateKey, p1)
+
+            const originalText = "Hello World"
+
+            const encrypted = await jok.crypto.encrypt(originalText, shared1)
+            const decrypted = await jok.crypto.decrypt(encrypted, shared2)
+
+            console.log({
+                match: originalText === decrypted,
+                originalText,
+                decrypted,
+            })
+        }
+    </script>
+
+</body>
+
+</html>

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "outDir": "dist",
+    "strict": true,
+    "moduleResolution": "Node",
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}

package/vite.config.ts

@@ -0,0 +1,23 @@
+import path from 'path'
+import { defineConfig } from 'vite'
+
+export default defineConfig({
+  publicDir: "test",
+  server: {
+    open: '/index.html' // or 'test/index.html' if kept in /test
+  },
+  build: {
+    lib: {
+      entry: path.resolve(__dirname, 'src/index.ts'),
+      name: '@jokio/sdk',
+      fileName: format => `jokio.sdk.${format}.js`,
+    },
+    // rollupOptions: {
+    //   output: {
+    //     globals: {
+    //       // Example: react: 'React'
+    //     },
+    //   },
+    // },
+  },
+})