@agentunion/kite 1.5.0 → 1.6.1

package/extensions/services/evol/web/src/services/kernel-client.ts

@@ -0,0 +1,406 @@
+/**
+ * Kernel WebSocket Client (TypeScript)
+ *
+ * Features:
+ * - Pairing/Authentication
+ * - Auto-reconnect
+ * - RPC calls
+ * - Event subscription
+ * - Token renewal
+ */
+
+import type { RpcResponse, ConnectionStatus } from '@/types/rpc'
+
+type MessageHandler = (event: MessageEvent) => void
+type ConnectionCallback = (status: ConnectionStatus, message: string) => void
+type AuthenticatedCallback = (reconnected: boolean) => void
+type EventCallback = (data: any) => void
+
+interface PendingRpc {
+  resolve: (value: any) => void
+  reject: (reason: any) => void
+  timeout: number
+}
+
+export class KernelClient {
+  private url: string
+  private ws: WebSocket | null = null
+  private moduleId: string | null = null
+  private role: string | null = null
+
+  public connected = false
+  public authenticated = false
+
+  // RPC management
+  private rpcId = 0
+  private pendingRpcs = new Map<string, PendingRpc>()
+
+  // Event listeners
+  private eventListeners = new Map<string, EventCallback[]>()
+
+  // Connection callbacks
+  public onConnectionChange: ConnectionCallback | null = null
+  public onAuthenticated: AuthenticatedCallback | null = null
+
+  // Reconnect config
+  private reconnectDelay = 1000
+  private maxReconnectDelay = 30000
+  private reconnectAttempts = 0
+  private reconnectTimer: number | null = null
+  private fatalError = false
+
+  // Heartbeat
+  private heartbeatInterval = 20000
+  private heartbeatTimer: number | null = null
+
+  // Token management
+  private token: string | null
+  private sessionToken: string
+
+  // Traffic stats
+  public bytesReceived = 0
+  public bytesSent = 0
+
+  constructor(url: string) {
+    this.url = url
+    // 优先使用 kiteToken（Evol 登录），其次使用 frontend_token（配对码）
+    this.token = localStorage.getItem('kiteToken') || localStorage.getItem('frontend_token')
+    console.log('[KernelClient] Constructor - token:', this.token ? this.token.substring(0, 20) + '...' : 'null')
+
+    let sessionToken = sessionStorage.getItem('session_token')
+    if (!sessionToken) {
+      sessionToken = 'sess_' + this.randomString(6)
+      sessionStorage.setItem('session_token', sessionToken)
+    }
+    this.sessionToken = sessionToken
+  }
+
+  async pair(code: string): Promise<{ moduleId: string; role: string }> {
+    return new Promise((resolve, reject) => {
+      this.connectWs((ws) => {
+        const pairMsg = JSON.stringify({ type: 'pair', code })
+        ws.send(pairMsg)
+        this.bytesSent += pairMsg.length
+
+        const handler: MessageHandler = (event) => {
+          this.bytesReceived += event.data.length
+          const msg = JSON.parse(event.data)
+
+          if (msg.type === 'paired') {
+            this.token = msg.token
+            this.sessionToken = msg.session_token
+            this.moduleId = msg.module_id
+            this.role = msg.role
+            localStorage.setItem('frontend_token', this.token)
+            sessionStorage.setItem('session_token', this.sessionToken)
+            this.authenticated = true
+            ws.removeEventListener('message', handler)
+            resolve({ moduleId: this.moduleId, role: this.role })
+          } else if (msg.type === 'error') {
+            ws.removeEventListener('message', handler)
+            reject(new Error(msg.message))
+          }
+        }
+
+        ws.addEventListener('message', handler)
+      }, reject)
+    })
+  }
+
+  async connect(): Promise<{ moduleId: string; role: string; reconnected: boolean }> {
+    if (!this.token) {
+      throw new Error('No token found, please pair first')
+    }
+
+    return new Promise((resolve, reject) => {
+      this.connectWs((ws) => {
+        const authMsg = JSON.stringify({
+          type: 'auth',
+          token: this.token,
+          session_token: this.sessionToken
+        })
+        console.log('[KernelClient] Sending auth message, token:', this.token ? this.token.substring(0, 20) + '...' : 'null')
+        ws.send(authMsg)
+        this.bytesSent += authMsg.length
+
+        const handler: MessageHandler = (event) => {
+          this.bytesReceived += event.data.length
+          const msg = JSON.parse(event.data)
+
+          if (msg.type === 'authenticated' || msg.type === 'reconnected') {
+            this.moduleId = msg.module_id
+            this.role = msg.role
+            this.authenticated = true
+            ws.removeEventListener('message', handler)
+
+            const isReconnected = msg.type === 'reconnected'
+            if (this.onAuthenticated) {
+              try {
+                this.onAuthenticated(isReconnected)
+              } catch (e) {
+                console.error('[KernelClient] onAuthenticated callback error:', e)
+              }
+            }
+
+            resolve({ moduleId: this.moduleId, role: this.role, reconnected: isReconnected })
+          } else if (msg.type === 'error') {
+            ws.removeEventListener('message', handler)
+
+            if (msg.fatal) {
+              this.fatalError = true
+              console.error('[KernelClient] Fatal error, will not retry:', msg.message)
+            }
+
+            if (msg.message.includes('Invalid') || msg.message.includes('expired')) {
+              localStorage.removeItem('frontend_token')
+              this.token = null
+            }
+
+            reject(new Error(msg.message))
+          }
+        }
+
+        ws.addEventListener('message', handler)
+      }, reject)
+    })
+  }
+
+  async call<T = any>(method: string, params: Record<string, any> = {}, timeout = 30000): Promise<T> {
+    if (!this.authenticated) {
+      throw new Error('Not authenticated')
+    }
+
+    return new Promise((resolve, reject) => {
+      const id = `rpc-${++this.rpcId}`
+      const rpcMsg = JSON.stringify({
+        jsonrpc: '2.0',
+        id,
+        method,
+        params
+      })
+
+      this.ws!.send(rpcMsg)
+      this.bytesSent += rpcMsg.length
+
+      const timer = window.setTimeout(() => {
+        this.pendingRpcs.delete(id)
+        reject(new Error(`RPC timeout: ${method}`))
+      }, timeout)
+
+      this.pendingRpcs.set(id, { resolve, reject, timeout: timer })
+    })
+  }
+
+  async subscribe(events: string[]): Promise<any> {
+    return this.call('event.subscribe', { events })
+  }
+
+  on(event: string, callback: EventCallback): void {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, [])
+    }
+    this.eventListeners.get(event)!.push(callback)
+  }
+
+  off(event: string, callback: EventCallback): void {
+    if (!this.eventListeners.has(event)) return
+    const listeners = this.eventListeners.get(event)!
+    const index = listeners.indexOf(callback)
+    if (index > -1) {
+      listeners.splice(index, 1)
+    }
+  }
+
+  disconnect(): void {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer)
+      this.reconnectTimer = null
+    }
+
+    this.stopHeartbeat()
+
+    if (this.ws) {
+      try {
+        const disconnectMsg = JSON.stringify({ type: 'disconnect' })
+        this.ws.send(disconnectMsg)
+        this.bytesSent += disconnectMsg.length
+      } catch (e) {
+        // Ignore
+      }
+
+      this.ws.close()
+      this.ws = null
+    }
+
+    this.connected = false
+    this.authenticated = false
+  }
+
+  private startHeartbeat(): void {
+    this.stopHeartbeat()
+    this.heartbeatTimer = window.setInterval(() => {
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        try {
+          const pingMsg = JSON.stringify({ type: 'ping' })
+          this.ws.send(pingMsg)
+          this.bytesSent += pingMsg.length
+        } catch (e) {
+          console.error('[KernelClient] Heartbeat failed:', e)
+        }
+      }
+    }, this.heartbeatInterval)
+  }
+
+  private stopHeartbeat(): void {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer)
+      this.heartbeatTimer = null
+    }
+  }
+
+  private connectWs(
+    onOpen: (ws: WebSocket) => void,
+    onError: (error: any) => void
+  ): void {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      onOpen(this.ws)
+      return
+    }
+
+    const ws = new WebSocket(this.url)
+
+    ws.onopen = () => {
+      console.log('[KernelClient] WebSocket connected')
+      this.ws = ws
+      this.connected = true
+      this.reconnectAttempts = 0
+      this.reconnectDelay = 1000
+      this.startHeartbeat()
+
+      if (this.onConnectionChange) {
+        this.onConnectionChange('connected', 'WebSocket 已连接')
+      }
+
+      onOpen(ws)
+    }
+
+    ws.onerror = (error) => {
+      console.error('[KernelClient] WebSocket error:', error)
+      if (onError) onError(error)
+    }
+
+    ws.onclose = () => {
+      console.log('[KernelClient] WebSocket closed')
+      this.connected = false
+      this.authenticated = false
+      this.ws = null
+      this.stopHeartbeat()
+
+      if (this.onConnectionChange) {
+        this.onConnectionChange('disconnected', 'WebSocket 已断开')
+      }
+
+      if (this.token) {
+        this.scheduleReconnect()
+      }
+    }
+
+    ws.onmessage = (event) => {
+      this.bytesReceived += event.data.length
+      this.handleMessage(event.data)
+    }
+  }
+
+  private handleMessage(raw: string): void {
+    try {
+      const msg = JSON.parse(raw) as RpcResponse
+
+      // RPC response
+      if (msg.id && this.pendingRpcs.has(String(msg.id))) {
+        const { resolve, reject, timeout } = this.pendingRpcs.get(String(msg.id))!
+        clearTimeout(timeout)
+        this.pendingRpcs.delete(String(msg.id))
+
+        if (msg.error) {
+          reject(new Error(msg.error.message || 'RPC error'))
+        } else {
+          resolve(msg.result)
+        }
+        return
+      }
+
+      // Event notification
+      if ((msg as any).method === 'event' || !msg.id) {
+        const params = (msg as any).params || {}
+        const event = params.event
+        const data = params.data || {}
+
+        // Exact match listeners
+        if (event && this.eventListeners.has(event)) {
+          const listeners = this.eventListeners.get(event)!
+          listeners.forEach(callback => {
+            try {
+              callback(data)
+            } catch (e) {
+              console.error('[KernelClient] Event listener error:', e)
+            }
+          })
+        }
+
+        // Wildcard listeners
+        if (event && this.eventListeners.has('>')) {
+          const wildcardListeners = this.eventListeners.get('>')!
+          wildcardListeners.forEach(callback => {
+            try {
+              callback({ ...data, event })
+            } catch (e) {
+              console.error('[KernelClient] Wildcard event listener error:', e)
+            }
+          })
+        }
+      }
+    } catch (e) {
+      console.error('[KernelClient] Message parse error:', e)
+    }
+  }
+
+  private scheduleReconnect(): void {
+    if (this.fatalError) {
+      console.error('[KernelClient] Fatal error detected, reconnection disabled')
+      if (this.onConnectionChange) {
+        this.onConnectionChange('error', '连接失败（永久性错误）')
+      }
+      return
+    }
+
+    if (this.reconnectTimer) return
+
+    this.reconnectAttempts++
+    const delay = Math.min(
+      this.reconnectDelay * Math.pow(1.5, this.reconnectAttempts - 1),
+      this.maxReconnectDelay
+    )
+
+    console.log(`[KernelClient] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`)
+
+    if (this.onConnectionChange) {
+      this.onConnectionChange('reconnecting', `正在重连... (${this.reconnectAttempts})`)
+    }
+
+    this.reconnectTimer = window.setTimeout(() => {
+      this.reconnectTimer = null
+      this.connect().catch(err => {
+        console.error('[KernelClient] Reconnect failed:', err)
+      })
+    }, delay)
+  }
+
+  private randomString(length: number): string {
+    const chars = 'abcdefghijklmnopqrstuvwxyz0123456789'
+    let result = ''
+    for (let i = 0; i < length; i++) {
+      result += chars.charAt(Math.floor(Math.random() * chars.length))
+    }
+    return result
+  }
+}

