1-6
823 lines
21 KiB
TypeScript
823 lines
21 KiB
TypeScript
import { srpc } from "./srpc";
|
|
import * as grpc_1 from "@grpc/grpc-js";
|
|
|
|
let client = new srpc.SillyGirlServiceClient(
|
|
"localhost:50051",
|
|
grpc_1.credentials.createInsecure()
|
|
);
|
|
|
|
let senders: Sender[] = [];
|
|
let plugin_id = process.env?.PLUGIN_ID ?? "";
|
|
|
|
process.on("beforeExit", () => {
|
|
for (let sender of senders) {
|
|
sender.destructor();
|
|
}
|
|
});
|
|
|
|
class Sender {
|
|
public uuid: string;
|
|
private destoried = false;
|
|
constructor(uuid: string) {
|
|
this.uuid = uuid;
|
|
senders.push(this);
|
|
}
|
|
|
|
destructor() {
|
|
if (this.destoried) return;
|
|
this.destoried = true;
|
|
client.SenderDestroy(
|
|
new srpc.ReplyRequest({ uuid: sender.uuid }),
|
|
(err, resp) => {}
|
|
);
|
|
}
|
|
|
|
async getUserId(): Promise<string | undefined> {
|
|
return new Promise((resolve, reject) => {
|
|
client.SenderGetUserId(
|
|
new srpc.SenderRequest({
|
|
uuid: this.uuid,
|
|
}),
|
|
(err, resp) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(resp?.value);
|
|
}
|
|
}
|
|
);
|
|
});
|
|
}
|
|
async getUserName(): Promise<string | undefined> {
|
|
return new Promise((resolve, reject) => {
|
|
client.SenderGetUserName(
|
|
new srpc.SenderRequest({
|
|
uuid: this.uuid,
|
|
}),
|
|
(err, resp) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(resp?.value);
|
|
}
|
|
}
|
|
);
|
|
});
|
|
}
|
|
async getChatId(): Promise<string | undefined> {
|
|
return new Promise((resolve, reject) => {
|
|
client.SenderGetChatId(
|
|
new srpc.SenderRequest({
|
|
uuid: this.uuid,
|
|
}),
|
|
(err, resp) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(resp?.value);
|
|
}
|
|
}
|
|
);
|
|
});
|
|
}
|
|
async getChatName(): Promise<string | undefined> {
|
|
return new Promise((resolve, reject) => {
|
|
client.SenderGetChatName(
|
|
new srpc.SenderRequest({
|
|
uuid: this.uuid,
|
|
}),
|
|
(err, resp) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(resp?.value);
|
|
}
|
|
}
|
|
);
|
|
});
|
|
}
|
|
async getMessageId(): Promise<string | undefined> {
|
|
return new Promise((resolve, reject) => {
|
|
client.SenderGetMessageId(
|
|
new srpc.SenderRequest({
|
|
uuid: this.uuid,
|
|
}),
|
|
(err, resp) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(resp?.value);
|
|
}
|
|
}
|
|
);
|
|
});
|
|
}
|
|
async getPlatform(): Promise<string | undefined> {
|
|
return new Promise((resolve, reject) => {
|
|
client.SenderGetPlatform(
|
|
new srpc.SenderRequest({
|
|
uuid: this.uuid,
|
|
}),
|
|
(err, resp) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(resp?.value);
|
|
}
|
|
}
|
|
);
|
|
});
|
|
}
|
|
async getBotId(): Promise<string | undefined> {
|
|
return new Promise((resolve, reject) => {
|
|
client.SenderGetBotId(
|
|
new srpc.SenderRequest({
|
|
uuid: this.uuid,
|
|
}),
|
|
(err, resp) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(resp?.value);
|
|
}
|
|
}
|
|
);
|
|
});
|
|
}
|
|
async getContent(): Promise<string | undefined> {
|
|
return new Promise((resolve, reject) => {
|
|
client.SenderGetContent(
|
|
new srpc.SenderRequest({
|
|
uuid: this.uuid,
|
|
}),
|
|
(err, resp) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(resp?.value);
|
|
}
|
|
}
|
|
);
|
|
});
|
|
}
|
|
async param(key: number | string): Promise<string> {
|
|
return new Promise((resolve, reject) => {
|
|
client.SenderParam(
|
|
new srpc.ReplyRequest({
|
|
uuid: this.uuid,
|
|
content: `${key}`,
|
|
}),
|
|
(err, resp) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(resp?.value ?? "");
|
|
}
|
|
}
|
|
);
|
|
});
|
|
}
|
|
async setContent(content: string): Promise<undefined> {
|
|
return new Promise((resolve, reject) => {
|
|
client.SenderSetContent(
|
|
new srpc.SenderContentRequest({
|
|
uuid: this.uuid,
|
|
content,
|
|
}),
|
|
(err, resp) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(undefined);
|
|
}
|
|
}
|
|
);
|
|
});
|
|
}
|
|
async continue(): Promise<undefined> {
|
|
return new Promise((resolve, reject) => {
|
|
client.SenderContinue(
|
|
new srpc.SenderRequest({
|
|
uuid: this.uuid,
|
|
}),
|
|
(err, resp) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(undefined);
|
|
}
|
|
}
|
|
);
|
|
});
|
|
}
|
|
async getAdapter() {
|
|
return new Adapter({
|
|
bot_id: await this.getBotId(),
|
|
platform: await this.getPlatform(),
|
|
});
|
|
}
|
|
|
|
async listen(options?: {
|
|
rules?: string[]; // 匹配规则
|
|
timeout?: number; // 超时，单位毫秒
|
|
handle?: (s: Sender) => Promise<string | void> | string | void; // 如果匹配成功，则进入消息处理逻辑。如果将 holdOn(content) 的结果作为返回值，会继续监听
|
|
listen_private?: boolean; // 监听用户群内消息时，同时监听用户消息
|
|
listen_group?: boolean; // 监听用户群内消息时，同时监听群员消息
|
|
allow_platforms?: string[]; // 平台白名单
|
|
prohibit_platforms?: string[]; // 平台黑名单
|
|
allow_groups?: string[]; // 群聊白名单
|
|
prohibit_groups?: string[]; // 群聊黑名单
|
|
allow_users?: string[]; // 用户白名单
|
|
prohibit_users?: string[]; // 群聊白名单
|
|
persistent?: boolean; //持久化监听
|
|
}): Promise<Sender | undefined> {
|
|
return new Promise(
|
|
async (resolve, reject) => {
|
|
let params: any = {
|
|
uuid: this.uuid,
|
|
rules: options?.rules,
|
|
timeout: options?.timeout,
|
|
listen_private: options?.listen_private,
|
|
listen_group: options?.listen_group,
|
|
allow_platforms: options?.allow_platforms,
|
|
prohibit_platforms: options?.prohibit_platforms,
|
|
allow_groups: options?.allow_groups,
|
|
prohibit_groups: options?.prohibit_groups,
|
|
allow_users: options?.allow_users,
|
|
prohibit_users: options?.prohibit_users,
|
|
persistent: options?.persistent,
|
|
plugin_id,
|
|
};
|
|
if (!this.uuid) {
|
|
params.persistent = true;
|
|
}
|
|
const call = client.SenderListen();
|
|
// let callback: any = options.replyHandler;
|
|
// console.log("===",this.uuid)
|
|
call.on("data", (response) => {
|
|
if (response.echo == "END") {
|
|
call.cancel();
|
|
return;
|
|
}
|
|
let s = response.uuid ? new Sender(response.uuid) : undefined;
|
|
if (options?.handle && s) {
|
|
// console.log(`options?.handle`, options.persistent)
|
|
let obj = options?.handle(s);
|
|
if (typeof obj == "string") {
|
|
call.write(
|
|
new srpc.SenderListenRequest({
|
|
uuid: response.echo,
|
|
value: obj,
|
|
})
|
|
);
|
|
} else if (obj) {
|
|
obj
|
|
.then((v: any) => {
|
|
call.write(
|
|
new srpc.SenderListenRequest({
|
|
uuid: response.echo,
|
|
value: v ?? "",
|
|
})
|
|
);
|
|
})
|
|
.catch((e) => {
|
|
call.write(
|
|
new srpc.SenderListenRequest({
|
|
uuid: response.echo,
|
|
value: "",
|
|
})
|
|
);
|
|
});
|
|
} else {
|
|
call.write(
|
|
new srpc.SenderListenRequest({
|
|
uuid: response.echo,
|
|
value: "",
|
|
})
|
|
);
|
|
}
|
|
// console.log(`options?.handle`, options.persistent)
|
|
} else {
|
|
// console.log(`call.cancel()`, options?.persistent)
|
|
call.write(
|
|
new srpc.SenderListenRequest({
|
|
uuid: response.echo,
|
|
value: "",
|
|
})
|
|
);
|
|
// console.log(`call.cancel()`, options?.persistent)
|
|
}
|
|
// console.log("response", JSON.stringify(response));
|
|
// call.cancel()
|
|
resolve(s);
|
|
});
|
|
call.on("error", (err) => {
|
|
reject(err);
|
|
// console.error(err);
|
|
});
|
|
// console.log("params", JSON.stringify(params));
|
|
call.write(new srpc.SenderListenRequest(params));
|
|
}
|
|
// client.SenderListen(new srpc.SenderListenRequest(params), (err, resp) => {
|
|
// if (err) {
|
|
// reject(err);
|
|
// } else {
|
|
// if (resp?.value) {
|
|
// let handle = options?.handle;
|
|
// let s = new Sender(resp.value);
|
|
// resolve(s);
|
|
// if (handle) {
|
|
// handle(s);
|
|
// }
|
|
// } else {
|
|
// reject(new Error("timeout"));
|
|
// }
|
|
// }
|
|
// });
|
|
// }
|
|
);
|
|
}
|
|
holdOn(str: string) {
|
|
return "go_again_" + str;
|
|
}
|
|
async reply(content: string): Promise<string | undefined> {
|
|
return new Promise((resolve, reject) => {
|
|
client.SenderReply(
|
|
new srpc.ReplyRequest({
|
|
uuid: this.uuid,
|
|
content,
|
|
}),
|
|
(err, resp) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(resp?.value);
|
|
}
|
|
}
|
|
);
|
|
});
|
|
}
|
|
async action(options: any): Promise<any | undefined> {
|
|
return new Promise((resolve, reject) => {
|
|
client.SenderAction(
|
|
new srpc.ReplyRequest({
|
|
uuid: this.uuid,
|
|
content: JSON.stringify(options),
|
|
}),
|
|
(err, resp) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(resp?.value);
|
|
}
|
|
}
|
|
);
|
|
});
|
|
}
|
|
async event(): Promise<any | undefined> {
|
|
return;
|
|
}
|
|
}
|
|
|
|
class Bucket {
|
|
name: string;
|
|
|
|
constructor(name: string) {
|
|
this.name = name;
|
|
}
|
|
|
|
transform(v: string | undefined) {
|
|
if (!v) {
|
|
return undefined;
|
|
}
|
|
let result: number | boolean;
|
|
if (v.startsWith("f:")) {
|
|
result = parseFloat(v.replace("f:", ""));
|
|
return result;
|
|
}
|
|
if (v.startsWith("d:")) {
|
|
result = parseInt(v.replace("d:", ""));
|
|
return result;
|
|
}
|
|
if (v.startsWith("b:")) {
|
|
result = v.replace("b:", "") === "true";
|
|
return result;
|
|
}
|
|
if (v.startsWith("o:")) {
|
|
result = JSON.parse(v.replace("o:", ""));
|
|
return result;
|
|
}
|
|
return v;
|
|
}
|
|
|
|
reverseTransform(value: any): string {
|
|
if (typeof value === "number" || typeof value === "boolean") {
|
|
return value.toString();
|
|
}
|
|
if (typeof value === "object" && value !== null) {
|
|
return "o:" + JSON.stringify(value);
|
|
}
|
|
if (value === undefined || value === null) {
|
|
return "";
|
|
}
|
|
if (typeof value === "string") {
|
|
if (!value) {
|
|
return "";
|
|
}
|
|
if (!isNaN(parseFloat(value))) {
|
|
return "f:" + parseFloat(value);
|
|
}
|
|
if (!isNaN(parseInt(value))) {
|
|
return "d:" + parseInt(value);
|
|
}
|
|
if (value === "true" || value === "false") {
|
|
return "b:" + (value === "true");
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
|
|
async get(key: string, defaultValue: any = undefined): Promise<any> {
|
|
return new Promise((resolve, reject) => {
|
|
client.BucketGet(
|
|
new srpc.BucketKeyRequest({ name: this.name, key }),
|
|
(err, resp) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(this.transform(resp?.value) || defaultValue);
|
|
}
|
|
}
|
|
);
|
|
});
|
|
}
|
|
|
|
async set(
|
|
key: string,
|
|
value: any
|
|
): Promise<{ message?: string; changed?: boolean }> {
|
|
return new Promise((resolve, reject) => {
|
|
client.BucketSet(
|
|
new srpc.BucketSetRequest({
|
|
name: this.name,
|
|
key,
|
|
value: this.reverseTransform(value),
|
|
}),
|
|
(err, resp) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve({
|
|
message: resp?.message,
|
|
changed: resp?.changed,
|
|
});
|
|
}
|
|
}
|
|
);
|
|
});
|
|
}
|
|
|
|
async getAll(): Promise<any> {
|
|
return new Promise((resolve, reject) => {
|
|
client.BucketGetAll(
|
|
new srpc.BucketRequest({ name: this.name }),
|
|
(err, resp) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
let values: any = {};
|
|
if (resp?.value) {
|
|
values = JSON.parse(resp?.value);
|
|
for (let key in values) {
|
|
values[key] = this.transform(values[key]);
|
|
}
|
|
}
|
|
resolve(values);
|
|
}
|
|
}
|
|
);
|
|
});
|
|
}
|
|
|
|
async delete(): Promise<undefined> {
|
|
return new Promise((resolve, reject) => {
|
|
client.BucketDelete(
|
|
new srpc.BucketRequest({ name: this.name }),
|
|
(err, resp) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(undefined);
|
|
}
|
|
}
|
|
);
|
|
});
|
|
}
|
|
|
|
async keys(): Promise<string[] | undefined> {
|
|
return new Promise((resolve, reject) => {
|
|
client.BucketKeys(
|
|
new srpc.BucketRequest({ name: this.name }),
|
|
(err, resp) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(resp?.keys);
|
|
}
|
|
}
|
|
);
|
|
});
|
|
}
|
|
|
|
async len(): Promise<number | undefined> {
|
|
return new Promise((resolve, reject) => {
|
|
client.BucketLen(
|
|
new srpc.BucketRequest({ name: this.name }),
|
|
(err, resp) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(resp?.length);
|
|
}
|
|
}
|
|
);
|
|
});
|
|
}
|
|
|
|
async buckets(): Promise<string[] | undefined> {
|
|
return new Promise((resolve, reject) => {
|
|
client.BucketBuckets(new srpc.Empty(), (err, resp) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(resp?.buckets);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
watch(
|
|
key: string,
|
|
handle: (old: any, now: any, key: string) => StorageFinal | void | any
|
|
) {
|
|
const call = client.BucketWatch();
|
|
call.on("data", async (response) => {
|
|
let fin: any = handle(
|
|
this.transform(response.old),
|
|
this.transform(response.now),
|
|
response.key
|
|
);
|
|
fin = await fin;
|
|
let result: StorageFinal = {
|
|
echo: response.echo,
|
|
};
|
|
if (!fin) {
|
|
result.error = "VOID";
|
|
} else {
|
|
result.now = this.reverseTransform(fin.now);
|
|
result.message = fin.message;
|
|
result.error = fin.error;
|
|
}
|
|
call.write(new srpc.BucketWatchRequest(result));
|
|
});
|
|
call.on("error", (err) => {
|
|
// console.error(err);
|
|
});
|
|
call.write(
|
|
new srpc.BucketWatchRequest({
|
|
name: this.name,
|
|
key: key,
|
|
plugin_id,
|
|
})
|
|
);
|
|
}
|
|
|
|
async _name(): Promise<string> {
|
|
return this.name;
|
|
}
|
|
}
|
|
interface StorageFinal {
|
|
echo?: string;
|
|
now?: any;
|
|
message?: string;
|
|
error?: string;
|
|
}
|
|
|
|
interface Message {
|
|
message_id?: string; // 消息ID
|
|
user_id: string; // 用户ID
|
|
chat_id?: string; // 聊天ID
|
|
content: string; // 聊天内容
|
|
user_name?: string; // 用户名
|
|
chat_name?: string; // 群组名
|
|
}
|
|
|
|
class Adapter {
|
|
platform: string | undefined;
|
|
bot_id: string | undefined;
|
|
call: any;
|
|
constructor(options: {
|
|
platform?: string;
|
|
bot_id?: string;
|
|
replyHandler?: (
|
|
message: Message
|
|
) => string | undefined | Promise<string | undefined>;
|
|
actionHandler?: (
|
|
message: Message
|
|
) => string | undefined | Promise<string | undefined>;
|
|
}) {
|
|
this.platform = options.platform;
|
|
this.bot_id = options.bot_id;
|
|
if (options.replyHandler) {
|
|
const call = client.AdapterRegist();
|
|
// let callback: any = ;
|
|
call.on("data", async (response) => {
|
|
// console.log("start on data")
|
|
let message = JSON.parse(response.value);
|
|
const { echo, __type__ } = message;
|
|
delete message.__type__;
|
|
delete message.echo;
|
|
if (__type__ == "reply" && options.replyHandler) {
|
|
let v = (await options.replyHandler(message)) ?? "";
|
|
call.write(
|
|
new srpc.AdapterRegistRequest({
|
|
bot_id: echo,
|
|
platform: v,
|
|
})
|
|
);
|
|
}
|
|
if (__type__ == "action" && options.actionHandler) {
|
|
let v = await options.actionHandler(message);
|
|
call.write(
|
|
new srpc.AdapterRegistRequest({
|
|
bot_id: echo,
|
|
platform: v,
|
|
})
|
|
);
|
|
}
|
|
// console.log("end on data")
|
|
});
|
|
call.on("error", (err) => {
|
|
console.error("adapter disc", err);
|
|
});
|
|
// console.log("before write")
|
|
call.write(
|
|
new srpc.AdapterRegistRequest({
|
|
bot_id: options.bot_id,
|
|
platform: options.platform,
|
|
})
|
|
);
|
|
// console.log("after write write")
|
|
this.call = call;
|
|
}
|
|
}
|
|
setActionHandler(func: (action: {}) => any): void {
|
|
// 将从服务端不断接收action消息，并处理
|
|
// 事件处理巨饼
|
|
}
|
|
async receive(message: Message): Promise<Sender> {
|
|
//投递消息
|
|
return new Promise<Sender>((resolve, reject) => {
|
|
client.AdapterReceive(
|
|
new srpc.AdapterRequest({
|
|
platform: this.platform,
|
|
bot_id: this.bot_id,
|
|
value: JSON.stringify(message),
|
|
}),
|
|
(err, resp) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else if (resp?.value) {
|
|
resolve(new Sender(resp.value));
|
|
}
|
|
}
|
|
);
|
|
});
|
|
}
|
|
async push(message: Message): Promise<string> {
|
|
//推送消息
|
|
return new Promise<string>((resolve, reject) => {
|
|
client.AdapterPush(
|
|
new srpc.AdapterRequest({
|
|
platform: this.platform,
|
|
bot_id: this.bot_id,
|
|
value: JSON.stringify(message),
|
|
}),
|
|
(err, resp) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(resp?.value ?? "");
|
|
}
|
|
}
|
|
);
|
|
});
|
|
}
|
|
async destroy(): Promise<void> {
|
|
this.call.cancel();
|
|
}
|
|
async sender(options: any): Promise<Sender> {
|
|
return new Promise<Sender>((resolve, reject) => {
|
|
client.AdapterSender(
|
|
new srpc.AdapterRequest({
|
|
platform: this.platform,
|
|
bot_id: this.bot_id,
|
|
value: JSON.stringify(options),
|
|
}),
|
|
(err, resp) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else if (resp?.value) {
|
|
resolve(new Sender(resp.value));
|
|
}
|
|
}
|
|
);
|
|
});
|
|
}
|
|
}
|
|
|
|
let sender: Sender = new Sender(process.env?.SENDER_ID ?? "");
|
|
|
|
async function sleep(ms: number | undefined) {
|
|
return new Promise((resolve) => setTimeout(resolve, ms));
|
|
}
|
|
|
|
class Console {
|
|
error = (message?: any, ...optionalParams: any[]) => {};
|
|
info = (message?: any, ...optionalParams: any[]) => {};
|
|
log = (message?: any, ...optionalParams: any[]) => {};
|
|
debug = (message?: any, ...optionalParams: any[]) => {};
|
|
}
|
|
|
|
let utils = {
|
|
parseCQText: (text: string, prefix = "CQ") => {
|
|
const cqRegex = new RegExp(`\\[${prefix}:(\\w+)(.*?)\\]`, "g");
|
|
const cqMatches = text.matchAll(cqRegex);
|
|
const result = [];
|
|
|
|
let lastIndex = 0;
|
|
for (const match of cqMatches) {
|
|
// 添加 CQ 码前的文本
|
|
const matchIndex = text.indexOf(match[0], lastIndex);
|
|
if (matchIndex > lastIndex) {
|
|
result.push(text.slice(lastIndex, matchIndex));
|
|
}
|
|
|
|
// 解析 CQ 码
|
|
const params: any = {};
|
|
const paramRegex = /(\w+)=([^,]+)/g;
|
|
const paramMatches = match[2].matchAll(paramRegex);
|
|
for (const paramMatch of paramMatches) {
|
|
params[paramMatch[1]] = paramMatch[2].trim();
|
|
}
|
|
result.push({
|
|
type: match[1],
|
|
params: params,
|
|
});
|
|
|
|
lastIndex = matchIndex + match[0].length;
|
|
}
|
|
if (lastIndex < text.length) {
|
|
result.push(text.slice(lastIndex));
|
|
}
|
|
return result;
|
|
},
|
|
};
|
|
|
|
let slog = (type: string, ...args: any[]) => {
|
|
|
|
};
|
|
|
|
let console = {
|
|
log(...args: any[]) {
|
|
const content = args.reduce((acc, arg) => acc + ' ' + arg, '')
|
|
client.Console(
|
|
new srpc.ConsoleRequest({ type: "log", content, plugin_id }),
|
|
(err, resp) => {}
|
|
)
|
|
},
|
|
info(...args: any[]) {
|
|
const content = args.reduce((acc, arg) => acc + ' ' + arg, '')
|
|
client.Console(
|
|
new srpc.ConsoleRequest({ type: "info", content, plugin_id }),
|
|
(err, resp) => {}
|
|
)
|
|
},
|
|
error(...args: any[]) {
|
|
const content = args.reduce((acc, arg) => acc + ' ' + arg, '')
|
|
client.Console(
|
|
new srpc.ConsoleRequest({ type: "error", content, plugin_id }),
|
|
(err, resp) => {}
|
|
)
|
|
},
|
|
debug(...args: any[]) {
|
|
const content = args.reduce((acc, arg) => acc + ' ' + arg, '')
|
|
client.Console(
|
|
new srpc.ConsoleRequest({ type: "debug", content, plugin_id }),
|
|
(err, resp) => {}
|
|
)
|
|
},
|
|
};
|
|
|
|
export { Adapter, Bucket, sender, sleep, utils, console };
|