@jokio/sdk 0.1.10 → 0.1.12

package/src/auth.service.ts

@@ -1,152 +0,0 @@
-import {
-  startAuthentication,
-  startRegistration,
-} from '@simplewebauthn/browser'
-
-type Config = {
-  authUrl: string
-}
-
-const USER_STORAGE_KEY = 'LAST_AUTH_DATA'
-
-export class AuthService {
-  constructor(private config: Config) {}
-
-  async requestEmailLogin(
-    email: string,
-    returnUrl: string = location.href,
-  ) {
-    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)
-
-    localStorage.setItem(USER_STORAGE_KEY, JSON.stringify(res))
-
-    return res as IdentityUser
-  }
-
-  async requestPasskeyLogin(
-    opts: {
-      displayName?: string
-      isRegistration?: boolean
-      addAsAdditionalDevice?: boolean
-    } = {},
-  ) {
-    const {
-      displayName = '',
-      isRegistration = false,
-      addAsAdditionalDevice = false,
-    } = opts
-
-    // 1. get challenge options
-    const passkeyOpts = 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 (!passkeyOpts.user?.id) {
-        attResp = await startAuthentication({
-          optionsJSON: passkeyOpts,
-        })
-      } else {
-        attResp = await startRegistration({
-          optionsJSON: passkeyOpts,
-        })
-      }
-    } 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)
-
-    localStorage.setItem(USER_STORAGE_KEY, JSON.stringify(res))
-
-    return res as IdentityUser
-  }
-
-  async guestLogin() {
-    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 = {
-  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

@@ -1,15 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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/index.ts

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

package/src/nats.service.ts

@@ -1,348 +0,0 @@
-import {
-  connect,
-  DebugEvents,
-  Events,
-  JSONCodec,
-  type NatsConnection,
-} from 'nats.ws'
-import { AuthService } from './auth.service'
-
-type Config = {
-  natsUrl: string
-}
-
-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),
-  )
-
-  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: finalNatsServerUrls,
-    })
-
-    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 ?? ''
-
-    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()
-  }
-
-  /**
-   * 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: (
-      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)
-
-          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)
-
-          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('.')
-  }
-}
-
-type IdentityUser = {
-  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]