232 lines
10 KiB
TypeScript
232 lines
10 KiB
TypeScript
import type { JsonObject, JsonValue, MessageMeta } from './types';
|
|
import { RETCODE, failedResponse } from './types';
|
|
|
|
import { register as registerInfo } from './actions/info';
|
|
import { register as registerMessage } from './actions/message';
|
|
import { register as registerFriend } from './actions/friend';
|
|
import { register as registerGroupInfo } from './actions/group-info';
|
|
import { register as registerGroupAdmin } from './actions/group-admin';
|
|
import { register as registerGroupFile } from './actions/group-file';
|
|
import { register as registerRequest } from './actions/request';
|
|
import { register as registerExtended } from './actions/extended';
|
|
|
|
import { WebHonorType } from '@/bridge/web/group-honor';
|
|
// import {ClientKeyInfo} from "@/bridge/bridge";
|
|
|
|
export interface MessageSendResult {
|
|
messageId: number;
|
|
meta?: MessageMeta;
|
|
echoEvent?: JsonObject;
|
|
}
|
|
|
|
export interface GroupEssenceMsgRet {
|
|
retcode: number;
|
|
data: {
|
|
is_end: boolean;
|
|
msg_list: any[];
|
|
[key: string]: any;
|
|
};
|
|
[key: string]: any;
|
|
}
|
|
|
|
export interface ApiActionContext {
|
|
getLoginInfo: () => { userId: number; nickname: string };
|
|
isOnline: () => boolean;
|
|
getMessage: (messageId: number) => JsonObject | null;
|
|
getMessageMeta: (messageId: number) => MessageMeta | null;
|
|
sendPrivateMessage?: (userId: number, message: JsonValue, autoEscape: boolean) => Promise<MessageSendResult>;
|
|
sendGroupMessage?: (groupId: number, message: JsonValue, autoEscape: boolean) => Promise<MessageSendResult>;
|
|
deleteMessage?: (messageId: number, meta: MessageMeta) => Promise<void>;
|
|
canSendImage?: () => boolean;
|
|
canSendRecord?: () => boolean;
|
|
// Info retrieval (async — triggers OIDB fetch)
|
|
getFriendList?: () => Promise<JsonObject[]>;
|
|
getGroupList?: (noCache?: boolean) => Promise<JsonObject[]>;
|
|
getGroupInfo?: (groupId: number, noCache?: boolean) => Promise<JsonObject | null>;
|
|
getGroupMemberList?: (groupId: number, noCache?: boolean) => Promise<JsonObject[]>;
|
|
getGroupMemberInfo?: (groupId: number, userId: number, noCache?: boolean) => Promise<JsonObject | null>;
|
|
getStrangerInfo?: (userId: number) => Promise<JsonObject | null>;
|
|
// Group admin
|
|
setGroupKick?: (groupId: number, userId: number, rejectAdd: boolean) => Promise<void>;
|
|
setGroupBan?: (groupId: number, userId: number, duration: number) => Promise<void>;
|
|
setGroupWholeBan?: (groupId: number, enable: boolean) => Promise<void>;
|
|
setGroupAdmin?: (groupId: number, userId: number, enable: boolean) => Promise<void>;
|
|
setGroupCard?: (groupId: number, userId: number, card: string) => Promise<void>;
|
|
setGroupName?: (groupId: number, name: string) => Promise<void>;
|
|
setGroupLeave?: (groupId: number) => Promise<void>;
|
|
setGroupSpecialTitle?: (groupId: number, userId: number, title: string) => Promise<void>;
|
|
// Group file
|
|
uploadGroupFile?: (groupId: number, file: string, name?: string, folderId?: string, uploadFile?: boolean) => Promise<string | null>;
|
|
uploadPrivateFile?: (userId: number, file: string, name?: string, uploadFile?: boolean) => Promise<string | null>;
|
|
getGroupFileUrl?: (groupId: number, fileId: string, busId?: number) => Promise<string>;
|
|
getGroupFiles?: (groupId: number, folderId?: string) => Promise<JsonObject>;
|
|
deleteGroupFile?: (groupId: number, fileId: string) => Promise<void>;
|
|
moveGroupFile?: (groupId: number, fileId: string, parentDirectory: string, targetDirectory: string) => Promise<void>;
|
|
createGroupFileFolder?: (groupId: number, name: string, parentId?: string) => Promise<void>;
|
|
deleteGroupFileFolder?: (groupId: number, folderId: string) => Promise<void>;
|
|
renameGroupFileFolder?: (groupId: number, folderId: string, newName: string) => Promise<void>;
|
|
getPrivateFileUrl?: (userId: number, fileId: string, fileHash: string) => Promise<string>;
|
|
// Requests
|
|
handleFriendRequest?: (flag: string, approve: boolean) => Promise<void>;
|
|
handleGroupRequest?: (flag: string, subType: string, approve: boolean, reason: string) => Promise<void>;
|
|
// Extended
|
|
sendLike?: (userId: number, times: number) => Promise<void>;
|
|
sendFriendPoke?: (userId: number, targetId?: number) => Promise<void>;
|
|
sendGroupPoke?: (groupId: number, userId: number) => Promise<void>;
|
|
setEssenceMsg?: (messageId: number) => Promise<void>;
|
|
deleteEssenceMsg?: (messageId: number) => Promise<void>;
|
|
forceFetchClientKey? : () => Promise<{clientKey: string, keyIndex: string, expireTime: string}>;
|
|
setOnlineStatus?: (status: number, extStatus?: number, batteryStatus?: number) => Promise<void>;
|
|
setProfile?: (nickname?: string, personalNote?: string) => Promise<void>;
|
|
// New context methods
|
|
setGroupReaction?: (groupId: number, sequence: number, code: string, isSet: boolean) => Promise<void>;
|
|
handleDeleteFriend?: (userId: number, block?: boolean) => Promise<void>;
|
|
getGroupMsgHistory?: (groupId: number, messageId?: number, count?: number) => Promise<JsonObject[]>;
|
|
getFriendMsgHistory?: (userId: number, messageId?: number, count?: number) => Promise<JsonObject[]>;
|
|
handleGetGroupSystemMsg?: () => Promise<JsonObject[]>;
|
|
getDownloadRKeys?: () => Promise<JsonObject[]>;
|
|
// Forward message
|
|
sendGroupForwardMsg?: (groupId: number, messages: JsonValue) => Promise<{ messageId: number; forwardId: string }>;
|
|
sendPrivateForwardMsg?: (userId: number, messages: JsonValue) => Promise<{ messageId: number; forwardId: string }>;
|
|
sendForwardMsg?: (messages: JsonValue) => Promise<{ forwardId: string }>;
|
|
getForwardMsg?: (resId: string) => Promise<JsonObject[]>;
|
|
// Extended NapCat-compatible
|
|
setFriendRemark?: (userId: number, remark: string) => Promise<void>;
|
|
getGroupFileCount?: (groupId: number) => Promise<{ fileCount: number; maxCount: number }>;
|
|
setMsgEmojiLike?: (messageId: number, emojiId: string, set: boolean) => Promise<void>;
|
|
markGroupMsgAsRead?: (groupId: number, sequence: number) => Promise<void>;
|
|
markPrivateMsgAsRead?: (userId: number, sequence: number) => Promise<void>;
|
|
// Web
|
|
getGroupHonorInfo?: (groupId: number, type: WebHonorType | string) => Promise<any>;
|
|
getGroupEssence?: (groupId: number, pageStart?: number, pageLimit?: number) => Promise<GroupEssenceMsgRet>;
|
|
getGroupEssenceAll?: (groupId: number) => Promise<GroupEssenceMsgRet[]>;
|
|
sendGroupNotice?: (groupId: number, content: string, options?: any) => Promise<any>;
|
|
getGroupNotice?: (groupId: number) => Promise<any[]>;
|
|
}
|
|
|
|
type ActionHandler = (params: JsonObject) => Promise<import('./types').ApiResponse>;
|
|
|
|
export class ApiHandler {
|
|
private readonly handlers = new Map<string, ActionHandler>();
|
|
|
|
constructor(context: ApiActionContext) {
|
|
registerInfo(this, context);
|
|
registerMessage(this, context);
|
|
registerFriend(this, context);
|
|
registerGroupInfo(this, context);
|
|
registerGroupAdmin(this, context);
|
|
registerGroupFile(this, context);
|
|
registerRequest(this, context);
|
|
registerExtended(this, context);
|
|
}
|
|
|
|
registerAction(action: string, handler: ActionHandler): void {
|
|
this.handlers.set(action, handler);
|
|
}
|
|
|
|
async handle(action: string, params: JsonObject): Promise<import('./types').ApiResponse> {
|
|
const handler = this.handlers.get(action);
|
|
if (!handler) {
|
|
return failedResponse(RETCODE.UNKNOWN_ACTION, 'unknown action');
|
|
}
|
|
|
|
try {
|
|
return await handler(params);
|
|
} catch (error) {
|
|
const message = error instanceof Error ? error.message : 'internal error';
|
|
return failedResponse(RETCODE.INTERNAL_ERROR, message);
|
|
}
|
|
}
|
|
|
|
async processRequest(rawRequest: string): Promise<string> {
|
|
if (!rawRequest.trim()) {
|
|
return JSON.stringify(failedResponse(RETCODE.BAD_REQUEST, 'bad request'));
|
|
}
|
|
|
|
try {
|
|
const parsed = JSON.parse(rawRequest) as unknown;
|
|
if (!isJsonObject(parsed)) {
|
|
return JSON.stringify(failedResponse(RETCODE.BAD_REQUEST, 'bad request'));
|
|
}
|
|
|
|
const action = asString(parsed.action);
|
|
if (!action) {
|
|
return JSON.stringify(failedResponse(RETCODE.BAD_REQUEST, 'bad request'));
|
|
}
|
|
|
|
const params = isJsonObject(parsed.params) ? parsed.params : {};
|
|
const echo = parsed.echo;
|
|
const response = await this.handle(action, params);
|
|
if (echo !== undefined) {
|
|
response.echo = toJsonValue(echo);
|
|
}
|
|
|
|
return JSON.stringify(response);
|
|
} catch {
|
|
return JSON.stringify(failedResponse(RETCODE.BAD_REQUEST, 'bad request'));
|
|
}
|
|
}
|
|
}
|
|
|
|
function isJsonObject(value: unknown): value is JsonObject {
|
|
return typeof value === 'object' && value !== null && !Array.isArray(value);
|
|
}
|
|
|
|
export function asString(value: unknown, fallback = ''): string {
|
|
if (typeof value === 'string') return value;
|
|
if (typeof value === 'number' || typeof value === 'boolean') return String(value);
|
|
return fallback;
|
|
}
|
|
|
|
export function asNumber(value: unknown): number {
|
|
if (typeof value === 'number' && Number.isFinite(value)) return Math.trunc(value);
|
|
if (typeof value === 'string' && value.trim()) {
|
|
const n = Number(value);
|
|
if (Number.isFinite(n)) return Math.trunc(n);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
export function asBoolean(value: unknown, fallback: boolean): boolean {
|
|
if (typeof value === 'boolean') return value;
|
|
if (typeof value === 'number') return value !== 0;
|
|
if (typeof value === 'string') {
|
|
const text = value.trim().toLowerCase();
|
|
if (text === 'true' || text === '1' || text === 'yes' || text === 'on') return true;
|
|
if (text === 'false' || text === '0' || text === 'no' || text === 'off') return false;
|
|
}
|
|
return fallback;
|
|
}
|
|
|
|
export function toJsonValue(value: unknown): JsonValue {
|
|
if (value === null) return null;
|
|
if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') return value;
|
|
if (Array.isArray(value)) return value.map(toJsonValue);
|
|
if (isJsonObject(value)) {
|
|
const obj: JsonObject = {};
|
|
for (const [key, item] of Object.entries(value)) {
|
|
obj[key] = toJsonValue(item);
|
|
}
|
|
return obj;
|
|
}
|
|
return String(value);
|
|
}
|
|
|
|
export function asMessage(value: unknown): import('./types').JsonValue | undefined {
|
|
if (value === undefined) return undefined;
|
|
if (typeof value === 'string') {
|
|
const trimmed = value.trim();
|
|
if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
|
|
try {
|
|
const parsed = JSON.parse(trimmed);
|
|
if (Array.isArray(parsed)) {
|
|
return toJsonValue(parsed);
|
|
}
|
|
} catch {
|
|
// Fallback to literal text if it just looks like an array but is invalid JSON
|
|
}
|
|
}
|
|
}
|
|
return toJsonValue(value);
|
|
}
|