虎牙抢购助手

+ + + item.valid).length} /> + + + + + + + + + + + + + row.id} + columns={prizeColumns} + dataSource={prizes} + pagination={{ pageSize: 12, showSizeChanger: false }} + scroll={{ x: 760 }} + /> + ), + }, + { + key: 'scores', + label: '积分', + children: ( + row.uid} + columns={scoreColumns} + dataSource={scores} + pagination={{ pageSize: 12, showSizeChanger: false }} + scroll={{ x: 680 }} + /> + ), + }, + { + key: 'records', + label: '记录', + children: ( +

row.key} + columns={recordColumns} + dataSource={recordRows} + pagination={{ pageSize: 12, showSizeChanger: false }} + scroll={{ x: 740 }} + /> + ), + }, + { + key: 'results', + label: '结果', + children: ( +

row.key || `${row.uid}-${row.loop}`} + columns={resultColumns} + dataSource={results} + pagination={{ pageSize: 12, showSizeChanger: false }} + scroll={{ x: 820 }} + /> + ), + }, + { + key: 'logs', + label: '日志', + children: , + }, + ]} + /> + + + ) +} + +function LogView({ logs }: { logs: LogEntry[] }) { + return ( +

+ {logs.map((item, index) => ( +

+ {item.time} + {item.level} + {item.message} +

+ ))} +

+ ) +} + +function normalizeExchangeResult(row: ExchangeResult, index: number): MonitorResult { + return { + key: `exchange-${row.uid}-${index}-${Date.now()}`, + loop: 0, + uid: row.uid, + action: 'exchange', + exchange: row.resp, + error: row.error, + } +} + +function normalizeMonitorResult(row: MonitorResult): MonitorResult { + return { + ...row, + key: `monitor-${row.loop || 0}-${row.uid}-${Date.now()}-${Math.random()}`, + } +} diff --git a/frontend/src/main.tsx b/frontend/src/main.tsx new file mode 100644 index 0000000..7e123ac --- /dev/null +++ b/frontend/src/main.tsx @@ -0,0 +1,37 @@ +import React from 'react' +import { createRoot } from 'react-dom/client' +import { App as AntApp, ConfigProvider } from 'antd' +import 'antd/dist/reset.css' +import './styles.css' +import Dashboard from './App' + +createRoot(document.getElementById('root')!).render( + + + + + + + , +) diff --git a/frontend/src/styles.css b/frontend/src/styles.css new file mode 100644 index 0000000..7c5b647 --- /dev/null +++ b/frontend/src/styles.css @@ -0,0 +1,169 @@ +* { + box-sizing: border-box; +} + +html, +body, +#root { + width: 100%; + height: 100%; + margin: 0; +} + +body { + color: #1f2937; + background: #eef2f7; +} + +.app-shell { + display: grid; + grid-template-columns: 380px minmax(0, 1fr); + gap: 12px; + height: 100vh; + padding: 12px; + overflow: hidden; +} + +.side-panel, +.main-panel { + min-height: 0; + border: 1px solid #d9e1ea; + border-radius: 8px; + background: #fff; +} + +.side-panel { + display: flex; + flex-direction: column; + padding: 14px; + overflow: auto; +} + +.main-panel { + display: flex; + flex-direction: column; + padding: 14px; + overflow: hidden; +} + +.brand-row { + display: flex; + align-items: flex-start; + justify-content: space-between; + gap: 10px; + margin-bottom: 14px; +} + +.brand-row h4 { + margin: 0 0 2px; +} + +.config-form .ant-form-item { + margin-bottom: 10px; +} + +.full { + width: 100%; +} + +.cookie-box textarea, +.cookie-box { + font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace; +} + +.action-bar { + display: flex; + margin-top: 2px; +} + +.run-row { + width: 100%; +} + +.run-row .ant-btn-primary { + flex: 1; +} + +.account-list { + display: flex; + flex-wrap: wrap; + gap: 6px; + min-height: 30px; + padding-top: 12px; +} + +.stats-row { + margin-bottom: 12px; +} + +.stats-row .ant-statistic { + padding: 10px 12px; + border: 1px solid #e5ebf2; + border-radius: 6px; + background: #f8fafc; +} + +.main-panel .ant-tabs { + min-height: 0; + flex: 1; +} + +.main-panel .ant-tabs-content, +.main-panel .ant-tabs-tabpane { + height: 100%; +} + +.log-view { + height: calc(100vh - 170px); + min-height: 360px; + overflow: auto; + border: 1px solid #e5ebf2; + border-radius: 6px; + background: #0f172a; + padding: 10px; +} + +.log-line { + display: grid; + grid-template-columns: 92px 64px minmax(0, 1fr); + align-items: start; + gap: 8px; + min-height: 24px; + color: #cbd5e1; + font-size: 12px; + line-height: 1.6; +} + +.log-line code { + white-space: pre-wrap; + word-break: break-word; + color: inherit; +} + +.log-line.level-error { + color: #fecaca; +} + +.log-line.level-debug { + color: #93c5fd; +} + +.ant-table-wrapper { + height: 100%; +} + +@media (max-width: 980px) { + .app-shell { + grid-template-columns: 1fr; + overflow: auto; + } + + .side-panel, + .main-panel { + overflow: visible; + } + + .log-view { + height: 420px; + } +} diff --git a/frontend/tsconfig.json b/frontend/tsconfig.json new file mode 100644 index 0000000..8d38243 --- /dev/null +++ b/frontend/tsconfig.json @@ -0,0 +1,21 @@ +{ + "compilerOptions": { + "target": "ES2020", + "useDefineForClassFields": true, + "lib": ["DOM", "DOM.Iterable", "ES2020"], + "allowJs": false, + "skipLibCheck": true, + "esModuleInterop": true, + "allowSyntheticDefaultImports": true, + "strict": true, + "forceConsistentCasingInFileNames": true, + "module": "ESNext", + "moduleResolution": "Node", + "resolveJsonModule": true, + "isolatedModules": true, + "noEmit": true, + "jsx": "react-jsx" + }, + "include": ["src", "wailsjs"], + "references": [{ "path": "./tsconfig.node.json" }] +} diff --git a/frontend/tsconfig.node.json b/frontend/tsconfig.node.json new file mode 100644 index 0000000..7065ca9 --- /dev/null +++ b/frontend/tsconfig.node.json @@ -0,0 +1,10 @@ +{ + "compilerOptions": { + "composite": true, + "skipLibCheck": true, + "module": "ESNext", + "moduleResolution": "Node", + "allowSyntheticDefaultImports": true + }, + "include": ["vite.config.ts"] +} diff --git a/frontend/vite.config.ts b/frontend/vite.config.ts new file mode 100644 index 0000000..185d5d0 --- /dev/null +++ b/frontend/vite.config.ts @@ -0,0 +1,10 @@ +import { defineConfig } from 'vite' +import react from '@vitejs/plugin-react' + +export default defineConfig({ + plugins: [react()], + clearScreen: false, + server: { + strictPort: true, + }, +}) diff --git a/frontend/wailsjs/go/gui/App.d.ts b/frontend/wailsjs/go/gui/App.d.ts new file mode 100755 index 0000000..b56ed75 --- /dev/null +++ b/frontend/wailsjs/go/gui/App.d.ts @@ -0,0 +1,23 @@ +// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL +// This file is automatically generated. DO NOT EDIT +import {gui} from '../models'; + +export function DefaultConfig():Promise; + +export function Exchange(arg1:gui.Config):Promise>; + +export function GetLogs():Promise>; + +export function GetRecords(arg1:gui.Config):Promise>; + +export function IsRunning():Promise; + +export function ListPrizes(arg1:gui.Config):Promise; + +export function PreviewAccounts(arg1:string):Promise>; + +export function QueryScores(arg1:gui.Config):Promise>; + +export function StartMonitor(arg1:gui.Config):Promise; + +export function StopMonitor():Promise; diff --git a/frontend/wailsjs/go/gui/App.js b/frontend/wailsjs/go/gui/App.js new file mode 100755 index 0000000..41c8a3a --- /dev/null +++ b/frontend/wailsjs/go/gui/App.js @@ -0,0 +1,43 @@ +// @ts-check +// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL +// This file is automatically generated. DO NOT EDIT + +export function DefaultConfig() { + return window['go']['gui']['App']['DefaultConfig'](); +} + +export function Exchange(arg1) { + return window['go']['gui']['App']['Exchange'](arg1); +} + +export function GetLogs() { + return window['go']['gui']['App']['GetLogs'](); +} + +export function GetRecords(arg1) { + return window['go']['gui']['App']['GetRecords'](arg1); +} + +export function IsRunning() { + return window['go']['gui']['App']['IsRunning'](); +} + +export function ListPrizes(arg1) { + return window['go']['gui']['App']['ListPrizes'](arg1); +} + +export function PreviewAccounts(arg1) { + return window['go']['gui']['App']['PreviewAccounts'](arg1); +} + +export function QueryScores(arg1) { + return window['go']['gui']['App']['QueryScores'](arg1); +} + +export function StartMonitor(arg1) { + return window['go']['gui']['App']['StartMonitor'](arg1); +} + +export function StopMonitor() { + return window['go']['gui']['App']['StopMonitor'](); +} diff --git a/frontend/wailsjs/go/models.ts b/frontend/wailsjs/go/models.ts new file mode 100755 index 0000000..aa368dc --- /dev/null +++ b/frontend/wailsjs/go/models.ts @@ -0,0 +1,488 @@ +export namespace gui { + + export class AccountPreview { + line: number; + uid: number; + valid: boolean; + error?: string; + + static createFrom(source: any = {}) { + return new AccountPreview(source); + } + + constructor(source: any = {}) { + if ('string' === typeof source) source = JSON.parse(source); + this.line = source["line"]; + this.uid = source["uid"]; + this.valid = source["valid"]; + this.error = source["error"]; + } + } + export class Config { + transport: string; + wssHost: string; + sid: number; + pid: number; + name: string; + cookieText: string; + loops: number; + delayMs: number; + concurrency: number; + stopAfterSuccess: boolean; + timeoutSec: number; + startAt: string; + + static createFrom(source: any = {}) { + return new Config(source); + } + + constructor(source: any = {}) { + if ('string' === typeof source) source = JSON.parse(source); + this.transport = source["transport"]; + this.wssHost = source["wssHost"]; + this.sid = source["sid"]; + this.pid = source["pid"]; + this.name = source["name"]; + this.cookieText = source["cookieText"]; + this.loops = source["loops"]; + this.delayMs = source["delayMs"]; + this.concurrency = source["concurrency"]; + this.stopAfterSuccess = source["stopAfterSuccess"]; + this.timeoutSec = source["timeoutSec"]; + this.startAt = source["startAt"]; + } + } + export class ExchangeResult { + uid: number; + resp?: huya.ScoreExchangePrizeResp; + error?: string; + + static createFrom(source: any = {}) { + return new ExchangeResult(source); + } + + constructor(source: any = {}) { + if ('string' === typeof source) source = JSON.parse(source); + this.uid = source["uid"]; + this.resp = this.convertValues(source["resp"], huya.ScoreExchangePrizeResp); + this.error = source["error"]; + } + + convertValues(a: any, classs: any, asMap: boolean = false): any { + if (!a) { + return a; + } + if (a.slice && a.map) { + return (a as any[]).map(elem => this.convertValues(elem, classs)); + } else if ("object" === typeof a) { + if (asMap) { + for (const key of Object.keys(a)) { + a[key] = new classs(a[key]); + } + return a; + } + return new classs(a); + } + return a; + } + } + export class LogEntry { + time: string; + level: string; + message: string; + + static createFrom(source: any = {}) { + return new LogEntry(source); + } + + constructor(source: any = {}) { + if ('string' === typeof source) source = JSON.parse(source); + this.time = source["time"]; + this.level = source["level"]; + this.message = source["message"]; + } + } + export class PrizeListResult { + uid: number; + status: number; + msg: string; + prizes: huya.PrizeInfo[]; + raw?: huya.GetActPrizeListResp; + + static createFrom(source: any = {}) { + return new PrizeListResult(source); + } + + constructor(source: any = {}) { + if ('string' === typeof source) source = JSON.parse(source); + this.uid = source["uid"]; + this.status = source["status"]; + this.msg = source["msg"]; + this.prizes = this.convertValues(source["prizes"], huya.PrizeInfo); + this.raw = this.convertValues(source["raw"], huya.GetActPrizeListResp); + } + + convertValues(a: any, classs: any, asMap: boolean = false): any { + if (!a) { + return a; + } + if (a.slice && a.map) { + return (a as any[]).map(elem => this.convertValues(elem, classs)); + } else if ("object" === typeof a) { + if (asMap) { + for (const key of Object.keys(a)) { + a[key] = new classs(a[key]); + } + return a; + } + return new classs(a); + } + return a; + } + } + export class RecordResult { + uid: number; + records: huya.UserPrizeInfo[]; + resp?: huya.GetUserPrizeRecordsResp; + error?: string; + + static createFrom(source: any = {}) { + return new RecordResult(source); + } + + constructor(source: any = {}) { + if ('string' === typeof source) source = JSON.parse(source); + this.uid = source["uid"]; + this.records = this.convertValues(source["records"], huya.UserPrizeInfo); + this.resp = this.convertValues(source["resp"], huya.GetUserPrizeRecordsResp); + this.error = source["error"]; + } + + convertValues(a: any, classs: any, asMap: boolean = false): any { + if (!a) { + return a; + } + if (a.slice && a.map) { + return (a as any[]).map(elem => this.convertValues(elem, classs)); + } else if ("object" === typeof a) { + if (asMap) { + for (const key of Object.keys(a)) { + a[key] = new classs(a[key]); + } + return a; + } + return new classs(a); + } + return a; + } + } + export class ScoreResult { + uid: number; + score: number; + resp?: huya.GetUserScoreResp; + error?: string; + + static createFrom(source: any = {}) { + return new ScoreResult(source); + } + + constructor(source: any = {}) { + if ('string' === typeof source) source = JSON.parse(source); + this.uid = source["uid"]; + this.score = source["score"]; + this.resp = this.convertValues(source["resp"], huya.GetUserScoreResp); + this.error = source["error"]; + } + + convertValues(a: any, classs: any, asMap: boolean = false): any { + if (!a) { + return a; + } + if (a.slice && a.map) { + return (a as any[]).map(elem => this.convertValues(elem, classs)); + } else if ("object" === typeof a) { + if (asMap) { + for (const key of Object.keys(a)) { + a[key] = new classs(a[key]); + } + return a; + } + return new classs(a); + } + return a; + } + } + +} + +export namespace huya { + + export class ActPreCondition { + condition_type: number; + condition_params?: Record; + tip?: string; + jump_url?: string; + button_desc?: string; + + static createFrom(source: any = {}) { + return new ActPreCondition(source); + } + + constructor(source: any = {}) { + if ('string' === typeof source) source = JSON.parse(source); + this.condition_type = source["condition_type"]; + this.condition_params = source["condition_params"]; + this.tip = source["tip"]; + this.jump_url = source["jump_url"]; + this.button_desc = source["button_desc"]; + } + } + export class ExchangeInfo { + pid: number; + exchange_score: number; + desc: string; + + static createFrom(source: any = {}) { + return new ExchangeInfo(source); + } + + constructor(source: any = {}) { + if ('string' === typeof source) source = JSON.parse(source); + this.pid = source["pid"]; + this.exchange_score = source["exchange_score"]; + this.desc = source["desc"]; + } + } + export class PrizeTag { + id: number; + name: string; + weight: number; + + static createFrom(source: any = {}) { + return new PrizeTag(source); + } + + constructor(source: any = {}) { + if ('string' === typeof source) source = JSON.parse(source); + this.id = source["id"]; + this.name = source["name"]; + this.weight = source["weight"]; + } + } + export class PrizeInfo { + id: number; + sid: number; + name: string; + score: number; + type: number; + img?: string; + sort: number; + frequency: number; + frequency_limit: number; + create_time: number; + num: number; + status: number; + percent: string; + new_score: number; + tags?: string; + left_num: number; + is_show_num: number; + + static createFrom(source: any = {}) { + return new PrizeInfo(source); + } + + constructor(source: any = {}) { + if ('string' === typeof source) source = JSON.parse(source); + this.id = source["id"]; + this.sid = source["sid"]; + this.name = source["name"]; + this.score = source["score"]; + this.type = source["type"]; + this.img = source["img"]; + this.sort = source["sort"]; + this.frequency = source["frequency"]; + this.frequency_limit = source["frequency_limit"]; + this.create_time = source["create_time"]; + this.num = source["num"]; + this.status = source["status"]; + this.percent = source["percent"]; + this.new_score = source["new_score"]; + this.tags = source["tags"]; + this.left_num = source["left_num"]; + this.is_show_num = source["is_show_num"]; + } + } + export class GetActPrizeListResp { + status: number; + msg: string; + prizes: PrizeInfo[]; + module_id: number; + tags: PrizeTag[]; + + static createFrom(source: any = {}) { + return new GetActPrizeListResp(source); + } + + constructor(source: any = {}) { + if ('string' === typeof source) source = JSON.parse(source); + this.status = source["status"]; + this.msg = source["msg"]; + this.prizes = this.convertValues(source["prizes"], PrizeInfo); + this.module_id = source["module_id"]; + this.tags = this.convertValues(source["tags"], PrizeTag); + } + + convertValues(a: any, classs: any, asMap: boolean = false): any { + if (!a) { + return a; + } + if (a.slice && a.map) { + return (a as any[]).map(elem => this.convertValues(elem, classs)); + } else if ("object" === typeof a) { + if (asMap) { + for (const key of Object.keys(a)) { + a[key] = new classs(a[key]); + } + return a; + } + return new classs(a); + } + return a; + } + } + export class UserPrizeInfo { + id: number; + name: string; + score: number; + create_time: number; + status: number; + type: number; + is_real: number; + new_score: number; + account?: string; + code?: string; + common_prize_type: number; + + static createFrom(source: any = {}) { + return new UserPrizeInfo(source); + } + + constructor(source: any = {}) { + if ('string' === typeof source) source = JSON.parse(source); + this.id = source["id"]; + this.name = source["name"]; + this.score = source["score"]; + this.create_time = source["create_time"]; + this.status = source["status"]; + this.type = source["type"]; + this.is_real = source["is_real"]; + this.new_score = source["new_score"]; + this.account = source["account"]; + this.code = source["code"]; + this.common_prize_type = source["common_prize_type"]; + } + } + export class GetUserPrizeRecordsResp { + status: number; + msg: string; + records: UserPrizeInfo[]; + + static createFrom(source: any = {}) { + return new GetUserPrizeRecordsResp(source); + } + + constructor(source: any = {}) { + if ('string' === typeof source) source = JSON.parse(source); + this.status = source["status"]; + this.msg = source["msg"]; + this.records = this.convertValues(source["records"], UserPrizeInfo); + } + + convertValues(a: any, classs: any, asMap: boolean = false): any { + if (!a) { + return a; + } + if (a.slice && a.map) { + return (a as any[]).map(elem => this.convertValues(elem, classs)); + } else if ("object" === typeof a) { + if (asMap) { + for (const key of Object.keys(a)) { + a[key] = new classs(a[key]); + } + return a; + } + return new classs(a); + } + return a; + } + } + export class GetUserScoreResp { + status: number; + msg: string; + gain_score: number; + used_score: number; + new_gain_score: number; + new_used_score: number; + score: number; + is_open_exchange_tip: number; + + static createFrom(source: any = {}) { + return new GetUserScoreResp(source); + } + + constructor(source: any = {}) { + if ('string' === typeof source) source = JSON.parse(source); + this.status = source["status"]; + this.msg = source["msg"]; + this.gain_score = source["gain_score"]; + this.used_score = source["used_score"]; + this.new_gain_score = source["new_gain_score"]; + this.new_used_score = source["new_used_score"]; + this.score = source["score"]; + this.is_open_exchange_tip = source["is_open_exchange_tip"]; + } + } + + + export class ScoreExchangePrizeResp { + status: number; + msg: string; + order_id?: string; + exchange_info: ExchangeInfo; + act_pre_condition: ActPreCondition; + + static createFrom(source: any = {}) { + return new ScoreExchangePrizeResp(source); + } + + constructor(source: any = {}) { + if ('string' === typeof source) source = JSON.parse(source); + this.status = source["status"]; + this.msg = source["msg"]; + this.order_id = source["order_id"]; + this.exchange_info = this.convertValues(source["exchange_info"], ExchangeInfo); + this.act_pre_condition = this.convertValues(source["act_pre_condition"], ActPreCondition); + } + + convertValues(a: any, classs: any, asMap: boolean = false): any { + if (!a) { + return a; + } + if (a.slice && a.map) { + return (a as any[]).map(elem => this.convertValues(elem, classs)); + } else if ("object" === typeof a) { + if (asMap) { + for (const key of Object.keys(a)) { + a[key] = new classs(a[key]); + } + return a; + } + return new classs(a); + } + return a; + } + } + +} + diff --git a/frontend/wailsjs/runtime/package.json b/frontend/wailsjs/runtime/package.json new file mode 100644 index 0000000..1e7c8a5 --- /dev/null +++ b/frontend/wailsjs/runtime/package.json @@ -0,0 +1,24 @@ +{ + "name": "@wailsapp/runtime", + "version": "2.0.0", + "description": "Wails Javascript runtime library", + "main": "runtime.js", + "types": "runtime.d.ts", + "scripts": { + }, + "repository": { + "type": "git", + "url": "git+https://github.com/wailsapp/wails.git" + }, + "keywords": [ + "Wails", + "Javascript", + "Go" + ], + "author": "Lea Anthony ", + "license": "MIT", + "bugs": { + "url": "https://github.com/wailsapp/wails/issues" + }, + "homepage": "https://github.com/wailsapp/wails#readme" +} diff --git a/frontend/wailsjs/runtime/runtime.d.ts b/frontend/wailsjs/runtime/runtime.d.ts new file mode 100644 index 0000000..3bbea84 --- /dev/null +++ b/frontend/wailsjs/runtime/runtime.d.ts @@ -0,0 +1,330 @@ +/* + _ __ _ __ +| | / /___ _(_) /____ +| | /| / / __ `/ / / ___/ +| |/ |/ / /_/ / / (__ ) +|__/|__/\__,_/_/_/____/ +The electron alternative for Go +(c) Lea Anthony 2019-present +*/ + +export interface Position { + x: number; + y: number; +} + +export interface Size { + w: number; + h: number; +} + +export interface Screen { + isCurrent: boolean; + isPrimary: boolean; + width : number + height : number +} + +// Environment information such as platform, buildtype, ... +export interface EnvironmentInfo { + buildType: string; + platform: string; + arch: string; +} + +// [EventsEmit](https://wails.io/docs/reference/runtime/events#eventsemit) +// emits the given event. Optional data may be passed with the event. +// This will trigger any event listeners. +export function EventsEmit(eventName: string, ...data: any): void; + +// [EventsOn](https://wails.io/docs/reference/runtime/events#eventson) sets up a listener for the given event name. +export function EventsOn(eventName: string, callback: (...data: any) => void): () => void; + +// [EventsOnMultiple](https://wails.io/docs/reference/runtime/events#eventsonmultiple) +// sets up a listener for the given event name, but will only trigger a given number times. +export function EventsOnMultiple(eventName: string, callback: (...data: any) => void, maxCallbacks: number): () => void; + +// [EventsOnce](https://wails.io/docs/reference/runtime/events#eventsonce) +// sets up a listener for the given event name, but will only trigger once. +export function EventsOnce(eventName: string, callback: (...data: any) => void): () => void; + +// [EventsOff](https://wails.io/docs/reference/runtime/events#eventsoff) +// unregisters the listener for the given event name. +export function EventsOff(eventName: string, ...additionalEventNames: string[]): void; + +// [EventsOffAll](https://wails.io/docs/reference/runtime/events#eventsoffall) +// unregisters all listeners. +export function EventsOffAll(): void; + +// [LogPrint](https://wails.io/docs/reference/runtime/log#logprint) +// logs the given message as a raw message +export function LogPrint(message: string): void; + +// [LogTrace](https://wails.io/docs/reference/runtime/log#logtrace) +// logs the given message at the `trace` log level. +export function LogTrace(message: string): void; + +// [LogDebug](https://wails.io/docs/reference/runtime/log#logdebug) +// logs the given message at the `debug` log level. +export function LogDebug(message: string): void; + +// [LogError](https://wails.io/docs/reference/runtime/log#logerror) +// logs the given message at the `error` log level. +export function LogError(message: string): void; + +// [LogFatal](https://wails.io/docs/reference/runtime/log#logfatal) +// logs the given message at the `fatal` log level. +// The application will quit after calling this method. +export function LogFatal(message: string): void; + +// [LogInfo](https://wails.io/docs/reference/runtime/log#loginfo) +// logs the given message at the `info` log level. +export function LogInfo(message: string): void; + +// [LogWarning](https://wails.io/docs/reference/runtime/log#logwarning) +// logs the given message at the `warning` log level. +export function LogWarning(message: string): void; + +// [WindowReload](https://wails.io/docs/reference/runtime/window#windowreload) +// Forces a reload by the main application as well as connected browsers. +export function WindowReload(): void; + +// [WindowReloadApp](https://wails.io/docs/reference/runtime/window#windowreloadapp) +// Reloads the application frontend. +export function WindowReloadApp(): void; + +// [WindowSetAlwaysOnTop](https://wails.io/docs/reference/runtime/window#windowsetalwaysontop) +// Sets the window AlwaysOnTop or not on top. +export function WindowSetAlwaysOnTop(b: boolean): void; + +// [WindowSetSystemDefaultTheme](https://wails.io/docs/next/reference/runtime/window#windowsetsystemdefaulttheme) +// *Windows only* +// Sets window theme to system default (dark/light). +export function WindowSetSystemDefaultTheme(): void; + +// [WindowSetLightTheme](https://wails.io/docs/next/reference/runtime/window#windowsetlighttheme) +// *Windows only* +// Sets window to light theme. +export function WindowSetLightTheme(): void; + +// [WindowSetDarkTheme](https://wails.io/docs/next/reference/runtime/window#windowsetdarktheme) +// *Windows only* +// Sets window to dark theme. +export function WindowSetDarkTheme(): void; + +// [WindowCenter](https://wails.io/docs/reference/runtime/window#windowcenter) +// Centers the window on the monitor the window is currently on. +export function WindowCenter(): void; + +// [WindowSetTitle](https://wails.io/docs/reference/runtime/window#windowsettitle) +// Sets the text in the window title bar. +export function WindowSetTitle(title: string): void; + +// [WindowFullscreen](https://wails.io/docs/reference/runtime/window#windowfullscreen) +// Makes the window full screen. +export function WindowFullscreen(): void; + +// [WindowUnfullscreen](https://wails.io/docs/reference/runtime/window#windowunfullscreen) +// Restores the previous window dimensions and position prior to full screen. +export function WindowUnfullscreen(): void; + +// [WindowIsFullscreen](https://wails.io/docs/reference/runtime/window#windowisfullscreen) +// Returns the state of the window, i.e. whether the window is in full screen mode or not. +export function WindowIsFullscreen(): Promise; + +// [WindowSetSize](https://wails.io/docs/reference/runtime/window#windowsetsize) +// Sets the width and height of the window. +export function WindowSetSize(width: number, height: number): void; + +// [WindowGetSize](https://wails.io/docs/reference/runtime/window#windowgetsize) +// Gets the width and height of the window. +export function WindowGetSize(): Promise; + +// [WindowSetMaxSize](https://wails.io/docs/reference/runtime/window#windowsetmaxsize) +// Sets the maximum window size. Will resize the window if the window is currently larger than the given dimensions. +// Setting a size of 0,0 will disable this constraint. +export function WindowSetMaxSize(width: number, height: number): void; + +// [WindowSetMinSize](https://wails.io/docs/reference/runtime/window#windowsetminsize) +// Sets the minimum window size. Will resize the window if the window is currently smaller than the given dimensions. +// Setting a size of 0,0 will disable this constraint. +export function WindowSetMinSize(width: number, height: number): void; + +// [WindowSetPosition](https://wails.io/docs/reference/runtime/window#windowsetposition) +// Sets the window position relative to the monitor the window is currently on. +export function WindowSetPosition(x: number, y: number): void; + +// [WindowGetPosition](https://wails.io/docs/reference/runtime/window#windowgetposition) +// Gets the window position relative to the monitor the window is currently on. +export function WindowGetPosition(): Promise; + +// [WindowHide](https://wails.io/docs/reference/runtime/window#windowhide) +// Hides the window. +export function WindowHide(): void; + +// [WindowShow](https://wails.io/docs/reference/runtime/window#windowshow) +// Shows the window, if it is currently hidden. +export function WindowShow(): void; + +// [WindowMaximise](https://wails.io/docs/reference/runtime/window#windowmaximise) +// Maximises the window to fill the screen. +export function WindowMaximise(): void; + +// [WindowToggleMaximise](https://wails.io/docs/reference/runtime/window#windowtogglemaximise) +// Toggles between Maximised and UnMaximised. +export function WindowToggleMaximise(): void; + +// [WindowUnmaximise](https://wails.io/docs/reference/runtime/window#windowunmaximise) +// Restores the window to the dimensions and position prior to maximising. +export function WindowUnmaximise(): void; + +// [WindowIsMaximised](https://wails.io/docs/reference/runtime/window#windowismaximised) +// Returns the state of the window, i.e. whether the window is maximised or not. +export function WindowIsMaximised(): Promise; + +// [WindowMinimise](https://wails.io/docs/reference/runtime/window#windowminimise) +// Minimises the window. +export function WindowMinimise(): void; + +// [WindowUnminimise](https://wails.io/docs/reference/runtime/window#windowunminimise) +// Restores the window to the dimensions and position prior to minimising. +export function WindowUnminimise(): void; + +// [WindowIsMinimised](https://wails.io/docs/reference/runtime/window#windowisminimised) +// Returns the state of the window, i.e. whether the window is minimised or not. +export function WindowIsMinimised(): Promise; + +// [WindowIsNormal](https://wails.io/docs/reference/runtime/window#windowisnormal) +// Returns the state of the window, i.e. whether the window is normal or not. +export function WindowIsNormal(): Promise; + +// [WindowSetBackgroundColour](https://wails.io/docs/reference/runtime/window#windowsetbackgroundcolour) +// Sets the background colour of the window to the given RGBA colour definition. This colour will show through for all transparent pixels. +export function WindowSetBackgroundColour(R: number, G: number, B: number, A: number): void; + +// [ScreenGetAll](https://wails.io/docs/reference/runtime/window#screengetall) +// Gets the all screens. Call this anew each time you want to refresh data from the underlying windowing system. +export function ScreenGetAll(): Promise; + +// [BrowserOpenURL](https://wails.io/docs/reference/runtime/browser#browseropenurl) +// Opens the given URL in the system browser. +export function BrowserOpenURL(url: string): void; + +// [Environment](https://wails.io/docs/reference/runtime/intro#environment) +// Returns information about the environment +export function Environment(): Promise; + +// [Quit](https://wails.io/docs/reference/runtime/intro#quit) +// Quits the application. +export function Quit(): void; + +// [Hide](https://wails.io/docs/reference/runtime/intro#hide) +// Hides the application. +export function Hide(): void; + +// [Show](https://wails.io/docs/reference/runtime/intro#show) +// Shows the application. +export function Show(): void; + +// [ClipboardGetText](https://wails.io/docs/reference/runtime/clipboard#clipboardgettext) +// Returns the current text stored on clipboard +export function ClipboardGetText(): Promise; + +// [ClipboardSetText](https://wails.io/docs/reference/runtime/clipboard#clipboardsettext) +// Sets a text on the clipboard +export function ClipboardSetText(text: string): Promise; + +// [OnFileDrop](https://wails.io/docs/reference/runtime/draganddrop#onfiledrop) +// OnFileDrop listens to drag and drop events and calls the callback with the coordinates of the drop and an array of path strings. +export function OnFileDrop(callback: (x: number, y: number ,paths: string[]) => void, useDropTarget: boolean) :void + +// [OnFileDropOff](https://wails.io/docs/reference/runtime/draganddrop#dragandddropoff) +// OnFileDropOff removes the drag and drop listeners and handlers. +export function OnFileDropOff() :void + +// Check if the file path resolver is available +export function CanResolveFilePaths(): boolean; + +// Resolves file paths for an array of files +export function ResolveFilePaths(files: File[]): void + +// Notification types +export interface NotificationOptions { + id: string; + title: string; + subtitle?: string; // macOS and Linux only + body?: string; + categoryId?: string; + data?: { [key: string]: any }; +} + +export interface NotificationAction { + id?: string; + title?: string; + destructive?: boolean; // macOS-specific +} + +export interface NotificationCategory { + id?: string; + actions?: NotificationAction[]; + hasReplyField?: boolean; + replyPlaceholder?: string; + replyButtonTitle?: string; +} + +// [InitializeNotifications](https://wails.io/docs/reference/runtime/notification#initializenotifications) +// Initializes the notification service for the application. +// This must be called before sending any notifications. +export function InitializeNotifications(): Promise; + +// [CleanupNotifications](https://wails.io/docs/reference/runtime/notification#cleanupnotifications) +// Cleans up notification resources and releases any held connections. +export function CleanupNotifications(): Promise; + +// [IsNotificationAvailable](https://wails.io/docs/reference/runtime/notification#isnotificationavailable) +// Checks if notifications are available on the current platform. +export function IsNotificationAvailable(): Promise; + +// [RequestNotificationAuthorization](https://wails.io/docs/reference/runtime/notification#requestnotificationauthorization) +// Requests notification authorization from the user (macOS only). +export function RequestNotificationAuthorization(): Promise; + +// [CheckNotificationAuthorization](https://wails.io/docs/reference/runtime/notification#checknotificationauthorization) +// Checks the current notification authorization status (macOS only). +export function CheckNotificationAuthorization(): Promise; + +// [SendNotification](https://wails.io/docs/reference/runtime/notification#sendnotification) +// Sends a basic notification with the given options. +export function SendNotification(options: NotificationOptions): Promise; + +// [SendNotificationWithActions](https://wails.io/docs/reference/runtime/notification#sendnotificationwithactions) +// Sends a notification with action buttons. Requires a registered category. +export function SendNotificationWithActions(options: NotificationOptions): Promise; + +// [RegisterNotificationCategory](https://wails.io/docs/reference/runtime/notification#registernotificationcategory) +// Registers a notification category that can be used with SendNotificationWithActions. +export function RegisterNotificationCategory(category: NotificationCategory): Promise; + +// [RemoveNotificationCategory](https://wails.io/docs/reference/runtime/notification#removenotificationcategory) +// Removes a previously registered notification category. +export function RemoveNotificationCategory(categoryId: string): Promise; + +// [RemoveAllPendingNotifications](https://wails.io/docs/reference/runtime/notification#removeallpendingnotifications) +// Removes all pending notifications from the notification center. +export function RemoveAllPendingNotifications(): Promise; + +// [RemovePendingNotification](https://wails.io/docs/reference/runtime/notification#removependingnotification) +// Removes a specific pending notification by its identifier. +export function RemovePendingNotification(identifier: string): Promise; + +// [RemoveAllDeliveredNotifications](https://wails.io/docs/reference/runtime/notification#removealldeliverednotifications) +// Removes all delivered notifications from the notification center. +export function RemoveAllDeliveredNotifications(): Promise; + +// [RemoveDeliveredNotification](https://wails.io/docs/reference/runtime/notification#removedeliverednotification) +// Removes a specific delivered notification by its identifier. +export function RemoveDeliveredNotification(identifier: string): Promise; + +// [RemoveNotification](https://wails.io/docs/reference/runtime/notification#removenotification) +// Removes a notification by its identifier (cross-platform convenience function). +export function RemoveNotification(identifier: string): Promise; \ No newline at end of file diff --git a/frontend/wailsjs/runtime/runtime.js b/frontend/wailsjs/runtime/runtime.js new file mode 100644 index 0000000..556621e --- /dev/null +++ b/frontend/wailsjs/runtime/runtime.js @@ -0,0 +1,298 @@ +/* + _ __ _ __ +| | / /___ _(_) /____ +| | /| / / __ `/ / / ___/ +| |/ |/ / /_/ / / (__ ) +|__/|__/\__,_/_/_/____/ +The electron alternative for Go +(c) Lea Anthony 2019-present +*/ + +export function LogPrint(message) { + window.runtime.LogPrint(message); +} + +export function LogTrace(message) { + window.runtime.LogTrace(message); +} + +export function LogDebug(message) { + window.runtime.LogDebug(message); +} + +export function LogInfo(message) { + window.runtime.LogInfo(message); +} + +export function LogWarning(message) { + window.runtime.LogWarning(message); +} + +export function LogError(message) { + window.runtime.LogError(message); +} + +export function LogFatal(message) { + window.runtime.LogFatal(message); +} + +export function EventsOnMultiple(eventName, callback, maxCallbacks) { + return window.runtime.EventsOnMultiple(eventName, callback, maxCallbacks); +} + +export function EventsOn(eventName, callback) { + return EventsOnMultiple(eventName, callback, -1); +} + +export function EventsOff(eventName, ...additionalEventNames) { + return window.runtime.EventsOff(eventName, ...additionalEventNames); +} + +export function EventsOffAll() { + return window.runtime.EventsOffAll(); +} + +export function EventsOnce(eventName, callback) { + return EventsOnMultiple(eventName, callback, 1); +} + +export function EventsEmit(eventName) { + let args = [eventName].slice.call(arguments); + return window.runtime.EventsEmit.apply(null, args); +} + +export function WindowReload() { + window.runtime.WindowReload(); +} + +export function WindowReloadApp() { + window.runtime.WindowReloadApp(); +} + +export function WindowSetAlwaysOnTop(b) { + window.runtime.WindowSetAlwaysOnTop(b); +} + +export function WindowSetSystemDefaultTheme() { + window.runtime.WindowSetSystemDefaultTheme(); +} + +export function WindowSetLightTheme() { + window.runtime.WindowSetLightTheme(); +} + +export function WindowSetDarkTheme() { + window.runtime.WindowSetDarkTheme(); +} + +export function WindowCenter() { + window.runtime.WindowCenter(); +} + +export function WindowSetTitle(title) { + window.runtime.WindowSetTitle(title); +} + +export function WindowFullscreen() { + window.runtime.WindowFullscreen(); +} + +export function WindowUnfullscreen() { + window.runtime.WindowUnfullscreen(); +} + +export function WindowIsFullscreen() { + return window.runtime.WindowIsFullscreen(); +} + +export function WindowGetSize() { + return window.runtime.WindowGetSize(); +} + +export function WindowSetSize(width, height) { + window.runtime.WindowSetSize(width, height); +} + +export function WindowSetMaxSize(width, height) { + window.runtime.WindowSetMaxSize(width, height); +} + +export function WindowSetMinSize(width, height) { + window.runtime.WindowSetMinSize(width, height); +} + +export function WindowSetPosition(x, y) { + window.runtime.WindowSetPosition(x, y); +} + +export function WindowGetPosition() { + return window.runtime.WindowGetPosition(); +} + +export function WindowHide() { + window.runtime.WindowHide(); +} + +export function WindowShow() { + window.runtime.WindowShow(); +} + +export function WindowMaximise() { + window.runtime.WindowMaximise(); +} + +export function WindowToggleMaximise() { + window.runtime.WindowToggleMaximise(); +} + +export function WindowUnmaximise() { + window.runtime.WindowUnmaximise(); +} + +export function WindowIsMaximised() { + return window.runtime.WindowIsMaximised(); +} + +export function WindowMinimise() { + window.runtime.WindowMinimise(); +} + +export function WindowUnminimise() { + window.runtime.WindowUnminimise(); +} + +export function WindowSetBackgroundColour(R, G, B, A) { + window.runtime.WindowSetBackgroundColour(R, G, B, A); +} + +export function ScreenGetAll() { + return window.runtime.ScreenGetAll(); +} + +export function WindowIsMinimised() { + return window.runtime.WindowIsMinimised(); +} + +export function WindowIsNormal() { + return window.runtime.WindowIsNormal(); +} + +export function BrowserOpenURL(url) { + window.runtime.BrowserOpenURL(url); +} + +export function Environment() { + return window.runtime.Environment(); +} + +export function Quit() { + window.runtime.Quit(); +} + +export function Hide() { + window.runtime.Hide(); +} + +export function Show() { + window.runtime.Show(); +} + +export function ClipboardGetText() { + return window.runtime.ClipboardGetText(); +} + +export function ClipboardSetText(text) { + return window.runtime.ClipboardSetText(text); +} + +/** + * Callback for OnFileDrop returns a slice of file path strings when a drop is finished. + * + * @export + * @callback OnFileDropCallback + * @param {number} x - x coordinate of the drop + * @param {number} y - y coordinate of the drop + * @param {string[]} paths - A list of file paths. + */ + +/** + * OnFileDrop listens to drag and drop events and calls the callback with the coordinates of the drop and an array of path strings. + * + * @export + * @param {OnFileDropCallback} callback - Callback for OnFileDrop returns a slice of file path strings when a drop is finished. + * @param {boolean} [useDropTarget=true] - Only call the callback when the drop finished on an element that has the drop target style. (--wails-drop-target) + */ +export function OnFileDrop(callback, useDropTarget) { + return window.runtime.OnFileDrop(callback, useDropTarget); +} + +/** + * OnFileDropOff removes the drag and drop listeners and handlers. + */ +export function OnFileDropOff() { + return window.runtime.OnFileDropOff(); +} + +export function CanResolveFilePaths() { + return window.runtime.CanResolveFilePaths(); +} + +export function ResolveFilePaths(files) { + return window.runtime.ResolveFilePaths(files); +} + +export function InitializeNotifications() { + return window.runtime.InitializeNotifications(); +} + +export function CleanupNotifications() { + return window.runtime.CleanupNotifications(); +} + +export function IsNotificationAvailable() { + return window.runtime.IsNotificationAvailable(); +} + +export function RequestNotificationAuthorization() { + return window.runtime.RequestNotificationAuthorization(); +} + +export function CheckNotificationAuthorization() { + return window.runtime.CheckNotificationAuthorization(); +} + +export function SendNotification(options) { + return window.runtime.SendNotification(options); +} + +export function SendNotificationWithActions(options) { + return window.runtime.SendNotificationWithActions(options); +} + +export function RegisterNotificationCategory(category) { + return window.runtime.RegisterNotificationCategory(category); +} + +export function RemoveNotificationCategory(categoryId) { + return window.runtime.RemoveNotificationCategory(categoryId); +} + +export function RemoveAllPendingNotifications() { + return window.runtime.RemoveAllPendingNotifications(); +} + +export function RemovePendingNotification(identifier) { + return window.runtime.RemovePendingNotification(identifier); +} + +export function RemoveAllDeliveredNotifications() { + return window.runtime.RemoveAllDeliveredNotifications(); +} + +export function RemoveDeliveredNotification(identifier) { + return window.runtime.RemoveDeliveredNotification(identifier); +} + +export function RemoveNotification(identifier) { + return window.runtime.RemoveNotification(identifier); +} \ No newline at end of file diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..759096f --- /dev/null +++ b/go.mod @@ -0,0 +1,38 @@ +module huya-go + +go 1.26 + +require ( + github.com/gorilla/websocket v1.5.3 + github.com/wailsapp/wails/v2 v2.12.0 +) + +require ( + git.sr.ht/~jackmordaunt/go-toast/v2 v2.0.3 // indirect + github.com/bep/debounce v1.2.1 // indirect + github.com/go-ole/go-ole v1.3.0 // indirect + github.com/godbus/dbus/v5 v5.1.0 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e // indirect + github.com/labstack/echo/v4 v4.13.3 // indirect + github.com/labstack/gommon v0.4.2 // indirect + github.com/leaanthony/go-ansi-parser v1.6.1 // indirect + github.com/leaanthony/gosod v1.0.4 // indirect + github.com/leaanthony/slicer v1.6.0 // indirect + github.com/leaanthony/u v1.1.1 // indirect + github.com/mattn/go-colorable v0.1.13 // indirect + github.com/mattn/go-isatty v0.0.20 // indirect + github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirect + github.com/pkg/errors v0.9.1 // indirect + github.com/rivo/uniseg v0.4.7 // indirect + github.com/samber/lo v1.49.1 // indirect + github.com/tkrajina/go-reflector v0.5.8 // indirect + github.com/valyala/bytebufferpool v1.0.0 // indirect + github.com/valyala/fasttemplate v1.2.2 // indirect + github.com/wailsapp/go-webview2 v1.0.22 // indirect + github.com/wailsapp/mimetype v1.4.1 // indirect + golang.org/x/crypto v0.33.0 // indirect + golang.org/x/net v0.35.0 // indirect + golang.org/x/sys v0.30.0 // indirect + golang.org/x/text v0.22.0 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..b5aa9ee --- /dev/null +++ b/go.sum @@ -0,0 +1,83 @@ +git.sr.ht/~jackmordaunt/go-toast/v2 v2.0.3 h1:N3IGoHHp9pb6mj1cbXbuaSXV/UMKwmbKLf53nQmtqMA= +git.sr.ht/~jackmordaunt/go-toast/v2 v2.0.3/go.mod h1:QtOLZGz8olr4qH2vWK0QH0w0O4T9fEIjMuWpKUsH7nc= +github.com/bep/debounce v1.2.1 h1:v67fRdBA9UQu2NhLFXrSg0Brw7CexQekrBwDMM8bzeY= +github.com/bep/debounce v1.2.1/go.mod h1:H8yggRPQKLUhUoqrJC1bO2xNya7vanpDl7xR3ISbCJ0= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= +github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= +github.com/godbus/dbus/v5 v5.1.0 h1:4KLkAxT3aOY8Li4FRJe/KvhoNFFxo0m6fNuFUO8QJUk= +github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= +github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e h1:Q3+PugElBCf4PFpxhErSzU3/PY5sFL5Z6rfv4AbGAck= +github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e/go.mod h1:alcuEEnZsY1WQsagKhZDsoPCRoOijYqhZvPwLG0kzVs= +github.com/labstack/echo/v4 v4.13.3 h1:pwhpCPrTl5qry5HRdM5FwdXnhXSLSY+WE+YQSeCaafY= +github.com/labstack/echo/v4 v4.13.3/go.mod h1:o90YNEeQWjDozo584l7AwhJMHN0bOC4tAfg+Xox9q5g= +github.com/labstack/gommon v0.4.2 h1:F8qTUNXgG1+6WQmqoUWnz8WiEU60mXVVw0P4ht1WRA0= +github.com/labstack/gommon v0.4.2/go.mod h1:QlUFxVM+SNXhDL/Z7YhocGIBYOiwB0mXm1+1bAPHPyU= +github.com/leaanthony/debme v1.2.1 h1:9Tgwf+kjcrbMQ4WnPcEIUcQuIZYqdWftzZkBr+i/oOc= +github.com/leaanthony/debme v1.2.1/go.mod h1:3V+sCm5tYAgQymvSOfYQ5Xx2JCr+OXiD9Jkw3otUjiA= +github.com/leaanthony/go-ansi-parser v1.6.1 h1:xd8bzARK3dErqkPFtoF9F3/HgN8UQk0ed1YDKpEz01A= +github.com/leaanthony/go-ansi-parser v1.6.1/go.mod h1:+vva/2y4alzVmmIEpk9QDhA7vLC5zKDTRwfZGOp3IWU= +github.com/leaanthony/gosod v1.0.4 h1:YLAbVyd591MRffDgxUOU1NwLhT9T1/YiwjKZpkNFeaI= +github.com/leaanthony/gosod v1.0.4/go.mod h1:GKuIL0zzPj3O1SdWQOdgURSuhkF+Urizzxh26t9f1cw= +github.com/leaanthony/slicer v1.6.0 h1:1RFP5uiPJvT93TAHi+ipd3NACobkW53yUiBqZheE/Js= +github.com/leaanthony/slicer v1.6.0/go.mod h1:o/Iz29g7LN0GqH3aMjWAe90381nyZlDNquK+mtH2Fj8= +github.com/leaanthony/u v1.1.1 h1:TUFjwDGlNX+WuwVEzDqQwC2lOv0P4uhTQw7CMFdiK7M= +github.com/leaanthony/u v1.1.1/go.mod h1:9+o6hejoRljvZ3BzdYlVL0JYCwtnAsVuN9pVTQcaRfI= +github.com/matryer/is v1.4.0/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU= +github.com/matryer/is v1.4.1 h1:55ehd8zaGABKLXQUe2awZ99BD/PTc2ls+KV/dXphgEQ= +github.com/matryer/is v1.4.1/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU= +github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= +github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= +github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ= +github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= +github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ= +github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= +github.com/samber/lo v1.49.1 h1:4BIFyVfuQSEpluc7Fua+j1NolZHiEHEpaSEKdsH0tew= +github.com/samber/lo v1.49.1/go.mod h1:dO6KHFzUKXgP8LDhU0oI8d2hekjXnGOu0DB8Jecxd6o= +github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/tkrajina/go-reflector v0.5.8 h1:yPADHrwmUbMq4RGEyaOUpz2H90sRsETNVpjzo3DLVQQ= +github.com/tkrajina/go-reflector v0.5.8/go.mod h1:ECbqLgccecY5kPmPmXg1MrHW585yMcDkVl6IvJe64T4= +github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw= +github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= +github.com/valyala/fasttemplate v1.2.2 h1:lxLXG0uE3Qnshl9QyaK6XJxMXlQZELvChBOCmQD0Loo= +github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ= +github.com/wailsapp/go-webview2 v1.0.22 h1:YT61F5lj+GGaat5OB96Aa3b4QA+mybD0Ggq6NZijQ58= +github.com/wailsapp/go-webview2 v1.0.22/go.mod h1:qJmWAmAmaniuKGZPWwne+uor3AHMB5PFhqiK0Bbj8kc= +github.com/wailsapp/mimetype v1.4.1 h1:pQN9ycO7uo4vsUUuPeHEYoUkLVkaRntMnHJxVwYhwHs= +github.com/wailsapp/mimetype v1.4.1/go.mod h1:9aV5k31bBOv5z6u+QP8TltzvNGJPmNJD4XlAL3U+j3o= +github.com/wailsapp/wails/v2 v2.12.0 h1:BHO/kLNWFHYjCzucxbzAYZWUjub1Tvb4cSguQozHn5c= +github.com/wailsapp/wails/v2 v2.12.0/go.mod h1:mo1bzK1DEJrobt7YrBjgxvb5Sihb1mhAY09hppbibQg= +golang.org/x/crypto v0.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus= +golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M= +golang.org/x/net v0.0.0-20210505024714-0287a6fb4125/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.35.0 h1:T5GQRQb2y08kTAByq9L4/bz8cipCdA8FbRTXewonqY8= +golang.org/x/net v0.35.0/go.mod h1:EglIi67kWsHKlRzzVMUD93VMSWGFOMSZgxFjparz1Qk= +golang.org/x/sys v0.0.0-20200810151505-1b9f1253b3ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc= +golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM= +golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/internal/gui/app.go b/internal/gui/app.go new file mode 100644 index 0000000..b596c7d --- /dev/null +++ b/internal/gui/app.go @@ -0,0 +1,518 @@ +package gui + +import ( + "context" + "errors" + "fmt" + "strconv" + "strings" + "sync" + "time" + + "github.com/wailsapp/wails/v2/pkg/runtime" + + "huya-go/internal/huya" + "huya-go/internal/sniper" +) + +const ( + eventLog = "gui:log" + eventMonitorResult = "gui:monitor-result" + eventMonitorState = "gui:monitor-state" + maxLogEntries = 500 +) + +type App struct { + ctx context.Context + + logMu sync.Mutex + logs []LogEntry + + runMu sync.Mutex + monitorCancel context.CancelFunc + monitorRunning bool +} + +type Config struct { + Transport string `json:"transport"` + WSSHost string `json:"wssHost"` + SID int32 `json:"sid"` + PID int32 `json:"pid"` + Name string `json:"name"` + CookieText string `json:"cookieText"` + Loops int `json:"loops"` + DelayMS int `json:"delayMs"` + Concurrency int `json:"concurrency"` + StopAfterSuccess bool `json:"stopAfterSuccess"` + TimeoutSec int `json:"timeoutSec"` + StartAt string `json:"startAt"` +} + +type AccountPreview struct { + Line int `json:"line"` + UID int64 `json:"uid"` + Valid bool `json:"valid"` + Error string `json:"error,omitempty"` +} + +type LogEntry struct { + Time string `json:"time"` + Level string `json:"level"` + Message string `json:"message"` +} + +type PrizeListResult struct { + UID int64 `json:"uid"` + Status int32 `json:"status"` + Msg string `json:"msg"` + Prizes []huya.PrizeInfo `json:"prizes"` + Raw *huya.GetActPrizeListResp `json:"raw,omitempty"` +} + +type ScoreResult struct { + UID int64 `json:"uid"` + Score int64 `json:"score"` + Resp *huya.GetUserScoreResp `json:"resp,omitempty"` + Error string `json:"error,omitempty"` +} + +type RecordResult struct { + UID int64 `json:"uid"` + Records []huya.UserPrizeInfo `json:"records"` + Resp *huya.GetUserPrizeRecordsResp `json:"resp,omitempty"` + Error string `json:"error,omitempty"` +} + +type ExchangeResult struct { + UID int64 `json:"uid"` + Resp *huya.ScoreExchangePrizeResp `json:"resp,omitempty"` + Error string `json:"error,omitempty"` +} + +type MonitorState struct { + Running bool `json:"running"` + Message string `json:"message"` +} + +type cookieLine struct { + lineNo int + text string +} + +func NewApp() *App { + return &App{} +} + +func (a *App) Startup(ctx context.Context) { + a.ctx = ctx + a.addLog("info", "GUI 已启动") +} + +func (a *App) Shutdown(ctx context.Context) { + a.StopMonitor() +} + +func (a *App) DefaultConfig() Config { + return Config{ + Transport: "wss", + WSSHost: huya.DefaultWSSHost, + SID: 2203, + PID: 12889, + Name: "小黄鸭", + Loops: 20, + DelayMS: 120, + Concurrency: 5, + StopAfterSuccess: true, + TimeoutSec: 15, + } +} + +func (a *App) PreviewAccounts(cookieText string) []AccountPreview { + previews := make([]AccountPreview, 0) + for _, line := range splitCookieLines(cookieText) { + uid := huya.ResolveUID(line.text) + item := AccountPreview{Line: line.lineNo, UID: uid, Valid: uid > 0} + if uid <= 0 { + item.Error = "无法解析 yyuid/udb_uid" + } + previews = append(previews, item) + } + return previews +} + +func (a *App) GetLogs() []LogEntry { + a.logMu.Lock() + defer a.logMu.Unlock() + return append([]LogEntry(nil), a.logs...) +} + +func (a *App) IsRunning() bool { + a.runMu.Lock() + defer a.runMu.Unlock() + return a.monitorRunning +} + +func (a *App) ListPrizes(cfg Config) (PrizeListResult, error) { + cfg = normalizeConfig(cfg) + accounts, err := parseAccounts(cfg.CookieText) + if err != nil { + return PrizeListResult{}, err + } + if cfg.SID <= 0 { + return PrizeListResult{}, errors.New("SID 不能为空") + } + client, closeClient, err := a.newClient(cfg) + if err != nil { + return PrizeListResult{}, err + } + defer closeClient() + + ctx, cancel := requestContext(cfg.TimeoutSec) + defer cancel() + resp, err := client.GetActPrizeList(ctx, accounts[0].UID, accounts[0].Cookie, cfg.SID) + if err != nil { + a.addLog("error", "查询奖品失败: %v", err) + return PrizeListResult{}, err + } + a.addLog("info", "查询奖品完成: uid=%d sid=%d count=%d", accounts[0].UID, cfg.SID, len(resp.Prizes)) + return PrizeListResult{ + UID: accounts[0].UID, + Status: resp.Status, + Msg: resp.Msg, + Prizes: resp.Prizes, + Raw: resp, + }, nil +} + +func (a *App) QueryScores(cfg Config) ([]ScoreResult, error) { + cfg = normalizeConfig(cfg) + accounts, err := parseAccounts(cfg.CookieText) + if err != nil { + return nil, err + } + if cfg.SID <= 0 { + return nil, errors.New("SID 不能为空") + } + client, closeClient, err := a.newClient(cfg) + if err != nil { + return nil, err + } + defer closeClient() + + results := make([]ScoreResult, len(accounts)) + a.runConcurrent(accounts, cfg.Concurrency, func(i int, account sniper.Account) { + ctx, cancel := requestContext(cfg.TimeoutSec) + defer cancel() + resp, err := client.QueryUserScore(ctx, account.UID, account.Cookie, cfg.SID) + item := ScoreResult{UID: account.UID, Resp: resp, Error: errorString(err)} + if resp != nil { + item.Score = resp.AvailableScore() + } + results[i] = item + }) + a.addLog("info", "查询积分完成: accounts=%d", len(accounts)) + return results, nil +} + +func (a *App) GetRecords(cfg Config) ([]RecordResult, error) { + cfg = normalizeConfig(cfg) + accounts, err := parseAccounts(cfg.CookieText) + if err != nil { + return nil, err + } + if cfg.SID <= 0 { + return nil, errors.New("SID 不能为空") + } + client, closeClient, err := a.newClient(cfg) + if err != nil { + return nil, err + } + defer closeClient() + + results := make([]RecordResult, len(accounts)) + a.runConcurrent(accounts, cfg.Concurrency, func(i int, account sniper.Account) { + ctx, cancel := requestContext(cfg.TimeoutSec) + defer cancel() + resp, err := client.GetUserPrizeRecords(ctx, account.UID, account.Cookie, cfg.SID) + item := RecordResult{UID: account.UID, Resp: resp, Error: errorString(err)} + if resp != nil { + item.Records = resp.Records + } + results[i] = item + }) + a.addLog("info", "查询兑换记录完成: accounts=%d", len(accounts)) + return results, nil +} + +func (a *App) Exchange(cfg Config) ([]ExchangeResult, error) { + cfg = normalizeConfig(cfg) + accounts, err := parseAccounts(cfg.CookieText) + if err != nil { + return nil, err + } + if cfg.SID <= 0 || cfg.PID <= 0 { + return nil, errors.New("SID 和 PID 都不能为空") + } + client, closeClient, err := a.newClient(cfg) + if err != nil { + return nil, err + } + defer closeClient() + + results := make([]ExchangeResult, len(accounts)) + a.runConcurrent(accounts, cfg.Concurrency, func(i int, account sniper.Account) { + ctx, cancel := requestContext(cfg.TimeoutSec) + defer cancel() + resp, err := client.ScoreExchangePrize(ctx, account.UID, account.Cookie, cfg.SID, cfg.PID) + results[i] = ExchangeResult{UID: account.UID, Resp: resp, Error: errorString(err)} + }) + a.addLog("info", "直接兑换完成: sid=%d pid=%d accounts=%d", cfg.SID, cfg.PID, len(accounts)) + return results, nil +} + +func (a *App) StartMonitor(cfg Config) error { + cfg = normalizeConfig(cfg) + accounts, err := parseAccounts(cfg.CookieText) + if err != nil { + return err + } + if cfg.SID <= 0 { + return errors.New("SID 不能为空") + } + if cfg.PID <= 0 && strings.TrimSpace(cfg.Name) == "" { + return errors.New("PID 和名称至少填写一个") + } + startAt, err := parseStartTime(cfg.StartAt) + if err != nil { + return err + } + + a.runMu.Lock() + if a.monitorRunning { + a.runMu.Unlock() + return errors.New("监控已在运行") + } + ctx, cancel := context.WithCancel(context.Background()) + a.monitorCancel = cancel + a.monitorRunning = true + a.runMu.Unlock() + + client, closeClient, err := a.newClient(cfg) + if err != nil { + cancel() + a.finishMonitor("启动失败") + return err + } + + a.emitState(true, "运行中") + a.addLog("info", "启动监控: sid=%d pid=%d name=%s accounts=%d", cfg.SID, cfg.PID, cfg.Name, len(accounts)) + + go func() { + defer closeClient() + defer a.finishMonitor("已停止") + + if !startAt.IsZero() { + a.addLog("info", "等待定时开始: %s", startAt.Format("2006-01-02 15:04:05")) + if err := waitUntil(ctx, startAt); err != nil { + a.addLog("info", "定时等待已取消") + return + } + } + + runner := sniper.Runner{Client: client} + err := runner.Run(ctx, accounts, sniper.Target{ + PID: cfg.PID, + Name: strings.TrimSpace(cfg.Name), + }, sniper.Config{ + SID: cfg.SID, + Loops: cfg.Loops, + Delay: time.Duration(cfg.DelayMS) * time.Millisecond, + Concurrency: cfg.Concurrency, + StopAfterSuccess: cfg.StopAfterSuccess, + }, func(result sniper.Result) { + a.emit(eventMonitorResult, result) + a.addLog("info", "监控结果: loop=%d uid=%d action=%s error=%s", result.Loop, result.UID, result.Action, result.Error) + }) + if err != nil && !errors.Is(err, context.Canceled) { + a.addLog("error", "监控结束异常: %v", err) + } + }() + return nil +} + +func (a *App) StopMonitor() bool { + a.runMu.Lock() + cancel := a.monitorCancel + a.runMu.Unlock() + if cancel == nil { + return false + } + cancel() + return true +} + +func (a *App) newClient(cfg Config) (huya.ActivityClient, func(), error) { + return huya.NewActivityClient(cfg.Transport, cfg.WSSHost, time.Duration(cfg.TimeoutSec)*time.Second, func(msg string) { + a.addLog("debug", "%s", msg) + }) +} + +func (a *App) runConcurrent(accounts []sniper.Account, concurrency int, fn func(i int, account sniper.Account)) { + if concurrency <= 0 { + concurrency = 1 + } + sem := make(chan struct{}, concurrency) + var wg sync.WaitGroup + for i, account := range accounts { + i, account := i, account + wg.Add(1) + go func() { + defer wg.Done() + sem <- struct{}{} + defer func() { <-sem }() + fn(i, account) + }() + } + wg.Wait() +} + +func (a *App) finishMonitor(message string) { + a.runMu.Lock() + a.monitorCancel = nil + a.monitorRunning = false + a.runMu.Unlock() + a.emitState(false, message) +} + +func (a *App) addLog(level, format string, args ...any) { + entry := LogEntry{ + Time: time.Now().Format("15:04:05.000"), + Level: level, + Message: fmt.Sprintf(format, args...), + } + a.logMu.Lock() + a.logs = append(a.logs, entry) + if len(a.logs) > maxLogEntries { + a.logs = append([]LogEntry(nil), a.logs[len(a.logs)-maxLogEntries:]...) + } + a.logMu.Unlock() + a.emit(eventLog, entry) +} + +func (a *App) emitState(running bool, message string) { + a.emit(eventMonitorState, MonitorState{Running: running, Message: message}) +} + +func (a *App) emit(event string, data any) { + if a.ctx == nil { + return + } + runtime.EventsEmit(a.ctx, event, data) +} + +func normalizeConfig(cfg Config) Config { + if strings.TrimSpace(cfg.Transport) == "" { + cfg.Transport = "wss" + } + if strings.TrimSpace(cfg.WSSHost) == "" { + cfg.WSSHost = huya.DefaultWSSHost + } + if cfg.Loops <= 0 { + cfg.Loops = 1 + } + if cfg.DelayMS <= 0 { + cfg.DelayMS = 150 + } + if cfg.Concurrency <= 0 { + cfg.Concurrency = 1 + } + if cfg.TimeoutSec <= 0 { + cfg.TimeoutSec = 15 + } + cfg.Name = strings.TrimSpace(cfg.Name) + cfg.CookieText = strings.TrimSpace(cfg.CookieText) + cfg.StartAt = strings.TrimSpace(cfg.StartAt) + return cfg +} + +func parseAccounts(cookieText string) ([]sniper.Account, error) { + lines := splitCookieLines(cookieText) + if len(lines) == 0 { + return nil, errors.New("Cookie 不能为空") + } + accounts := make([]sniper.Account, 0, len(lines)) + for _, cookie := range lines { + uid := huya.ResolveUID(cookie.text) + if uid <= 0 { + return nil, fmt.Errorf("第 %d 行 Cookie 无法解析 yyuid/udb_uid", cookie.lineNo) + } + accounts = append(accounts, sniper.Account{UID: uid, Cookie: cookie.text}) + } + return accounts, nil +} + +func splitCookieLines(cookieText string) []cookieLine { + lines := strings.Split(cookieText, "\n") + out := make([]cookieLine, 0, len(lines)) + for i, line := range lines { + item := strings.TrimSpace(line) + if item == "" || strings.HasPrefix(item, "#") { + continue + } + out = append(out, cookieLine{lineNo: i + 1, text: item}) + } + return out +} + +func requestContext(timeoutSec int) (context.Context, context.CancelFunc) { + if timeoutSec <= 0 { + timeoutSec = 15 + } + return context.WithTimeout(context.Background(), time.Duration(timeoutSec)*time.Second) +} + +func parseStartTime(text string) (time.Time, error) { + text = strings.TrimSpace(text) + if text == "" { + return time.Time{}, nil + } + if ts, err := strconv.ParseInt(text, 10, 64); err == nil { + return time.Unix(ts, 0), nil + } + for _, layout := range []string{time.RFC3339, "2006-01-02 15:04:05", "2006-01-02 15:04"} { + if t, err := time.ParseInLocation(layout, text, time.Local); err == nil { + return t, nil + } + } + return time.Time{}, fmt.Errorf("无法解析开始时间: %s", text) +} + +func waitUntil(ctx context.Context, when time.Time) error { + for { + remaining := time.Until(when) + if remaining <= 0 { + return nil + } + timer := time.NewTimer(minDuration(remaining, 200*time.Millisecond)) + select { + case <-timer.C: + case <-ctx.Done(): + timer.Stop() + return ctx.Err() + } + } +} + +func minDuration(a, b time.Duration) time.Duration { + if a < b { + return a + } + return b +} + +func errorString(err error) string { + if err == nil { + return "" + } + return err.Error() +} diff --git a/internal/huya/activity.go b/internal/huya/activity.go new file mode 100644 index 0000000..f031433 --- /dev/null +++ b/internal/huya/activity.go @@ -0,0 +1,581 @@ +package huya + +import ( + "math" + "strconv" + "strings" + + "huya-go/internal/taf" +) + +const ( + ActivityWebUA = "web&1.0&huya" + ActivityRecordUA = "webh5&1.0.0&huya" + ActivityBindUA = "pc&1.0.0&huya" + ServantWebActUI = "webActUI" + FuncGetUserScore = "getUserScore" + FuncPrizeList = "getActPrizeList" + FuncPrizeRecords = "getUserPrizeRecords" + FuncExchangePrize = "scoreExchangePrize" +) + +type ActivityUserID struct { + UID int64 `json:"uid"` + GUID string `json:"guid,omitempty"` + Token string `json:"token,omitempty"` + HuyaUA string `json:"huya_ua"` + Cookie string `json:"-"` + TokenType int32 `json:"token_type"` + DeviceInfo string `json:"device_info,omitempty"` +} + +func NewActivityUserID(uid int64, cookie, ua string) ActivityUserID { + return ActivityUserID{ + UID: uid, + HuyaUA: ua, + Cookie: NormalizeCookie(cookie), + TokenType: 0, + } +} + +func (u *ActivityUserID) WriteTo(w *taf.Writer) error { + if err := w.WriteInt64(0, u.UID); err != nil { + return err + } + if err := w.WriteString(1, u.GUID); err != nil { + return err + } + if err := w.WriteString(2, u.Token); err != nil { + return err + } + if err := w.WriteString(3, u.HuyaUA); err != nil { + return err + } + if err := w.WriteString(4, u.Cookie); err != nil { + return err + } + if err := w.WriteInt32(5, int64(u.TokenType)); err != nil { + return err + } + return w.WriteString(6, u.DeviceInfo) +} + +func (u *ActivityUserID) ReadFrom(r *taf.Reader) error { + var err error + if u.UID, err = r.ReadInt64(0, false, u.UID); err != nil { + return err + } + if u.GUID, err = r.ReadString(1, false, u.GUID); err != nil { + return err + } + if u.Token, err = r.ReadString(2, false, u.Token); err != nil { + return err + } + if u.HuyaUA, err = r.ReadString(3, false, u.HuyaUA); err != nil { + return err + } + if u.Cookie, err = r.ReadString(4, false, u.Cookie); err != nil { + return err + } + if u.TokenType, err = r.ReadInt32(5, false, u.TokenType); err != nil { + return err + } + u.DeviceInfo, err = r.ReadString(6, false, u.DeviceInfo) + return err +} + +type GetUserScoreReq struct { + User ActivityUserID + SID int32 +} + +func (q *GetUserScoreReq) WriteTo(w *taf.Writer) error { + if err := w.WriteStruct(0, &q.User); err != nil { + return err + } + return w.WriteInt32(1, int64(q.SID)) +} + +func (q *GetUserScoreReq) ReadFrom(r *taf.Reader) error { + _, err := r.ReadStruct(0, false, &q.User) + if err != nil { + return err + } + q.SID, err = r.ReadInt32(1, false, q.SID) + return err +} + +type GetUserScoreResp struct { + Status int32 `json:"status"` + Msg string `json:"msg"` + GainScore int32 `json:"gain_score"` + UsedScore int32 `json:"used_score"` + NewGainScore int64 `json:"new_gain_score"` + NewUsedScore int64 `json:"new_used_score"` + Score int64 `json:"score"` + IsOpenExchangeTip int32 `json:"is_open_exchange_tip"` +} + +func (r *GetUserScoreResp) WriteTo(w *taf.Writer) error { return nil } + +func (r *GetUserScoreResp) ReadFrom(rd *taf.Reader) error { + var err error + if r.Status, err = rd.ReadInt32(0, false, r.Status); err != nil { + return err + } + if r.Msg, err = rd.ReadString(1, false, r.Msg); err != nil { + return err + } + if r.GainScore, err = rd.ReadInt32(2, false, r.GainScore); err != nil { + return err + } + if r.UsedScore, err = rd.ReadInt32(3, false, r.UsedScore); err != nil { + return err + } + if r.NewGainScore, err = rd.ReadInt64(4, false, r.NewGainScore); err != nil { + return err + } + if r.NewUsedScore, err = rd.ReadInt64(5, false, r.NewUsedScore); err != nil { + return err + } + if r.Score, err = rd.ReadInt64(6, false, r.Score); err != nil { + return err + } + r.IsOpenExchangeTip, err = rd.ReadInt32(7, false, r.IsOpenExchangeTip) + return err +} + +func (r GetUserScoreResp) AvailableScore() int64 { + if r.NewGainScore != 0 || r.NewUsedScore != 0 { + score := r.NewGainScore - r.NewUsedScore + if score < 0 { + return 0 + } + return score + } + return r.Score +} + +type GetActPrizeListReq struct { + User ActivityUserID + SID int32 +} + +func (q *GetActPrizeListReq) WriteTo(w *taf.Writer) error { + if err := w.WriteStruct(0, &q.User); err != nil { + return err + } + return w.WriteInt32(1, int64(q.SID)) +} + +func (q *GetActPrizeListReq) ReadFrom(r *taf.Reader) error { + _, err := r.ReadStruct(0, false, &q.User) + if err != nil { + return err + } + q.SID, err = r.ReadInt32(1, false, q.SID) + return err +} + +type PrizeInfo struct { + ID int64 `json:"id"` + SID int64 `json:"sid"` + Name string `json:"name"` + Score int64 `json:"score"` + Type int32 `json:"type"` + Image string `json:"img,omitempty"` + Sort int32 `json:"sort"` + Frequency int32 `json:"frequency"` + FrequencyLimit int32 `json:"frequency_limit"` + CreateTime int64 `json:"create_time"` + Num int64 `json:"num"` + Status int32 `json:"status"` + Percent string `json:"percent"` + NewScore int64 `json:"new_score"` + Tags string `json:"tags,omitempty"` + LeftNum int64 `json:"left_num"` + IsShowNum int32 `json:"is_show_num"` +} + +func (p *PrizeInfo) WriteTo(w *taf.Writer) error { return nil } + +func (p *PrizeInfo) ReadFrom(r *taf.Reader) error { + var err error + if p.ID, err = r.ReadInt64(0, false, p.ID); err != nil { + return err + } + if p.SID, err = r.ReadInt64(1, false, p.SID); err != nil { + return err + } + if p.Name, err = r.ReadString(2, false, p.Name); err != nil { + return err + } + if p.Score, err = r.ReadInt64(3, false, p.Score); err != nil { + return err + } + if p.Type, err = r.ReadInt32(4, false, p.Type); err != nil { + return err + } + if p.Image, err = r.ReadString(5, false, p.Image); err != nil { + return err + } + if p.Sort, err = r.ReadInt32(6, false, p.Sort); err != nil { + return err + } + if p.Frequency, err = r.ReadInt32(7, false, p.Frequency); err != nil { + return err + } + if p.FrequencyLimit, err = r.ReadInt32(8, false, p.FrequencyLimit); err != nil { + return err + } + if p.CreateTime, err = r.ReadInt64(9, false, p.CreateTime); err != nil { + return err + } + if p.Num, err = r.ReadInt64(10, false, p.Num); err != nil { + return err + } + if p.Status, err = r.ReadInt32(11, false, p.Status); err != nil { + return err + } + if p.Percent, err = r.ReadString(12, false, p.Percent); err != nil { + return err + } + if p.NewScore, err = r.ReadInt64(13, false, p.NewScore); err != nil { + return err + } + if p.Tags, err = r.ReadString(14, false, p.Tags); err != nil { + return err + } + if p.LeftNum, err = r.ReadInt64(15, false, p.LeftNum); err != nil { + return err + } + p.IsShowNum, err = r.ReadInt32(16, false, p.IsShowNum) + return err +} + +func (p PrizeInfo) Price() int64 { + if p.NewScore != 0 { + return p.NewScore + } + return p.Score +} + +func (p PrizeInfo) EstimatedLeft() int64 { + if p.LeftNum > 0 { + return p.LeftNum + } + text := strings.TrimSuffix(strings.TrimSpace(p.Percent), "%") + if text == "" || p.Num <= 0 { + return 0 + } + percent, err := strconv.ParseFloat(text, 64) + if err != nil { + return 0 + } + return int64(math.Floor(float64(p.Num)*percent/100.0 + 1e-9)) +} + +type PrizeTag struct { + ID int64 `json:"id"` + Name string `json:"name"` + Weight int32 `json:"weight"` +} + +func (t *PrizeTag) WriteTo(w *taf.Writer) error { return nil } + +func (t *PrizeTag) ReadFrom(r *taf.Reader) error { + var err error + if t.ID, err = r.ReadInt64(0, false, t.ID); err != nil { + return err + } + if t.Name, err = r.ReadString(1, false, t.Name); err != nil { + return err + } + t.Weight, err = r.ReadInt32(2, false, t.Weight) + return err +} + +type GetActPrizeListResp struct { + Status int32 `json:"status"` + Msg string `json:"msg"` + Prizes []PrizeInfo `json:"prizes"` + ModuleID int32 `json:"module_id"` + Tags []PrizeTag `json:"tags"` +} + +func (r *GetActPrizeListResp) WriteTo(w *taf.Writer) error { return nil } + +func (r *GetActPrizeListResp) ReadFrom(rd *taf.Reader) error { + var err error + if r.Status, err = rd.ReadInt32(0, false, r.Status); err != nil { + return err + } + if r.Msg, err = rd.ReadString(1, false, r.Msg); err != nil { + return err + } + items, err := rd.ReadListStruct(2, false, func() taf.Unmarshaler { return &PrizeInfo{} }) + if err != nil { + return err + } + r.Prizes = make([]PrizeInfo, 0, len(items)) + for _, item := range items { + if prize, ok := item.(*PrizeInfo); ok { + r.Prizes = append(r.Prizes, *prize) + } + } + if r.ModuleID, err = rd.ReadInt32(3, false, r.ModuleID); err != nil { + return err + } + tags, err := rd.ReadListStruct(4, false, func() taf.Unmarshaler { return &PrizeTag{} }) + if err != nil { + return err + } + r.Tags = make([]PrizeTag, 0, len(tags)) + for _, item := range tags { + if tag, ok := item.(*PrizeTag); ok { + r.Tags = append(r.Tags, *tag) + } + } + return nil +} + +type GetUserPrizeRecordsReq struct { + User ActivityUserID + SID int32 +} + +func (q *GetUserPrizeRecordsReq) WriteTo(w *taf.Writer) error { + if err := w.WriteStruct(0, &q.User); err != nil { + return err + } + return w.WriteInt32(1, int64(q.SID)) +} + +func (q *GetUserPrizeRecordsReq) ReadFrom(r *taf.Reader) error { + _, err := r.ReadStruct(0, false, &q.User) + if err != nil { + return err + } + q.SID, err = r.ReadInt32(1, false, q.SID) + return err +} + +type UserPrizeInfo struct { + ID int64 `json:"id"` + Name string `json:"name"` + Score int64 `json:"score"` + CreateTime int64 `json:"create_time"` + Status int32 `json:"status"` + Type int32 `json:"type"` + IsReal int32 `json:"is_real"` + NewScore int64 `json:"new_score"` + Account string `json:"account,omitempty"` + Code string `json:"code,omitempty"` + CommonPrizeType int32 `json:"common_prize_type"` +} + +func (p *UserPrizeInfo) WriteTo(w *taf.Writer) error { return nil } + +func (p *UserPrizeInfo) ReadFrom(r *taf.Reader) error { + var err error + if p.ID, err = r.ReadInt64(0, false, p.ID); err != nil { + return err + } + if p.Name, err = r.ReadString(1, false, p.Name); err != nil { + return err + } + if p.Score, err = r.ReadInt64(2, false, p.Score); err != nil { + return err + } + if p.CreateTime, err = r.ReadInt64(3, false, p.CreateTime); err != nil { + return err + } + if p.Status, err = r.ReadInt32(4, false, p.Status); err != nil { + return err + } + if p.Type, err = r.ReadInt32(5, false, p.Type); err != nil { + return err + } + if p.IsReal, err = r.ReadInt32(6, false, p.IsReal); err != nil { + return err + } + if p.NewScore, err = r.ReadInt64(7, false, p.NewScore); err != nil { + return err + } + if p.Account, err = r.ReadString(8, false, p.Account); err != nil { + return err + } + if p.Code, err = r.ReadString(9, false, p.Code); err != nil { + return err + } + p.CommonPrizeType, err = r.ReadInt32(10, false, p.CommonPrizeType) + return err +} + +type GetUserPrizeRecordsResp struct { + Status int32 `json:"status"` + Msg string `json:"msg"` + Records []UserPrizeInfo `json:"records"` +} + +func (r *GetUserPrizeRecordsResp) WriteTo(w *taf.Writer) error { return nil } + +func (r *GetUserPrizeRecordsResp) ReadFrom(rd *taf.Reader) error { + var err error + if r.Status, err = rd.ReadInt32(0, false, r.Status); err != nil { + return err + } + if r.Msg, err = rd.ReadString(1, false, r.Msg); err != nil { + return err + } + items, err := rd.ReadListStruct(2, false, func() taf.Unmarshaler { return &UserPrizeInfo{} }) + if err != nil { + return err + } + r.Records = make([]UserPrizeInfo, 0, len(items)) + for _, item := range items { + if record, ok := item.(*UserPrizeInfo); ok { + r.Records = append(r.Records, *record) + } + } + return nil +} + +type ScoreExchangePrizeReq struct { + User ActivityUserID + SID int32 + PID int32 + IP string + ClientEnv map[string]string + Source string + IsRole int32 +} + +func (q *ScoreExchangePrizeReq) WriteTo(w *taf.Writer) error { + if err := w.WriteStruct(0, &q.User); err != nil { + return err + } + if err := w.WriteInt32(1, int64(q.SID)); err != nil { + return err + } + if err := w.WriteInt32(2, int64(q.PID)); err != nil { + return err + } + if err := w.WriteString(3, q.IP); err != nil { + return err + } + if err := w.WriteMapStringString(4, q.ClientEnv); err != nil { + return err + } + if err := w.WriteString(5, q.Source); err != nil { + return err + } + if q.IsRole == 0 { + q.IsRole = 1 + } + return w.WriteInt32(6, int64(q.IsRole)) +} + +func (q *ScoreExchangePrizeReq) ReadFrom(r *taf.Reader) error { + _, err := r.ReadStruct(0, false, &q.User) + if err != nil { + return err + } + if q.SID, err = r.ReadInt32(1, false, q.SID); err != nil { + return err + } + if q.PID, err = r.ReadInt32(2, false, q.PID); err != nil { + return err + } + if q.IP, err = r.ReadString(3, false, q.IP); err != nil { + return err + } + if q.ClientEnv, err = r.ReadMapStringString(4, false); err != nil { + return err + } + if q.Source, err = r.ReadString(5, false, q.Source); err != nil { + return err + } + q.IsRole, err = r.ReadInt32(6, false, q.IsRole) + return err +} + +type ExchangeInfo struct { + PID int32 `json:"pid"` + ExchangeScore int64 `json:"exchange_score"` + Desc string `json:"desc"` +} + +func (e *ExchangeInfo) WriteTo(w *taf.Writer) error { return nil } + +func (e *ExchangeInfo) ReadFrom(r *taf.Reader) error { + var err error + if e.PID, err = r.ReadInt32(1, false, e.PID); err != nil { + return err + } + if e.ExchangeScore, err = r.ReadInt64(2, false, e.ExchangeScore); err != nil { + return err + } + e.Desc, err = r.ReadString(3, false, e.Desc) + return err +} + +type ActPreCondition struct { + ConditionType int32 `json:"condition_type"` + ConditionParams map[string]string `json:"condition_params,omitempty"` + Tip string `json:"tip,omitempty"` + JumpURL string `json:"jump_url,omitempty"` + ButtonDesc string `json:"button_desc,omitempty"` +} + +func (c *ActPreCondition) WriteTo(w *taf.Writer) error { return nil } + +func (c *ActPreCondition) ReadFrom(r *taf.Reader) error { + var err error + if c.ConditionType, err = r.ReadInt32(0, false, c.ConditionType); err != nil { + return err + } + if c.ConditionParams, err = r.ReadMapStringString(1, false); err != nil { + return err + } + if c.Tip, err = r.ReadString(2, false, c.Tip); err != nil { + return err + } + if c.JumpURL, err = r.ReadString(3, false, c.JumpURL); err != nil { + return err + } + c.ButtonDesc, err = r.ReadString(4, false, c.ButtonDesc) + return err +} + +type ScoreExchangePrizeResp struct { + Status int32 `json:"status"` + Msg string `json:"msg"` + OrderID string `json:"order_id,omitempty"` + ExchangeInfo ExchangeInfo `json:"exchange_info"` + ActPreCondition ActPreCondition `json:"act_pre_condition"` +} + +func (r *ScoreExchangePrizeResp) WriteTo(w *taf.Writer) error { return nil } + +func (r *ScoreExchangePrizeResp) ReadFrom(rd *taf.Reader) error { + var err error + if r.Status, err = rd.ReadInt32(0, false, r.Status); err != nil { + return err + } + if r.Msg, err = rd.ReadString(1, false, r.Msg); err != nil { + return err + } + if r.OrderID, err = rd.ReadString(3, false, r.OrderID); err != nil { + return err + } + if _, err = rd.ReadStruct(4, false, &r.ExchangeInfo); err != nil { + return err + } + _, err = rd.ReadStruct(5, false, &r.ActPreCondition) + return err +} + +func (r ScoreExchangePrizeResp) Success() bool { + return r.Status == 200 && (r.Msg == "" || strings.Contains(r.Msg, "成功")) +} diff --git a/internal/huya/baseinfo.go b/internal/huya/baseinfo.go new file mode 100644 index 0000000..63604a5 --- /dev/null +++ b/internal/huya/baseinfo.go @@ -0,0 +1,101 @@ +package huya + +import ( + "encoding/base64" + "math/rand" + "net/url" + + "huya-go/internal/taf" +) + +const ( + HTTPHuyaUA = "webh5&0.0.1&websocket&&diypc_52775" + PCUserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " + + "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36" +) + +type WSConnectParaInfo struct { + UID int64 + GUID string + UA string + AppSrc string + MID string + Exp string + TokenType int32 + Token string + Cookie string + TraceID string + CustomHeaders map[string]string +} + +func NewWSConnectParaInfo(uid int64, guid, cookie string) WSConnectParaInfo { + return WSConnectParaInfo{ + UID: uid, + GUID: guid, + UA: HTTPHuyaUA, + AppSrc: "HUYA&ZH&2052", + Cookie: cookie, + TraceID: NewTraceID(), + CustomHeaders: map[string]string{}, + } +} + +func (i WSConnectParaInfo) WriteTo(w *taf.Writer) error { + if err := w.WriteInt64(0, i.UID); err != nil { + return err + } + if err := w.WriteString(1, i.GUID); err != nil { + return err + } + if err := w.WriteString(2, i.UA); err != nil { + return err + } + if err := w.WriteString(3, i.AppSrc); err != nil { + return err + } + if err := w.WriteString(4, i.MID); err != nil { + return err + } + if err := w.WriteString(5, i.Exp); err != nil { + return err + } + if err := w.WriteInt32(6, int64(i.TokenType)); err != nil { + return err + } + if err := w.WriteString(7, i.Token); err != nil { + return err + } + if err := w.WriteString(8, i.Cookie); err != nil { + return err + } + if err := w.WriteString(9, i.TraceID); err != nil { + return err + } + return w.WriteMapStringString(10, i.CustomHeaders) +} + +func NewTraceID() string { + // 与前端 traceId 格式保持一致：hex16:hex16:0:0。 + v := rand.Uint64() + s := lowerHex16(v) + return s + ":" + s + ":0:0" +} + +func lowerHex16(v uint64) string { + const digits = "0123456789abcdef" + var b [16]byte + for i := 15; i >= 0; i-- { + b[i] = digits[v&0xf] + v >>= 4 + } + return string(b[:]) +} + +func GenerateHTTPBaseinfo(uid int64, guid, cookie string) (string, error) { + info := NewWSConnectParaInfo(uid, guid, cookie) + w := taf.NewWriter() + if err := info.WriteTo(w); err != nil { + return "", err + } + return url.QueryEscape(base64.StdEncoding.EncodeToString(w.Bytes())), nil +} diff --git a/internal/huya/client.go b/internal/huya/client.go new file mode 100644 index 0000000..f2b174d --- /dev/null +++ b/internal/huya/client.go @@ -0,0 +1,39 @@ +package huya + +import ( + "context" + "fmt" + "strings" + "time" +) + +// ActivityClient 抽象虎牙活动接口，HTTP 与 WSS 传输都实现它。 +type ActivityClient interface { + GetActPrizeList(ctx context.Context, uid int64, cookie string, sid int32) (*GetActPrizeListResp, error) + QueryUserScore(ctx context.Context, uid int64, cookie string, sid int32) (*GetUserScoreResp, error) + GetUserPrizeRecords(ctx context.Context, uid int64, cookie string, sid int32) (*GetUserPrizeRecordsResp, error) + ScoreExchangePrize(ctx context.Context, uid int64, cookie string, sid, pid int32) (*ScoreExchangePrizeResp, error) +} + +// NewActivityClient 按传输层创建活动客户端，供 CLI 和 GUI 共用。 +func NewActivityClient(transport, wssHost string, timeout time.Duration, logger func(string)) (ActivityClient, func(), error) { + switch strings.ToLower(strings.TrimSpace(transport)) { + case "", "http": + client := NewHTTPClient(logger) + if timeout > 0 { + client.Client.Timeout = timeout + } + return client, func() {}, nil + case "wss", "ws", "websocket": + client := NewWSSClient(logger) + if strings.TrimSpace(wssHost) != "" { + client.Host = strings.TrimSpace(wssHost) + } + if timeout > 0 { + client.CallTimeout = timeout + } + return client, func() { _ = client.Close() }, nil + default: + return nil, func() {}, fmt.Errorf("未知传输层: %s", transport) + } +} diff --git a/internal/huya/cookie.go b/internal/huya/cookie.go new file mode 100644 index 0000000..903f110 --- /dev/null +++ b/internal/huya/cookie.go @@ -0,0 +1,70 @@ +package huya + +import ( + "strconv" + "strings" +) + +type CookiePair struct { + Key string + Value string +} + +func CookiePairs(cookie string) []CookiePair { + parts := strings.Split(cookie, ";") + pairs := make([]CookiePair, 0, len(parts)) + for _, part := range parts { + item := strings.TrimSpace(part) + if item == "" || !strings.Contains(item, "=") { + continue + } + key, value, _ := strings.Cut(item, "=") + key = strings.TrimSpace(key) + if key == "" { + continue + } + pairs = append(pairs, CookiePair{Key: key, Value: strings.TrimSpace(value)}) + } + return pairs +} + +func NormalizeCookie(cookie string) string { + pairs := CookiePairs(cookie) + order := make([]string, 0, len(pairs)) + values := map[string]string{} + for _, pair := range pairs { + if _, ok := values[pair.Key]; !ok { + order = append(order, pair.Key) + } + values[pair.Key] = pair.Value + } + out := make([]string, 0, len(order)) + for _, key := range order { + out = append(out, key+"="+values[key]) + } + return strings.Join(out, "; ") +} + +func CookieValue(cookie, key string) string { + value := "" + for _, pair := range CookiePairs(cookie) { + if pair.Key == key { + value = pair.Value + } + } + return value +} + +func ResolveUID(cookie string) int64 { + for _, key := range []string{"yyuid", "udb_uid", "uid"} { + value := CookieValue(cookie, key) + if value == "" { + continue + } + uid, err := strconv.ParseInt(value, 10, 64) + if err == nil && uid > 0 { + return uid + } + } + return 0 +} diff --git a/internal/huya/http_client.go b/internal/huya/http_client.go new file mode 100644 index 0000000..8e06ad8 --- /dev/null +++ b/internal/huya/http_client.go @@ -0,0 +1,170 @@ +package huya + +import ( + "bytes" + "compress/gzip" + "context" + "fmt" + "io" + "net/http" + "time" + + "huya-go/internal/taf" + "huya-go/internal/wup" +) + +const DefaultCDNWSEndpoint = "https://cdnws.api.huya.com/" + +type HTTPClient struct { + Endpoint string + Client *http.Client + Logger func(string) +} + +type CallOptions struct { + UID int64 + GUID string + Cookie string + RequestID int32 + Timeout time.Duration +} + +func NewHTTPClient(logger func(string)) *HTTPClient { + return &HTTPClient{ + Endpoint: DefaultCDNWSEndpoint, + Client: &http.Client{ + Timeout: 15 * time.Second, + }, + Logger: logger, + } +} + +func (c *HTTPClient) logf(format string, args ...any) { + if c.Logger != nil { + c.Logger(fmt.Sprintf(format, args...)) + } +} + +func (c *HTTPClient) CallRPC(ctx context.Context, service, method string, reqStruct taf.Marshaler, respStruct taf.Unmarshaler, opt CallOptions) (*wup.Response, error) { + if opt.RequestID == 0 { + opt.RequestID = 1 + } + reqWup := wup.NewRequest(service, method, opt.RequestID) + if err := reqWup.WriteStruct("tReq", reqStruct); err != nil { + return nil, err + } + body, err := reqWup.Encode() + if err != nil { + return nil, err + } + + baseinfo, err := GenerateHTTPBaseinfo(opt.UID, opt.GUID, opt.Cookie) + if err != nil { + return nil, err + } + endpoint := c.Endpoint + if endpoint == "" { + endpoint = DefaultCDNWSEndpoint + } + url := endpoint + "?baseinfo=" + baseinfo + httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body)) + if err != nil { + return nil, err + } + httpReq.Header.Set("User-Agent", PCUserAgent) + httpReq.Header.Set("Origin", "https://zt.huya.com") + httpReq.Header.Set("Referer", "https://zt.huya.com/") + httpReq.Header.Set("Content-Type", "application/octet-stream") + httpReq.Header.Set("Accept-Language", "zh-CN,zh;q=0.9") + + client := c.Client + if client == nil { + client = http.DefaultClient + } + if opt.Timeout > 0 { + var cancel context.CancelFunc + ctx, cancel = context.WithTimeout(ctx, opt.Timeout) + defer cancel() + httpReq = httpReq.WithContext(ctx) + } + + c.logf("[HTTP] POST %s.%s body=%dB", service, method, len(body)) + httpResp, err := client.Do(httpReq) + if err != nil { + return nil, err + } + defer httpResp.Body.Close() + respBody, err := io.ReadAll(httpResp.Body) + if err != nil { + return nil, err + } + if len(respBody) >= 2 && respBody[0] == 0x1f && respBody[1] == 0x8b { + gz, err := gzip.NewReader(bytes.NewReader(respBody)) + if err != nil { + return nil, err + } + respBody, err = io.ReadAll(gz) + _ = gz.Close() + if err != nil { + return nil, err + } + } + if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 { + return nil, fmt.Errorf("http status %d: %s", httpResp.StatusCode, string(respBody[:min(len(respBody), 200)])) + } + + var resp wup.Response + if err := resp.Decode(respBody); err != nil { + return nil, err + } + if respStruct != nil { + ok, err := resp.ReadStruct("tRsp", respStruct) + if err != nil { + return nil, err + } + if !ok { + return nil, fmt.Errorf("%s.%s 响应缺少 tRsp/tResp", service, method) + } + } + return &resp, nil +} + +func (c *HTTPClient) buildUser(uid int64, cookie, ua string) ActivityUserID { + return NewActivityUserID(uid, cookie, ua) +} + +func (c *HTTPClient) QueryUserScore(ctx context.Context, uid int64, cookie string, sid int32) (*GetUserScoreResp, error) { + req := &GetUserScoreReq{User: c.buildUser(uid, cookie, ActivityWebUA), SID: sid} + var resp GetUserScoreResp + _, err := c.CallRPC(ctx, ServantWebActUI, FuncGetUserScore, req, &resp, CallOptions{UID: uid, Cookie: cookie, RequestID: 2}) + return &resp, err +} + +func (c *HTTPClient) GetActPrizeList(ctx context.Context, uid int64, cookie string, sid int32) (*GetActPrizeListResp, error) { + req := &GetActPrizeListReq{User: c.buildUser(uid, cookie, ActivityWebUA), SID: sid} + var resp GetActPrizeListResp + _, err := c.CallRPC(ctx, ServantWebActUI, FuncPrizeList, req, &resp, CallOptions{UID: uid, Cookie: cookie, RequestID: 1}) + return &resp, err +} + +func (c *HTTPClient) GetUserPrizeRecords(ctx context.Context, uid int64, cookie string, sid int32) (*GetUserPrizeRecordsResp, error) { + user := c.buildUser(uid, cookie, ActivityRecordUA) + user.GUID = CookieValue(cookie, "guid") + req := &GetUserPrizeRecordsReq{User: user, SID: sid} + var resp GetUserPrizeRecordsResp + _, err := c.CallRPC(ctx, ServantWebActUI, FuncPrizeRecords, req, &resp, CallOptions{UID: uid, Cookie: cookie, RequestID: 6}) + return &resp, err +} + +func (c *HTTPClient) ScoreExchangePrize(ctx context.Context, uid int64, cookie string, sid, pid int32) (*ScoreExchangePrizeResp, error) { + req := &ScoreExchangePrizeReq{ + User: c.buildUser(uid, cookie, ActivityWebUA), + SID: sid, + PID: pid, + ClientEnv: map[string]string{}, + IsRole: 1, + } + var resp ScoreExchangePrizeResp + _, err := c.CallRPC(ctx, ServantWebActUI, FuncExchangePrize, req, &resp, CallOptions{UID: uid, Cookie: cookie, RequestID: 1}) + return &resp, err +} diff --git a/internal/huya/wss_client.go b/internal/huya/wss_client.go new file mode 100644 index 0000000..91d3492 --- /dev/null +++ b/internal/huya/wss_client.go @@ -0,0 +1,674 @@ +package huya + +import ( + "context" + "errors" + "fmt" + "net/http" + "net/url" + "strconv" + "strings" + "sync" + "time" + + "github.com/gorilla/websocket" + + "huya-go/internal/taf" + "huya-go/internal/wup" +) + +const ( + DefaultWSSHost = "77bc035c-ws.va.huya.com" + DefaultWSSOrigin = "https://zt.huya.com" + + WSSCookieUA = "webh5&0.0.1&websocket&&diypc_52775" + WSSBizUA = "web&1.0.0&huya" + WSSInitUA = "webh5&0.0.1&websocket&&h5_/index.html" +) + +type WSSClient struct { + Host string + Origin string + UserAgent string + Dialer *websocket.Dialer + Logger func(string) + CallTimeout time.Duration + + mu sync.Mutex + sessions map[string]*WSSSession +} + +type WSSSession struct { + client *WSSClient + uid int64 + cookie string + guid string + + conn *websocket.Conn + + writeMu sync.Mutex + pendingMu sync.Mutex + pending []chan rpcResult + closed chan struct{} + closeOnce sync.Once + closeErr error + + nextWUPRequestID int32 + launchGUID string + launchIP string +} + +type rpcResult struct { + body []byte + err error +} + +func NewWSSClient(logger func(string)) *WSSClient { + return &WSSClient{ + Host: DefaultWSSHost, + Origin: DefaultWSSOrigin, + UserAgent: PCUserAgent, + Logger: logger, + CallTimeout: 10 * time.Second, + sessions: map[string]*WSSSession{}, + } +} + +func (c *WSSClient) logf(format string, args ...any) { + if c.Logger != nil { + c.Logger(fmt.Sprintf(format, args...)) + } +} + +func (c *WSSClient) Close() error { + c.mu.Lock() + sessions := make([]*WSSSession, 0, len(c.sessions)) + for _, session := range c.sessions { + sessions = append(sessions, session) + } + c.sessions = map[string]*WSSSession{} + c.mu.Unlock() + + var firstErr error + for _, session := range sessions { + if err := session.Close(); err != nil && firstErr == nil { + firstErr = err + } + } + return firstErr +} + +func (c *WSSClient) session(ctx context.Context, uid int64, cookie string) (*WSSSession, error) { + key := strconv.FormatInt(uid, 10) + c.mu.Lock() + if session := c.sessions[key]; session != nil && !session.isClosed() { + c.mu.Unlock() + return session, nil + } + c.mu.Unlock() + + c.mu.Lock() + defer c.mu.Unlock() + if session := c.sessions[key]; session != nil && !session.isClosed() { + return session, nil + } + session, err := c.dialSession(ctx, uid, cookie) + if err != nil { + return nil, err + } + c.sessions[key] = session + return session, nil +} + +func (c *WSSClient) dialSession(ctx context.Context, uid int64, cookie string) (*WSSSession, error) { + host := c.Host + if host == "" { + host = DefaultWSSHost + } + origin := c.Origin + if origin == "" { + origin = DefaultWSSOrigin + } + userAgent := c.UserAgent + if userAgent == "" { + userAgent = PCUserAgent + } + + guid := CookieValue(cookie, "guid") + baseinfo, err := GenerateHTTPBaseinfo(uid, guid, NormalizeWSSCookie(cookie)) + if err != nil { + return nil, err + } + wsURL := url.URL{Scheme: "wss", Host: host, Path: "/"} + wsURL.RawQuery = "baseinfo=" + baseinfo + + dialer := c.Dialer + if dialer == nil { + dialer = &websocket.Dialer{ + HandshakeTimeout: 10 * time.Second, + EnableCompression: true, + Proxy: http.ProxyFromEnvironment, + } + } + headers := http.Header{} + headers.Set("Origin", origin) + headers.Set("User-Agent", userAgent) + headers.Set("Accept-Language", "zh-CN,zh;q=0.9") + + c.logf("[WSS] 连接 %s uid=%d", host, uid) + conn, resp, err := dialer.DialContext(ctx, wsURL.String(), headers) + if err != nil { + if resp != nil { + return nil, fmt.Errorf("wss dial: %w (status=%s)", err, resp.Status) + } + return nil, fmt.Errorf("wss dial: %w", err) + } + conn.EnableWriteCompression(true) + conn.SetReadLimit(4 << 20) + + session := &WSSSession{ + client: c, + uid: uid, + cookie: cookie, + guid: guid, + conn: conn, + closed: make(chan struct{}), + nextWUPRequestID: 8, + } + go session.readLoop() + go session.heartbeatLoop() + + if err := session.initialize(ctx); err != nil { + _ = session.Close() + return nil, err + } + return session, nil +} + +func (s *WSSSession) isClosed() bool { + select { + case <-s.closed: + return true + default: + return false + } +} + +func (s *WSSSession) Close() error { + var err error + s.closeOnce.Do(func() { + close(s.closed) + err = s.conn.Close() + s.failPending(errors.New("wss closed")) + }) + return err +} + +func (s *WSSSession) readLoop() { + for { + messageType, raw, err := s.conn.ReadMessage() + if err != nil { + s.closeWithError(err) + return + } + if messageType != websocket.BinaryMessage { + continue + } + msg, err := DecodeWSSMessage(raw) + if err != nil { + s.client.logf("[WSS] 解码消息失败: %v", err) + continue + } + switch msg.Command { + case WSSCommandRPCResponse: + s.resolveNext(rpcResult{body: msg.Body}) + case WSSCommandHeartbeatRecv: + // 心跳响应无需处理。 + default: + s.client.logf("[WSS] 收到 cmd=0x%02x seq=0x%08x body=%dB", msg.Command, msg.Sequence, len(msg.Body)) + } + } +} + +func (s *WSSSession) heartbeatLoop() { + ticker := time.NewTicker(8 * time.Second) + defer ticker.Stop() + for { + select { + case <-ticker.C: + ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) + _ = s.sendHeartbeat(ctx) + cancel() + case <-s.closed: + return + } + } +} + +func (s *WSSSession) closeWithError(err error) { + s.closeOnce.Do(func() { + s.closeErr = err + close(s.closed) + _ = s.conn.Close() + s.failPending(err) + }) +} + +func (s *WSSSession) failPending(err error) { + s.pendingMu.Lock() + pending := s.pending + s.pending = nil + s.pendingMu.Unlock() + for _, ch := range pending { + ch <- rpcResult{err: err} + } +} + +func (s *WSSSession) resolveNext(result rpcResult) { + s.pendingMu.Lock() + if len(s.pending) == 0 { + s.pendingMu.Unlock() + return + } + ch := s.pending[0] + copy(s.pending, s.pending[1:]) + s.pending = s.pending[:len(s.pending)-1] + s.pendingMu.Unlock() + ch <- result +} + +func (s *WSSSession) removePending(target chan rpcResult) { + s.pendingMu.Lock() + defer s.pendingMu.Unlock() + for i, ch := range s.pending { + if ch == target { + copy(s.pending[i:], s.pending[i+1:]) + s.pending = s.pending[:len(s.pending)-1] + return + } + } +} + +func (s *WSSSession) writeMessage(ctx context.Context, msg WSSMessage) error { + s.writeMu.Lock() + defer s.writeMu.Unlock() + if deadline, ok := ctx.Deadline(); ok { + _ = s.conn.SetWriteDeadline(deadline) + defer s.conn.SetWriteDeadline(time.Time{}) + } + return s.conn.WriteMessage(websocket.BinaryMessage, msg.Encode()) +} + +func (s *WSSSession) callRaw(ctx context.Context, msg WSSMessage) ([]byte, error) { + ch := make(chan rpcResult, 1) + s.pendingMu.Lock() + s.pending = append(s.pending, ch) + s.pendingMu.Unlock() + + if err := s.writeMessage(ctx, msg); err != nil { + s.removePending(ch) + return nil, err + } + select { + case result := <-ch: + return result.body, result.err + case <-ctx.Done(): + s.removePending(ch) + return nil, ctx.Err() + case <-s.closed: + if s.closeErr != nil { + return nil, s.closeErr + } + return nil, errors.New("wss closed") + } +} + +func (s *WSSSession) initialize(ctx context.Context) error { + if err := s.sendHeartbeat(ctx); err != nil { + return err + } + if err := s.callWSLaunch(ctx); err != nil { + return err + } + if err := s.callGetConfig(ctx); err != nil { + s.client.logf("[WSS] getConfig 失败但继续: %v", err) + } + if s.launchGUID != "" { + if err := s.sendRegister(ctx, s.launchGUID); err != nil { + return err + } + } + return s.sendConfirm(ctx) +} + +func (s *WSSSession) withTimeout(ctx context.Context) (context.Context, context.CancelFunc) { + if _, ok := ctx.Deadline(); ok || s.client.CallTimeout <= 0 { + return ctx, func() {} + } + return context.WithTimeout(ctx, s.client.CallTimeout) +} + +func (s *WSSSession) sendHeartbeat(ctx context.Context) error { + w := taf.NewWriter() + if err := w.WriteHead(0, taf.TypeList); err != nil { + return err + } + if err := w.WriteInt32(0, 1); err != nil { + return err + } + if err := w.WriteString(0, "live:0"); err != nil { + return err + } + if err := w.WriteString(1, ""); err != nil { + return err + } + body := append(append([]byte{}, w.Bytes()...), wssTailBytes...) + return s.writeMessage(ctx, WSSMessage{Command: WSSCommandHeartbeatSend, Sequence: wssSeqHeartbeat, Body: body}) +} + +func (s *WSSSession) callWSLaunch(ctx context.Context) error { + req := &wsLaunchReq{} + wupReq := wup.NewRequest("launch", "wsLaunch", -1) + wupReq.Timeout = 0 + if err := wupReq.WriteStruct("tReq", req); err != nil { + return err + } + data, err := wupReq.Encode() + if err != nil { + return err + } + ctx, cancel := s.withTimeout(ctx) + defer cancel() + body, err := s.callRaw(ctx, WSSMessage{ + Command: WSSCommandRPCRequest, + Sequence: wssSeqWSLaunch, + Body: encodeWSSRPCBody(data), + }) + if err != nil { + return err + } + var resp wup.Response + if err := resp.Decode(extractWUPFromWSSBody(body)); err != nil { + return err + } + var launch wsLaunchResp + ok, err := resp.ReadStruct("tRsp", &launch) + if err != nil { + return err + } + if !ok { + return errors.New("wsLaunch 响应缺少 tRsp") + } + s.launchGUID = launch.GUID + s.launchIP = launch.ClientIP + s.client.logf("[WSS] wsLaunch guid=%s ip=%s", launch.GUID, launch.ClientIP) + return nil +} + +func (s *WSSSession) callGetConfig(ctx context.Context) error { + req := &getConfigReq{} + wupReq := wup.NewRequest("mobileui", "getConfig", 7) + wupReq.Timeout = 0 + if err := wupReq.WriteStruct("tReq", req); err != nil { + return err + } + data, err := wupReq.Encode() + if err != nil { + return err + } + ctx, cancel := s.withTimeout(ctx) + defer cancel() + _, err = s.callRaw(ctx, WSSMessage{ + Command: WSSCommandRPCRequest, + Sequence: wssSeqGetConfig, + Body: encodeWSSRPCBody(data), + }) + return err +} + +func (s *WSSSession) sendRegister(ctx context.Context, launchGUID string) error { + w := taf.NewWriter() + if err := w.WriteString(0, "HUYA&ZH&2052"); err != nil { + return err + } + if err := w.WriteString(1, launchGUID); err != nil { + return err + } + if err := w.WriteInt32(2, 0); err != nil { + return err + } + if err := w.WriteInt32(3, 0); err != nil { + return err + } + if err := w.WriteStructBegin(6); err != nil { + return err + } + if err := w.WriteMapStringString(0, nil); err != nil { + return err + } + if err := w.WriteMapStringString(1, nil); err != nil { + return err + } + if err := w.WriteInt32(3, 0); err != nil { + return err + } + if err := w.WriteStructEnd(); err != nil { + return err + } + if err := w.WriteMapStringString(7, nil); err != nil { + return err + } + if err := w.WriteInt32(8, 0); err != nil { + return err + } + body := append(append([]byte{}, w.Bytes()...), wssTailBytes...) + return s.writeMessage(ctx, WSSMessage{Command: WSSCommandRegister, Sequence: wssSeqRegister, Body: body}) +} + +func (s *WSSSession) sendConfirm(ctx context.Context) error { + w := taf.NewWriter() + if err := w.WriteMapStringString(0, nil); err != nil { + return err + } + body := append(append([]byte{}, w.Bytes()...), wssTailBytes...) + return s.writeMessage(ctx, WSSMessage{Command: WSSCommandConfirmSend, Sequence: wssSeqConfirm, Body: body}) +} + +func (s *WSSSession) nextRequestID() int32 { + id := s.nextWUPRequestID + s.nextWUPRequestID++ + return id +} + +func (s *WSSSession) callRPC(ctx context.Context, service, method string, reqStruct taf.Marshaler, respStruct taf.Unmarshaler) (*wup.Response, error) { + wupReq := wup.NewRequest(service, method, s.nextRequestID()) + wupReq.Timeout = 0 + if err := wupReq.WriteStruct("tReq", reqStruct); err != nil { + return nil, err + } + data, err := wupReq.Encode() + if err != nil { + return nil, err + } + ctx, cancel := s.withTimeout(ctx) + defer cancel() + s.client.logf("[WSS] RPC %s.%s body=%dB", service, method, len(data)) + body, err := s.callRaw(ctx, WSSMessage{ + Command: WSSCommandRPCRequest, + Sequence: wssSeqBusiness, + Body: encodeWSSRPCBody(data), + }) + if err != nil { + return nil, err + } + var resp wup.Response + if err := resp.Decode(extractWUPFromWSSBody(body)); err != nil { + return nil, err + } + if respStruct != nil { + ok, err := resp.ReadStruct("tRsp", respStruct) + if err != nil { + return nil, err + } + if !ok { + return nil, fmt.Errorf("%s.%s 响应缺少 tRsp/tResp", service, method) + } + } + return &resp, nil +} + +func (c *WSSClient) buildUser(uid int64, cookie string) ActivityUserID { + user := NewActivityUserID(uid, NormalizeWSSCookie(cookie), WSSBizUA) + user.GUID = "" + user.Token = "" + user.DeviceInfo = "" + return user +} + +func (c *WSSClient) QueryUserScore(ctx context.Context, uid int64, cookie string, sid int32) (*GetUserScoreResp, error) { + session, err := c.session(ctx, uid, cookie) + if err != nil { + return nil, err + } + req := &GetUserScoreReq{User: c.buildUser(uid, cookie), SID: sid} + var resp GetUserScoreResp + _, err = session.callRPC(ctx, ServantWebActUI, FuncGetUserScore, req, &resp) + return &resp, err +} + +func (c *WSSClient) GetActPrizeList(ctx context.Context, uid int64, cookie string, sid int32) (*GetActPrizeListResp, error) { + session, err := c.session(ctx, uid, cookie) + if err != nil { + return nil, err + } + req := &GetActPrizeListReq{User: c.buildUser(uid, cookie), SID: sid} + var resp GetActPrizeListResp + _, err = session.callRPC(ctx, ServantWebActUI, FuncPrizeList, req, &resp) + return &resp, err +} + +func (c *WSSClient) GetUserPrizeRecords(ctx context.Context, uid int64, cookie string, sid int32) (*GetUserPrizeRecordsResp, error) { + session, err := c.session(ctx, uid, cookie) + if err != nil { + return nil, err + } + req := &GetUserPrizeRecordsReq{User: c.buildUser(uid, cookie), SID: sid} + var resp GetUserPrizeRecordsResp + _, err = session.callRPC(ctx, ServantWebActUI, FuncPrizeRecords, req, &resp) + return &resp, err +} + +func (c *WSSClient) ScoreExchangePrize(ctx context.Context, uid int64, cookie string, sid, pid int32) (*ScoreExchangePrizeResp, error) { + session, err := c.session(ctx, uid, cookie) + if err != nil { + return nil, err + } + req := &ScoreExchangePrizeReq{ + User: c.buildUser(uid, cookie), + SID: sid, + PID: pid, + ClientEnv: map[string]string{}, + IsRole: 1, + } + var resp ScoreExchangePrizeResp + _, err = session.callRPC(ctx, ServantWebActUI, FuncExchangePrize, req, &resp) + return &resp, err +} + +func NormalizeWSSCookie(cookie string) string { + cookie = NormalizeCookie(cookie) + pairs := CookiePairs(cookie) + out := []string{"huya_ua=" + WSSCookieUA} + for _, pair := range pairs { + if strings.EqualFold(pair.Key, "huya_ua") { + continue + } + out = append(out, pair.Key+"="+pair.Value) + } + return strings.Join(out, "; ") +} + +type wsLaunchReq struct{} + +func (r *wsLaunchReq) WriteTo(w *taf.Writer) error { + if err := w.WriteInt64(0, 0); err != nil { + return err + } + if err := w.WriteString(1, ""); err != nil { + return err + } + if err := w.WriteString(2, WSSInitUA); err != nil { + return err + } + if err := w.WriteString(3, "HUYA&ZH&2052"); err != nil { + return err + } + if err := w.WriteStructBegin(4); err != nil { + return err + } + for i := 0; i < 5; i++ { + if err := w.WriteString(i, ""); err != nil { + return err + } + } + return w.WriteStructEnd() +} + +type wsLaunchResp struct { + GUID string + ClientIP string +} + +func (r *wsLaunchResp) ReadFrom(rd *taf.Reader) error { + var err error + if r.GUID, err = rd.ReadString(0, false, r.GUID); err != nil { + return err + } + r.ClientIP, err = rd.ReadString(1, false, r.ClientIP) + return err +} + +type getConfigReq struct{} + +func (r *getConfigReq) WriteTo(w *taf.Writer) error { + if err := w.WriteStructBegin(0); err != nil { + return err + } + if err := w.WriteInt64(0, 0); err != nil { + return err + } + if err := w.WriteString(1, ""); err != nil { + return err + } + if err := w.WriteString(2, ""); err != nil { + return err + } + if err := w.WriteString(3, WSSInitUA); err != nil { + return err + } + if err := w.WriteString(4, ""); err != nil { + return err + } + if err := w.WriteInt32(5, 0); err != nil { + return err + } + if err := w.WriteString(6, ""); err != nil { + return err + } + if err := w.WriteString(7, ""); err != nil { + return err + } + if err := w.WriteStructEnd(); err != nil { + return err + } + if err := w.WriteMapStringString(1, nil); err != nil { + return err + } + if err := w.WriteString(2, "huya"); err != nil { + return err + } + if err := w.WriteHead(3, taf.TypeList); err != nil { + return err + } + return w.WriteInt32(0, 0) +} diff --git a/internal/huya/wss_message.go b/internal/huya/wss_message.go new file mode 100644 index 0000000..68fab96 --- /dev/null +++ b/internal/huya/wss_message.go @@ -0,0 +1,113 @@ +package huya + +import ( + "encoding/binary" + "fmt" + "math/rand" +) + +const ( + WSSCommandRPCRequest byte = 0x03 + WSSCommandRPCResponse byte = 0x04 + WSSCommandAuth byte = 0x0a + WSSCommandHeartbeatSend byte = 0x10 + WSSCommandHeartbeatRecv byte = 0x11 + WSSCommandConfirmSend byte = 0x17 + WSSCommandRegister byte = 0x21 + + wssSeqHeartbeat uint32 = 0x1d00000d + wssSeqWSLaunch uint32 = 0x1d000078 + wssSeqGetConfig uint32 = 0x1d000076 + wssSeqRegister uint32 = 0x1d00003c + wssSeqConfirm uint32 = 0x1d000002 + wssSeqBusiness uint32 = 0x1d000106 +) + +var ( + wssTailBytes = []byte{0x2c, 0x36, 0x00, 0x4c, 0x5c, 0x66, 0x00} + wssBigTailSuffix = []byte{0x4c, 0x5c, 0x66, 0x00} +) + +// WSSMessage 是虎牙 WebSocketCommand 的 Go 表达。 +// +// 外层格式来自浏览器/参考项目： +// +// 1B version(0) + 1B command + 4B sequence + body +type WSSMessage struct { + Command byte + Sequence uint32 + Body []byte +} + +func (m WSSMessage) Encode() []byte { + out := make([]byte, 6+len(m.Body)) + out[0] = 0 + out[1] = m.Command + binary.BigEndian.PutUint32(out[2:6], m.Sequence) + copy(out[6:], m.Body) + return out +} + +func DecodeWSSMessage(data []byte) (WSSMessage, error) { + if len(data) < 6 { + return WSSMessage{}, fmt.Errorf("wss: 消息太短: %d", len(data)) + } + return WSSMessage{ + Command: data[1], + Sequence: binary.BigEndian.Uint32(data[2:6]), + Body: append([]byte(nil), data[6:]...), + }, nil +} + +func encodeWSSRPCBody(wupData []byte) []byte { + if len(wupData) < 4 { + out := append([]byte{}, wupData...) + return append(out, wssTailBytes...) + } + declaredLen := int(binary.BigEndian.Uint32(wupData[:4])) + wupBody := wupData + if declaredLen == len(wupData) { + wupBody = wupData[4:] + } + if len(wupBody) <= 0xff { + out := append([]byte{}, wupData...) + return append(out, wssTailBytes...) + } + + trace := NewWSSBigTailTrace() + packetLen := len(wupData) + out := make([]byte, 0, 1+4+len(wupBody)+len(trace)) + out = append(out, byte(packetLen&0xff)) + var lenBuf [4]byte + binary.BigEndian.PutUint32(lenBuf[:], uint32(packetLen)) + out = append(out, lenBuf[:]...) + out = append(out, wupBody...) + out = append(out, trace...) + return out +} + +func extractWUPFromWSSBody(body []byte) []byte { + if len(body) < 5 { + return body + } + // 大包格式: [1B prefix][4B wup_len][裸 WUP body][tail] + wupLen := int(binary.BigEndian.Uint32(body[1:5])) + if 5+wupLen <= len(body) && len(body) >= 7 && body[5] == 0x10 && body[6] == 0x03 { + return body[5 : 5+wupLen] + } + // 小包格式: [4B total_len][WUP body][tail] + totalLen := int(binary.BigEndian.Uint32(body[:4])) + if 8 <= totalLen && totalLen <= len(body) && body[4] == 0x10 && body[5] == 0x03 { + return body[:totalLen] + } + if 5+wupLen <= len(body) { + return body[5 : 5+wupLen] + } + return body +} + +func NewWSSBigTailTrace() []byte { + trace := lowerHex16(rand.Uint64()) + out := []byte(",6%" + trace + ":" + trace + ":0:3") + return append(out, wssBigTailSuffix...) +} diff --git a/internal/sniper/sniper.go b/internal/sniper/sniper.go new file mode 100644 index 0000000..b8286e9 --- /dev/null +++ b/internal/sniper/sniper.go @@ -0,0 +1,130 @@ +package sniper + +import ( + "context" + "strings" + "sync" + "time" + + "huya-go/internal/huya" +) + +type Account struct { + UID int64 `json:"uid"` + Cookie string `json:"-"` +} + +type Target struct { + PID int32 `json:"pid"` + Name string `json:"name"` +} + +type Config struct { + SID int32 + Loops int + Delay time.Duration + Concurrency int + StopAfterSuccess bool +} + +type Result struct { + Loop int `json:"loop"` + UID int64 `json:"uid"` + Action string `json:"action"` + Prize *huya.PrizeInfo `json:"prize,omitempty"` + Exchange *huya.ScoreExchangePrizeResp `json:"exchange,omitempty"` + Error string `json:"error,omitempty"` +} + +type Runner struct { + Client huya.ActivityClient +} + +func (r *Runner) Run(ctx context.Context, accounts []Account, target Target, cfg Config, emit func(Result)) error { + if cfg.Loops <= 0 { + cfg.Loops = 1 + } + if cfg.Delay <= 0 { + cfg.Delay = 150 * time.Millisecond + } + if cfg.Concurrency <= 0 { + cfg.Concurrency = 1 + } + var client huya.ActivityClient = r.Client + if client == nil { + client = huya.NewHTTPClient(nil) + } + + ctx, cancel := context.WithCancel(ctx) + defer cancel() + + for loop := 1; loop <= cfg.Loops; loop++ { + if ctx.Err() != nil { + return ctx.Err() + } + sem := make(chan struct{}, cfg.Concurrency) + var wg sync.WaitGroup + for _, account := range accounts { + account := account + wg.Add(1) + go func() { + defer wg.Done() + select { + case sem <- struct{}{}: + defer func() { <-sem }() + case <-ctx.Done(): + return + } + result := r.tryAccount(ctx, client, account, target, cfg.SID, loop) + if emit != nil { + emit(result) + } + if cfg.StopAfterSuccess && result.Exchange != nil && result.Exchange.Success() { + cancel() + } + }() + } + wg.Wait() + if ctx.Err() != nil { + return ctx.Err() + } + if loop < cfg.Loops { + timer := time.NewTimer(cfg.Delay) + select { + case <-timer.C: + case <-ctx.Done(): + timer.Stop() + return ctx.Err() + } + } + } + return nil +} + +func (r *Runner) tryAccount(ctx context.Context, client huya.ActivityClient, account Account, target Target, sid int32, loop int) Result { + list, err := client.GetActPrizeList(ctx, account.UID, account.Cookie, sid) + if err != nil { + return Result{Loop: loop, UID: account.UID, Action: "list_error", Error: err.Error()} + } + prize := matchPrize(list.Prizes, target) + if prize == nil { + return Result{Loop: loop, UID: account.UID, Action: "not_found"} + } + exchange, err := client.ScoreExchangePrize(ctx, account.UID, account.Cookie, sid, int32(prize.ID)) + if err != nil { + return Result{Loop: loop, UID: account.UID, Action: "exchange_error", Prize: prize, Error: err.Error()} + } + return Result{Loop: loop, UID: account.UID, Action: "exchange", Prize: prize, Exchange: exchange} +} + +func matchPrize(prizes []huya.PrizeInfo, target Target) *huya.PrizeInfo { + for i := range prizes { + if target.PID > 0 && int32(prizes[i].ID) == target.PID { + return &prizes[i] + } + if target.PID == 0 && target.Name != "" && strings.Contains(prizes[i].Name, target.Name) { + return &prizes[i] + } + } + return nil +} diff --git a/internal/taf/reader.go b/internal/taf/reader.go new file mode 100644 index 0000000..d384ea9 --- /dev/null +++ b/internal/taf/reader.go @@ -0,0 +1,420 @@ +package taf + +import ( + "bytes" + "encoding/binary" + "errors" + "fmt" + "io" + "math" +) + +// Reader 负责从 TAF/JCE 字节流中按 tag 顺序读取字段。 +type Reader struct { + buf *bytes.Reader +} + +func NewReader(data []byte) *Reader { + return &Reader{buf: bytes.NewReader(data)} +} + +func (r *Reader) Position() int64 { + pos, _ := r.buf.Seek(0, io.SeekCurrent) + return pos +} + +func (r *Reader) Seek(pos int64) error { + _, err := r.buf.Seek(pos, io.SeekStart) + return err +} + +func (r *Reader) ReadHead() (int, Type, error) { + b, err := r.buf.ReadByte() + if err != nil { + return 0, 0, err + } + tag := int((b >> 4) & 0x0f) + typ := Type(b & 0x0f) + if tag == 15 { + ext, err := r.buf.ReadByte() + if err != nil { + return 0, 0, err + } + tag = int(ext) + } + return tag, typ, nil +} + +func (r *Reader) PeekHead() (int, Type, error) { + pos := r.Position() + tag, typ, err := r.ReadHead() + _ = r.Seek(pos) + return tag, typ, err +} + +func (r *Reader) ReadIntValue(typ Type) (int64, error) { + switch typ { + case TypeZero: + return 0, nil + case TypeInt8: + b, err := r.buf.ReadByte() + return int64(int8(b)), err + case TypeInt16: + var b [2]byte + if _, err := io.ReadFull(r.buf, b[:]); err != nil { + return 0, err + } + return int64(int16(binary.BigEndian.Uint16(b[:]))), nil + case TypeInt32: + var b [4]byte + if _, err := io.ReadFull(r.buf, b[:]); err != nil { + return 0, err + } + return int64(int32(binary.BigEndian.Uint32(b[:]))), nil + case TypeInt64: + var b [8]byte + if _, err := io.ReadFull(r.buf, b[:]); err != nil { + return 0, err + } + return int64(binary.BigEndian.Uint64(b[:])), nil + default: + return 0, fmt.Errorf("taf: 期望整数类型，实际 0x%02x", byte(typ)) + } +} + +func (r *Reader) ReadStringValue(typ Type) (string, error) { + var n uint32 + switch typ { + case TypeString1: + b, err := r.buf.ReadByte() + if err != nil { + return "", err + } + n = uint32(b) + case TypeString4: + var b [4]byte + if _, err := io.ReadFull(r.buf, b[:]); err != nil { + return "", err + } + n = binary.BigEndian.Uint32(b[:]) + default: + return "", fmt.Errorf("taf: 期望字符串类型，实际 0x%02x", byte(typ)) + } + raw := make([]byte, n) + if _, err := io.ReadFull(r.buf, raw); err != nil { + return "", err + } + return string(raw), nil +} + +func (r *Reader) ReadBytesValue(typ Type) ([]byte, error) { + if typ != TypeSimpleList { + return nil, fmt.Errorf("taf: 期望 bytes，实际 0x%02x", byte(typ)) + } + _, itemType, err := r.ReadHead() + if err != nil { + return nil, err + } + if itemType != TypeInt8 { + return nil, fmt.Errorf("taf: bytes 元素类型不是 int8: 0x%02x", byte(itemType)) + } + n, err := r.readLength() + if err != nil { + return nil, err + } + if n < 0 || n > math.MaxInt32 { + return nil, fmt.Errorf("taf: bytes 长度异常: %d", n) + } + raw := make([]byte, int(n)) + _, err = io.ReadFull(r.buf, raw) + return raw, err +} + +func (r *Reader) Skip(typ Type) error { + switch typ { + case TypeZero: + return nil + case TypeInt8: + _, err := r.buf.ReadByte() + return err + case TypeInt16: + _, err := r.buf.Seek(2, io.SeekCurrent) + return err + case TypeInt32, TypeFloat: + _, err := r.buf.Seek(4, io.SeekCurrent) + return err + case TypeInt64, TypeDouble: + _, err := r.buf.Seek(8, io.SeekCurrent) + return err + case TypeString1: + b, err := r.buf.ReadByte() + if err != nil { + return err + } + _, err = r.buf.Seek(int64(b), io.SeekCurrent) + return err + case TypeString4: + var b [4]byte + if _, err := io.ReadFull(r.buf, b[:]); err != nil { + return err + } + _, err := r.buf.Seek(int64(binary.BigEndian.Uint32(b[:])), io.SeekCurrent) + return err + case TypeMap: + n, err := r.readLength() + if err != nil { + return err + } + for i := int64(0); i < n; i++ { + if _, kt, err := r.ReadHead(); err != nil { + return err + } else if err := r.Skip(kt); err != nil { + return err + } + if _, vt, err := r.ReadHead(); err != nil { + return err + } else if err := r.Skip(vt); err != nil { + return err + } + } + return nil + case TypeList: + n, err := r.readLength() + if err != nil { + return err + } + for i := int64(0); i < n; i++ { + if _, it, err := r.ReadHead(); err != nil { + return err + } else if err := r.Skip(it); err != nil { + return err + } + } + return nil + case TypeStructBegin: + return r.SkipToStructEnd() + case TypeStructEnd: + return nil + case TypeSimpleList: + _, itemType, err := r.ReadHead() + if err != nil { + return err + } + if itemType != TypeInt8 { + return fmt.Errorf("taf: simple list 元素类型异常: 0x%02x", byte(itemType)) + } + n, err := r.readLength() + if err != nil { + return err + } + _, err = r.buf.Seek(n, io.SeekCurrent) + return err + default: + return fmt.Errorf("taf: 未知字段类型 0x%02x", byte(typ)) + } +} + +func (r *Reader) readLength() (int64, error) { + _, typ, err := r.ReadHead() + if err != nil { + return 0, err + } + return r.ReadIntValue(typ) +} + +func (r *Reader) findTag(target int, required bool) (Type, bool, error) { + for { + pos := r.Position() + tag, typ, err := r.ReadHead() + if err != nil { + if errors.Is(err, io.EOF) && !required { + return 0, false, nil + } + return 0, false, err + } + if typ == TypeStructEnd { + _ = r.Seek(pos) + if required { + return 0, false, fmt.Errorf("taf: 未找到 tag=%d，已到结构尾", target) + } + return 0, false, nil + } + if tag == target { + return typ, true, nil + } + if tag > target { + _ = r.Seek(pos) + if required { + return 0, false, fmt.Errorf("taf: 未找到 tag=%d，遇到 tag=%d", target, tag) + } + return 0, false, nil + } + if err := r.Skip(typ); err != nil { + return 0, false, err + } + } +} + +func (r *Reader) ReadInt64(tag int, required bool, def int64) (int64, error) { + typ, ok, err := r.findTag(tag, required) + if err != nil || !ok { + return def, err + } + return r.ReadIntValue(typ) +} + +func (r *Reader) ReadInt32(tag int, required bool, def int32) (int32, error) { + value, err := r.ReadInt64(tag, required, int64(def)) + return int32(value), err +} + +func (r *Reader) ReadString(tag int, required bool, def string) (string, error) { + typ, ok, err := r.findTag(tag, required) + if err != nil || !ok { + return def, err + } + return r.ReadStringValue(typ) +} + +func (r *Reader) ReadBytes(tag int, required bool, def []byte) ([]byte, error) { + typ, ok, err := r.findTag(tag, required) + if err != nil || !ok { + return def, err + } + return r.ReadBytesValue(typ) +} + +func (r *Reader) ReadMapStringString(tag int, required bool) (map[string]string, error) { + typ, ok, err := r.findTag(tag, required) + if err != nil || !ok { + return map[string]string{}, err + } + if typ != TypeMap { + return nil, fmt.Errorf("taf: tag=%d 不是 map: 0x%02x", tag, byte(typ)) + } + n, err := r.readLength() + if err != nil { + return nil, err + } + out := make(map[string]string, n) + for i := int64(0); i < n; i++ { + _, kt, err := r.ReadHead() + if err != nil { + return nil, err + } + k, err := r.ReadStringValue(kt) + if err != nil { + return nil, err + } + _, vt, err := r.ReadHead() + if err != nil { + return nil, err + } + v, err := r.ReadStringValue(vt) + if err != nil { + return nil, err + } + out[k] = v + } + return out, nil +} + +func (r *Reader) ReadMapStringBytes(tag int, required bool) (map[string][]byte, error) { + typ, ok, err := r.findTag(tag, required) + if err != nil || !ok { + return map[string][]byte{}, err + } + if typ != TypeMap { + return nil, fmt.Errorf("taf: tag=%d 不是 map: 0x%02x", tag, byte(typ)) + } + n, err := r.readLength() + if err != nil { + return nil, err + } + out := make(map[string][]byte, n) + for i := int64(0); i < n; i++ { + _, kt, err := r.ReadHead() + if err != nil { + return nil, err + } + k, err := r.ReadStringValue(kt) + if err != nil { + return nil, err + } + _, vt, err := r.ReadHead() + if err != nil { + return nil, err + } + v, err := r.ReadBytesValue(vt) + if err != nil { + return nil, err + } + out[k] = v + } + return out, nil +} + +func (r *Reader) ReadStruct(tag int, required bool, obj Unmarshaler) (bool, error) { + typ, ok, err := r.findTag(tag, required) + if err != nil || !ok { + return false, err + } + if typ != TypeStructBegin { + return false, fmt.Errorf("taf: tag=%d 不是结构体: 0x%02x", tag, byte(typ)) + } + if err := obj.ReadFrom(r); err != nil { + return false, err + } + return true, r.SkipToStructEnd() +} + +func (r *Reader) ReadListStruct(tag int, required bool, factory func() Unmarshaler) ([]Unmarshaler, error) { + typ, ok, err := r.findTag(tag, required) + if err != nil || !ok { + return nil, err + } + if typ != TypeList { + return nil, fmt.Errorf("taf: tag=%d 不是 list: 0x%02x", tag, byte(typ)) + } + n, err := r.readLength() + if err != nil { + return nil, err + } + out := make([]Unmarshaler, 0, n) + for i := int64(0); i < n; i++ { + _, it, err := r.ReadHead() + if err != nil { + return nil, err + } + if it != TypeStructBegin { + if err := r.Skip(it); err != nil { + return nil, err + } + continue + } + obj := factory() + if err := obj.ReadFrom(r); err != nil { + return nil, err + } + if err := r.SkipToStructEnd(); err != nil { + return nil, err + } + out = append(out, obj) + } + return out, nil +} + +func (r *Reader) SkipToStructEnd() error { + for { + _, typ, err := r.ReadHead() + if err != nil { + return err + } + if typ == TypeStructEnd { + return nil + } + if err := r.Skip(typ); err != nil { + return err + } + } +} diff --git a/internal/taf/taf_test.go b/internal/taf/taf_test.go new file mode 100644 index 0000000..0418d86 --- /dev/null +++ b/internal/taf/taf_test.go @@ -0,0 +1,31 @@ +package taf_test + +import ( + "testing" + + "huya-go/internal/huya" + "huya-go/internal/taf" +) + +func TestStructRoundTrip(t *testing.T) { + user := &huya.ActivityUserID{ + UID: 123456, + GUID: "guid-1", + HuyaUA: huya.ActivityWebUA, + Cookie: "yyuid=123456;", + TokenType: 0, + } + w := taf.NewWriter() + if err := w.WriteStruct(0, user); err != nil { + t.Fatal(err) + } + var got huya.ActivityUserID + r := taf.NewReader(w.Bytes()) + ok, err := r.ReadStruct(0, true, &got) + if err != nil { + t.Fatal(err) + } + if !ok || got.UID != user.UID || got.GUID != user.GUID || got.HuyaUA != user.HuyaUA { + t.Fatalf("round trip mismatch: %#v", got) + } +} diff --git a/internal/taf/types.go b/internal/taf/types.go new file mode 100644 index 0000000..84e5d1f --- /dev/null +++ b/internal/taf/types.go @@ -0,0 +1,31 @@ +package taf + +// Type 是虎牙前端使用的 TAF/JCE 字段类型。 +type Type byte + +const ( + TypeInt8 Type = 0x00 + TypeInt16 Type = 0x01 + TypeInt32 Type = 0x02 + TypeInt64 Type = 0x03 + TypeFloat Type = 0x04 + TypeDouble Type = 0x05 + TypeString1 Type = 0x06 + TypeString4 Type = 0x07 + TypeMap Type = 0x08 + TypeList Type = 0x09 + TypeStructBegin Type = 0x0a + TypeStructEnd Type = 0x0b + TypeZero Type = 0x0c + TypeSimpleList Type = 0x0d +) + +// Marshaler 表示可编码成 TAF 结构体字段的对象。 +type Marshaler interface { + WriteTo(*Writer) error +} + +// Unmarshaler 表示可从 TAF 结构体字段读取自身的对象。 +type Unmarshaler interface { + ReadFrom(*Reader) error +} diff --git a/internal/taf/writer.go b/internal/taf/writer.go new file mode 100644 index 0000000..2453245 --- /dev/null +++ b/internal/taf/writer.go @@ -0,0 +1,232 @@ +package taf + +import ( + "bytes" + "encoding/binary" + "fmt" + "math" +) + +// Writer 负责按 TAF/JCE 格式编码字段。 +type Writer struct { + buf bytes.Buffer +} + +func NewWriter() *Writer { + return &Writer{} +} + +func (w *Writer) Bytes() []byte { + return w.buf.Bytes() +} + +func (w *Writer) WriteHead(tag int, typ Type) error { + if tag < 0 || tag > 255 { + return fmt.Errorf("taf: tag 超出范围: %d", tag) + } + if tag < 15 { + return w.buf.WriteByte(byte(tag<<4) | byte(typ)) + } + if err := w.buf.WriteByte(0xf0 | byte(typ)); err != nil { + return err + } + return w.buf.WriteByte(byte(tag)) +} + +func (w *Writer) WriteInt8(tag int, value int64) error { + if value == 0 { + return w.WriteHead(tag, TypeZero) + } + if value < math.MinInt8 || value > math.MaxInt8 { + return fmt.Errorf("taf: int8 溢出: %d", value) + } + if err := w.WriteHead(tag, TypeInt8); err != nil { + return err + } + return w.buf.WriteByte(byte(int8(value))) +} + +func (w *Writer) WriteInt16(tag int, value int64) error { + if value >= math.MinInt8 && value <= math.MaxInt8 { + return w.WriteInt8(tag, value) + } + if value < math.MinInt16 || value > math.MaxInt16 { + return fmt.Errorf("taf: int16 溢出: %d", value) + } + if err := w.WriteHead(tag, TypeInt16); err != nil { + return err + } + var b [2]byte + binary.BigEndian.PutUint16(b[:], uint16(int16(value))) + _, err := w.buf.Write(b[:]) + return err +} + +func (w *Writer) WriteInt32(tag int, value int64) error { + if value >= math.MinInt16 && value <= math.MaxInt16 { + return w.WriteInt16(tag, value) + } + if value < math.MinInt32 || value > math.MaxInt32 { + return fmt.Errorf("taf: int32 溢出: %d", value) + } + if err := w.WriteHead(tag, TypeInt32); err != nil { + return err + } + var b [4]byte + binary.BigEndian.PutUint32(b[:], uint32(int32(value))) + _, err := w.buf.Write(b[:]) + return err +} + +func (w *Writer) WriteInt64(tag int, value int64) error { + if value >= math.MinInt32 && value <= math.MaxInt32 { + return w.WriteInt32(tag, value) + } + if err := w.WriteHead(tag, TypeInt64); err != nil { + return err + } + var b [8]byte + binary.BigEndian.PutUint64(b[:], uint64(value)) + _, err := w.buf.Write(b[:]) + return err +} + +func (w *Writer) WriteBool(tag int, value bool) error { + if value { + return w.WriteInt8(tag, 1) + } + return w.WriteInt8(tag, 0) +} + +func (w *Writer) WriteFloat(tag int, value float32) error { + if err := w.WriteHead(tag, TypeFloat); err != nil { + return err + } + var b [4]byte + binary.BigEndian.PutUint32(b[:], math.Float32bits(value)) + _, err := w.buf.Write(b[:]) + return err +} + +func (w *Writer) WriteDouble(tag int, value float64) error { + if err := w.WriteHead(tag, TypeDouble); err != nil { + return err + } + var b [8]byte + binary.BigEndian.PutUint64(b[:], math.Float64bits(value)) + _, err := w.buf.Write(b[:]) + return err +} + +func (w *Writer) WriteString(tag int, value string) error { + raw := []byte(value) + if len(raw) > math.MaxUint8 { + if err := w.WriteHead(tag, TypeString4); err != nil { + return err + } + var b [4]byte + binary.BigEndian.PutUint32(b[:], uint32(len(raw))) + if _, err := w.buf.Write(b[:]); err != nil { + return err + } + _, err := w.buf.Write(raw) + return err + } + if err := w.WriteHead(tag, TypeString1); err != nil { + return err + } + if err := w.buf.WriteByte(byte(len(raw))); err != nil { + return err + } + _, err := w.buf.Write(raw) + return err +} + +func (w *Writer) WriteBytes(tag int, value []byte) error { + if err := w.WriteHead(tag, TypeSimpleList); err != nil { + return err + } + if err := w.WriteHead(0, TypeInt8); err != nil { + return err + } + if err := w.WriteInt32(0, int64(len(value))); err != nil { + return err + } + _, err := w.buf.Write(value) + return err +} + +func (w *Writer) WriteStructBegin(tag int) error { + return w.WriteHead(tag, TypeStructBegin) +} + +func (w *Writer) WriteStructEnd() error { + return w.WriteHead(0, TypeStructEnd) +} + +func (w *Writer) WriteStruct(tag int, value Marshaler) error { + if err := w.WriteStructBegin(tag); err != nil { + return err + } + if err := value.WriteTo(w); err != nil { + return err + } + return w.WriteStructEnd() +} + +func (w *Writer) WriteMapStringString(tag int, value map[string]string) error { + if value == nil { + value = map[string]string{} + } + if err := w.WriteHead(tag, TypeMap); err != nil { + return err + } + if err := w.WriteInt32(0, int64(len(value))); err != nil { + return err + } + for k, v := range value { + if err := w.WriteString(0, k); err != nil { + return err + } + if err := w.WriteString(1, v); err != nil { + return err + } + } + return nil +} + +func (w *Writer) WriteMapStringBytes(tag int, value map[string][]byte) error { + if value == nil { + value = map[string][]byte{} + } + if err := w.WriteHead(tag, TypeMap); err != nil { + return err + } + if err := w.WriteInt32(0, int64(len(value))); err != nil { + return err + } + for k, v := range value { + if err := w.WriteString(0, k); err != nil { + return err + } + if err := w.WriteBytes(1, v); err != nil { + return err + } + } + return nil +} + +func (w *Writer) WriteListStruct(tag int, values []Marshaler) error { + if err := w.WriteHead(tag, TypeList); err != nil { + return err + } + if err := w.WriteInt32(0, int64(len(values))); err != nil { + return err + } + for _, value := range values { + if err := w.WriteStruct(0, value); err != nil { + return err + } + } + return nil +} diff --git a/internal/wup/wup.go b/internal/wup/wup.go new file mode 100644 index 0000000..71d6f7d --- /dev/null +++ b/internal/wup/wup.go @@ -0,0 +1,263 @@ +package wup + +import ( + "bytes" + "encoding/binary" + "errors" + "fmt" + "io" + + "huya-go/internal/taf" +) + +// Request 是 WUP v3 请求封装。 +type Request struct { + Version int16 + PacketType int8 + Message int32 + RequestID int32 + Servant string + Func string + Timeout int32 + Context map[string]string + Status map[string]string + NewData map[string][]byte +} + +func NewRequest(servant, fn string, requestID int32) *Request { + return &Request{ + Version: 3, + Servant: servant, + Func: fn, + RequestID: requestID, + Timeout: 3000, + Context: map[string]string{}, + Status: map[string]string{}, + NewData: map[string][]byte{}, + } +} + +func (r *Request) WriteStruct(key string, value taf.Marshaler) error { + w := taf.NewWriter() + if err := w.WriteStruct(0, value); err != nil { + return err + } + r.NewData[key] = w.Bytes() + return nil +} + +func (r *Request) Encode() ([]byte, error) { + data := taf.NewWriter() + if err := data.WriteMapStringBytes(0, r.NewData); err != nil { + return nil, err + } + + body := taf.NewWriter() + if err := body.WriteInt16(1, int64(r.Version)); err != nil { + return nil, err + } + if err := body.WriteInt8(2, int64(r.PacketType)); err != nil { + return nil, err + } + if err := body.WriteInt32(3, int64(r.Message)); err != nil { + return nil, err + } + if err := body.WriteInt32(4, int64(r.RequestID)); err != nil { + return nil, err + } + if err := body.WriteString(5, r.Servant); err != nil { + return nil, err + } + if err := body.WriteString(6, r.Func); err != nil { + return nil, err + } + if err := body.WriteBytes(7, data.Bytes()); err != nil { + return nil, err + } + if err := body.WriteInt32(8, int64(r.Timeout)); err != nil { + return nil, err + } + if err := body.WriteMapStringString(9, r.Context); err != nil { + return nil, err + } + if err := body.WriteMapStringString(10, r.Status); err != nil { + return nil, err + } + + rawBody := body.Bytes() + out := bytes.NewBuffer(make([]byte, 0, len(rawBody)+4)) + var lenBuf [4]byte + binary.BigEndian.PutUint32(lenBuf[:], uint32(len(rawBody)+4)) + out.Write(lenBuf[:]) + out.Write(rawBody) + return out.Bytes(), nil +} + +// Response 是 WUP 响应封装。 +type Response struct { + Version int16 + PacketType int8 + Message int32 + RequestID int32 + Servant string + Func string + Buffer []byte + Timeout int32 + Context map[string]string + Status map[string]string + NewData map[string][]byte +} + +func (r *Response) Decode(data []byte) error { + body := NormalizePayload(data) + reader := taf.NewReader(body) + r.Context = map[string]string{} + r.Status = map[string]string{} + r.NewData = map[string][]byte{} + + for { + tag, typ, err := reader.ReadHead() + if err != nil { + if errors.Is(err, io.EOF) { + return nil + } + return err + } + if tag > 10 { + return nil + } + switch tag { + case 1: + v, err := reader.ReadIntValue(typ) + r.Version = int16(v) + if err != nil { + return err + } + case 2: + v, err := reader.ReadIntValue(typ) + r.PacketType = int8(v) + if err != nil { + return err + } + case 3: + v, err := reader.ReadIntValue(typ) + r.Message = int32(v) + if err != nil { + return err + } + case 4: + v, err := reader.ReadIntValue(typ) + r.RequestID = int32(v) + if err != nil { + return err + } + case 5: + v, err := reader.ReadStringValue(typ) + r.Servant = v + if err != nil { + return err + } + case 6: + v, err := reader.ReadStringValue(typ) + r.Func = v + if err != nil { + return err + } + case 7: + v, err := reader.ReadBytesValue(typ) + if err != nil { + return err + } + r.Buffer = v + if err := r.decodeBuffer(); err != nil { + return err + } + case 8: + v, err := reader.ReadIntValue(typ) + r.Timeout = int32(v) + if err != nil { + return err + } + case 9: + if typ != taf.TypeMap { + if err := reader.Skip(typ); err != nil { + return err + } + continue + } + _ = reader.Seek(reader.Position() - 1) + v, err := reader.ReadMapStringString(9, false) + r.Context = v + if err != nil { + return err + } + case 10: + if typ != taf.TypeMap { + if err := reader.Skip(typ); err != nil { + return err + } + return nil + } + _ = reader.Seek(reader.Position() - 1) + v, err := reader.ReadMapStringString(10, false) + r.Status = v + if err != nil { + return err + } + return nil + default: + if err := reader.Skip(typ); err != nil { + return err + } + } + } +} + +func (r *Response) decodeBuffer() error { + if len(r.Buffer) == 0 { + return nil + } + reader := taf.NewReader(r.Buffer) + m, err := reader.ReadMapStringBytes(0, false) + if err != nil { + return err + } + r.NewData = m + return nil +} + +func (r *Response) ReadStruct(key string, obj taf.Unmarshaler) (bool, error) { + data := r.NewData[key] + if len(data) == 0 && key == "tRsp" { + data = r.NewData["tResp"] + } + if len(data) == 0 && key == "tResp" { + data = r.NewData["tRsp"] + } + if len(data) == 0 { + return false, nil + } + reader := taf.NewReader(data) + _, typ, err := reader.ReadHead() + if err != nil { + return false, err + } + if typ != taf.TypeStructBegin { + return false, fmt.Errorf("wup: %s 不是结构体响应: 0x%02x", key, byte(typ)) + } + if err := obj.ReadFrom(reader); err != nil { + return false, err + } + return true, reader.SkipToStructEnd() +} + +func NormalizePayload(data []byte) []byte { + if len(data) < 4 { + return data + } + n := int(binary.BigEndian.Uint32(data[:4])) + if n == len(data) || n+4 == len(data) { + return data[4:] + } + return data +} diff --git a/internal/wup/wup_test.go b/internal/wup/wup_test.go new file mode 100644 index 0000000..b6522e0 --- /dev/null +++ b/internal/wup/wup_test.go @@ -0,0 +1,33 @@ +package wup_test + +import ( + "testing" + + "huya-go/internal/huya" + "huya-go/internal/wup" +) + +func TestWupEncodeDecodeHeader(t *testing.T) { + req := wup.NewRequest(huya.ServantWebActUI, huya.FuncGetUserScore, 2) + err := req.WriteStruct("tReq", &huya.GetUserScoreReq{ + User: huya.NewActivityUserID(123, "yyuid=123;", huya.ActivityWebUA), + SID: 456, + }) + if err != nil { + t.Fatal(err) + } + raw, err := req.Encode() + if err != nil { + t.Fatal(err) + } + var resp wup.Response + if err := resp.Decode(raw); err != nil { + t.Fatal(err) + } + if resp.Servant != huya.ServantWebActUI || resp.Func != huya.FuncGetUserScore || resp.RequestID != 2 { + t.Fatalf("unexpected header: %#v", resp) + } + if len(resp.NewData["tReq"]) == 0 { + t.Fatal("missing tReq") + } +} diff --git a/main.go b/main.go new file mode 100644 index 0000000..bbc61fa --- /dev/null +++ b/main.go @@ -0,0 +1,38 @@ +package main + +import ( + "embed" + "log" + + "github.com/wailsapp/wails/v2" + "github.com/wailsapp/wails/v2/pkg/options" + "github.com/wailsapp/wails/v2/pkg/options/assetserver" + + "huya-go/internal/gui" +) + +//go:embed all:frontend/dist +var assets embed.FS + +func main() { + app := gui.NewApp() + + err := wails.Run(&options.App{ + Title: "虎牙抢购助手", + Width: 1280, + Height: 820, + MinWidth: 1024, + MinHeight: 680, + AssetServer: &assetserver.Options{ + Assets: assets, + }, + OnStartup: app.Startup, + OnShutdown: app.Shutdown, + Bind: []interface{}{ + app, + }, + }) + if err != nil { + log.Fatal(err) + } +} diff --git a/wails.json b/wails.json new file mode 100644 index 0000000..676fbec --- /dev/null +++ b/wails.json @@ -0,0 +1,9 @@ +{ + "$schema": "https://wails.io/schemas/config.v2.json", + "name": "huya-go", + "outputfilename": "huya-gui", + "frontend:install": "npm install", + "frontend:build": "npm run build", + "frontend:dev:watcher": "npm run dev", + "frontend:dev:serverUrl": "auto" +}