package/extensions/services/evol/web/src/stores/auth.ts

@@ -0,0 +1,189 @@
+import { defineStore } from 'pinia'
+import { ref, computed } from 'vue'
+import type { UserInfo } from '@/types/token'
+
+export const useAuthStore = defineStore('auth', () => {
+  const kiteToken = ref<string | null>(getKiteToken())
+  const userInfo = ref<UserInfo | null>(null)
+  const deviceInfo = ref(getDeviceInfo())
+
+  // Cache (5s TTL)
+  const userInfoCache = ref<UserInfo | null>(null)
+  const userInfoCacheTime = ref(0)
+  const CACHE_TTL = 5000
+
+  function getKiteToken(): string | null {
+    let token = localStorage.getItem('kiteToken')
+    if (token) return token
+
+    token = getCookie('kiteToken')
+    if (token) {
+      localStorage.setItem('kiteToken', token)
+      return token
+    }
+    return null
+  }
+
+  function getCookie(name: string): string | null {
+    const value = `; ${document.cookie}`
+    const parts = value.split(`; ${name}=`)
+    if (parts.length === 2) return parts.pop()!.split(';').shift() || null
+    return null
+  }
+
+  function setCookie(name: string, value: string, days = 30) {
+    const expires = new Date(Date.now() + days * 864e5).toUTCString()
+    document.cookie = `${name}=${value}; expires=${expires}; path=/; SameSite=Strict`
+  }
+
+  function saveKiteToken(token: string) {
+    kiteToken.value = token
+    localStorage.setItem('kiteToken', token)
+    setCookie('kiteToken', token, 30)
+  }
+
+  function clearKiteToken() {
+    kiteToken.value = null
+    localStorage.removeItem('kiteToken')
+    setCookie('kiteToken', '', -1)
+  }
+
+  function getDeviceInfo() {
+    let deviceId = localStorage.getItem('deviceId')
+    if (!deviceId) {
+      deviceId = 'device_' + randomString(16) + '_' + Date.now()
+      localStorage.setItem('deviceId', deviceId)
+    }
+
+    const ua = navigator.userAgent
+    let osName = 'Unknown OS'
+    if (/Windows/i.test(ua)) osName = 'Windows'
+    else if (/Mac/i.test(ua)) osName = 'macOS'
+    else if (/Linux/i.test(ua)) osName = 'Linux'
+    else if (/Android/i.test(ua)) osName = 'Android'
+    else if (/iPhone|iPad/i.test(ua)) osName = 'iOS'
+
+    let browserName = 'Unknown Browser'
+    if (/Chrome/i.test(ua) && !/Edge/i.test(ua)) browserName = 'Chrome'
+    else if (/Firefox/i.test(ua)) browserName = 'Firefox'
+    else if (/Safari/i.test(ua) && !/Chrome/i.test(ua)) browserName = 'Safari'
+    else if (/Edge/i.test(ua)) browserName = 'Edge'
+
+    return {
+      deviceId,
+      deviceName: `${browserName} on ${osName}`,
+      deviceType: /Android|iPhone|iPad/i.test(ua) ? 'Mobile' : 'Desktop',
+      browser: browserName,
+      os: osName,
+      userAgent: ua
+    }
+  }
+
+  function randomString(length: number): string {
+    const chars = 'abcdefghijklmnopqrstuvwxyz0123456789'
+    let result = ''
+    for (let i = 0; i < length; i++) {
+      result += chars.charAt(Math.floor(Math.random() * chars.length))
+    }
+    return result
+  }
+
+  /**
+   * 通过 HTTP→RPC 转发发送短信验证码
+   */
+  async function sendSMS(phone: string) {
+    const res = await fetch('/api/send_sms', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ phone })
+    })
+    return res.json()
+  }
+
+  /**
+   * 通过 HTTP→RPC 转发验证短信并登录
+   */
+  async function login(phone: string, code: string) {
+    const res = await fetch('/api/verify_sms', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ phone, code, deviceInfo: deviceInfo.value })
+    })
+    const result = await res.json()
+    if (result.success) {
+      saveKiteToken(result.kiteToken)
+      userInfo.value = result.data
+      userInfoCache.value = result.data
+      userInfoCacheTime.value = Date.now()
+    }
+    return result
+  }
+
+  async function logout(kernelClient: any) {
+    try {
+      if (kernelClient && kiteToken.value) {
+        await kernelClient.call('evol.logout', { kiteToken: kiteToken.value })
+      }
+    } catch (e) {
+      console.error('Logout RPC failed:', e)
+    }
+    clearKiteToken()
+    userInfo.value = null
+    userInfoCache.value = null
+  }
+
+  async function loadUserInfo(kernelClient: any) {
+    const now = Date.now()
+    if (userInfoCache.value && now - userInfoCacheTime.value < CACHE_TTL) {
+      userInfo.value = userInfoCache.value
+      return
+    }
+
+    if (kernelClient && !kernelClient.authenticated) {
+      const start = Date.now()
+      while (!kernelClient.authenticated && Date.now() - start < 5000) {
+        await new Promise(r => setTimeout(r, 100))
+      }
+    }
+
+    if (!kernelClient || !kernelClient.authenticated) {
+      throw new Error('KernelClient not authenticated')
+    }
+
+    const data = await kernelClient.call('evol.get_user_info', { kiteToken: kiteToken.value })
+    if (data.success) {
+      userInfo.value = data.data
+      userInfoCache.value = data.data
+      userInfoCacheTime.value = Date.now()
+    } else if (data.code === 'INVALID_KITE_TOKEN') {
+      clearKiteToken()
+      throw new Error('KITE_TOKEN_INVALID')
+    } else {
+      throw new Error(data.message || 'EVOL_TOKEN_INVALID')
+    }
+  }
+
+  const isAuthenticated = computed(() => !!kiteToken.value)
+  const displayName = computed(() => {
+    if (!userInfo.value) return ''
+    const info = userInfo.value.userInfo || userInfo.value
+    return info.nickName || info.userName || ''
+  })
+  const credits = computed(() => {
+    if (!userInfo.value) return 0
+    return userInfo.value.accountInfo?.credits || 0
+  })
+
+  return {
+    kiteToken,
+    userInfo,
+    deviceInfo,
+    isAuthenticated,
+    displayName,
+    credits,
+    sendSMS,
+    login,
+    logout,
+    loadUserInfo
+  }
+})