koishi-plugin-cocoyyy-console 1.0.0

package/lib/index.d.ts

@@ -0,0 +1,11 @@
+import { Context, Logger, Schema } from 'koishi';
+import { MysqlConfig, SaveConfig } from './utils/config';
+export declare const name = "cocoyyy-console";
+export interface Config {
+    mysql?: MysqlConfig;
+    save?: SaveConfig;
+}
+export declare const Config: Schema<Config>;
+export declare let logger: Logger;
+export declare let savePath: any;
+export declare function apply(ctx: Context, config: Config): Promise<void>;

package/lib/index.js

@@ -0,0 +1,471 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  logger: () => logger,
+  name: () => name,
+  savePath: () => savePath
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi3 = require("koishi");
+
+// src/utils/config.ts
+var import_koishi = require("koishi");
+var MysqlConfigSchema = import_koishi.Schema.object({
+  host: import_koishi.Schema.string().default("127.0.0.1").description("MySQL 主机地址"),
+  port: import_koishi.Schema.number().default(3306).description("MySQL 端口"),
+  user: import_koishi.Schema.string().default("root").description("用户名"),
+  password: import_koishi.Schema.string().role("secret").default("").description("密码"),
+  database: import_koishi.Schema.string().default("test").description("数据库名")
+});
+function loadMysqlConfigFromEnv(env = process.env) {
+  return {
+    host: env.MYSQL_HOST || "127.0.0.1",
+    port: Number(env.MYSQL_PORT || 3306),
+    user: env.MYSQL_USER || "root",
+    password: env.MYSQL_PASSWORD || "",
+    database: env.MYSQL_DATABASE || "test"
+  };
+}
+__name(loadMysqlConfigFromEnv, "loadMysqlConfigFromEnv");
+var SaveConfigSchema = import_koishi.Schema.object({
+  save_path: import_koishi.Schema.string().default("").description("保存图片路径（绝对路径）")
+});
+function resolveTagBaseDir(config) {
+  if (config?.save_path && config.save_path.trim().length > 0) return config.save_path;
+  return null;
+}
+__name(resolveTagBaseDir, "resolveTagBaseDir");
+
+// src/infra/mysql_init.ts
+var import_sequelize = require("sequelize");
+var sequelize = null;
+function initSequelize(cfg) {
+  const conf = cfg ?? loadMysqlConfigFromEnv();
+  sequelize = new import_sequelize.Sequelize(conf.database, conf.user, conf.password, {
+    host: conf.host,
+    port: conf.port,
+    dialect: "mysql",
+    logging: false
+  });
+}
+__name(initSequelize, "initSequelize");
+function getSequelize() {
+  if (!sequelize) {
+    initSequelize();
+  }
+  return sequelize;
+}
+__name(getSequelize, "getSequelize");
+async function testConnect() {
+  try {
+    const db = getSequelize();
+    await db.authenticate();
+    logger.info("数据库连接成功");
+    return true;
+  } catch (e) {
+    logger.info("数据库连接失败：", e?.message || e);
+    return false;
+  }
+}
+__name(testConnect, "testConnect");
+
+// src/models/tags.ts
+var import_sequelize2 = require("sequelize");
+var TagsModel = class extends import_sequelize2.Model {
+  static {
+    __name(this, "TagsModel");
+  }
+  id;
+  tags;
+  alias;
+  status;
+  createtime;
+};
+var inited = false;
+function getTagsModel() {
+  const sequelize2 = getSequelize();
+  if (!inited) {
+    TagsModel.init(
+      {
+        id: {
+          type: import_sequelize2.DataTypes.INTEGER.UNSIGNED,
+          allowNull: false,
+          autoIncrement: true,
+          primaryKey: true
+        },
+        tags: {
+          type: import_sequelize2.DataTypes.STRING(191),
+          allowNull: false,
+          unique: true
+        },
+        alias: {
+          type: import_sequelize2.DataTypes.STRING(191),
+          allowNull: true
+        },
+        status: {
+          type: import_sequelize2.DataTypes.TINYINT,
+          allowNull: false,
+          defaultValue: 0
+          // 0: 正常, 1: 软删除
+        },
+        createtime: {
+          type: import_sequelize2.DataTypes.DATE,
+          allowNull: false,
+          defaultValue: import_sequelize2.DataTypes.NOW,
+          field: "createtime",
+          set(value) {
+            if (typeof value === "number") {
+              const ts = value > 1e12 ? value : value * 1e3;
+              this.setDataValue("createtime", new Date(ts));
+            } else {
+              this.setDataValue("createtime", value);
+            }
+          }
+        }
+      },
+      {
+        sequelize: sequelize2,
+        tableName: "tags",
+        modelName: "Tags",
+        timestamps: false,
+        underscored: false
+      }
+    );
+    inited = true;
+  }
+  return TagsModel;
+}
+__name(getTagsModel, "getTagsModel");
+
+// src/models/imgs.ts
+var import_sequelize3 = require("sequelize");
+var ImgsModel = class extends import_sequelize3.Model {
+  static {
+    __name(this, "ImgsModel");
+  }
+  id;
+  tag_id;
+  img_url;
+  status;
+  createtime;
+};
+var inited2 = false;
+function getImgsModel() {
+  const sequelize2 = getSequelize();
+  if (!inited2) {
+    ImgsModel.init(
+      {
+        id: {
+          type: import_sequelize3.DataTypes.INTEGER.UNSIGNED,
+          allowNull: false,
+          autoIncrement: true,
+          primaryKey: true
+        },
+        tag_id: {
+          type: import_sequelize3.DataTypes.INTEGER.UNSIGNED,
+          allowNull: false
+        },
+        img_url: {
+          type: import_sequelize3.DataTypes.STRING(512),
+          allowNull: false
+        },
+        status: {
+          type: import_sequelize3.DataTypes.TINYINT,
+          allowNull: false,
+          defaultValue: 0
+          // 0: 正常, 1: 软删除
+        },
+        createtime: {
+          type: import_sequelize3.DataTypes.DATE,
+          allowNull: false,
+          defaultValue: import_sequelize3.DataTypes.NOW,
+          field: "createtime",
+          set(value) {
+            if (typeof value === "number") {
+              const ts = value > 1e12 ? value : value * 1e3;
+              this.setDataValue("createtime", new Date(ts));
+            } else {
+              this.setDataValue("createtime", value);
+            }
+          }
+        }
+      },
+      {
+        sequelize: sequelize2,
+        tableName: "imgs",
+        modelName: "Imgs",
+        timestamps: false,
+        underscored: false
+      }
+    );
+    inited2 = true;
+  }
+  return ImgsModel;
+}
+__name(getImgsModel, "getImgsModel");
+
+// src/utils/common.ts
+function is_at_bot(session) {
+  const elements = Array.isArray(session?.elements) ? session.elements : [];
+  const atElement = elements.find((element) => element?.type === "at");
+  const atId = atElement?.attrs?.id;
+  const selfId = session?.bot?.selfId ?? session?.selfId;
+  if (atId == null || selfId == null) return false;
+  return String(atId) === String(selfId);
+}
+__name(is_at_bot, "is_at_bot");
+
+// src/services/tag_service.ts
+var import_sequelize4 = require("sequelize");
+var import_fs = require("fs");
+var import_path = require("path");
+async function findTagByName(name2) {
+  const Tag = getTagsModel();
+  return await Tag.findOne({
+    where: {
+      status: 0,
+      [import_sequelize4.Op.or]: [
+        { tags: name2 },
+        { alias: { [import_sequelize4.Op.like]: `%${name2}%` } }
+      ]
+    }
+  });
+}
+__name(findTagByName, "findTagByName");
+async function findDeletedTagByName(name2) {
+  const Tag = getTagsModel();
+  return await Tag.findOne({
+    where: {
+      status: 1,
+      [import_sequelize4.Op.or]: [
+        { tags: name2 },
+        { alias: { [import_sequelize4.Op.like]: `%${name2}%` } }
+      ]
+    }
+  });
+}
+__name(findDeletedTagByName, "findDeletedTagByName");
+async function createorUpdateTag(name2, alias, savePath2) {
+  try {
+    const Tag = getTagsModel();
+    let existed = await findTagByName(name2);
+    if (existed) {
+      if (alias == null) {
+        throw new Error("already existed!");
+      }
+      let now_alias = existed.get("alias");
+      if (now_alias != null) {
+        const list = now_alias.split(";");
+        if (!list.includes(alias)) list.push(alias);
+        now_alias = list.join(";");
+      } else {
+        now_alias = alias;
+      }
+      existed.alias = now_alias;
+      await existed.save();
+      return { result: true, error: null };
+    }
+    existed = await findDeletedTagByName(name2);
+    if (existed) {
+      if (existed.get("status") != 0) {
+        existed.set("status", 0);
+        await existed.save();
+        return { result: true, error: null };
+      }
+      throw new Error("already existed!");
+    }
+    if (savePath2 == null) {
+      throw new Error("saving path config wrong!");
+    }
+    const now = new Date(Date.now() + 8 * 60 * 60 * 1e3);
+    const tag = await Tag.create({ tags: name2, alias: alias ?? null, createtime: now });
+    const dir = (0, import_path.join)(savePath2, String(tag.id));
+    (0, import_fs.mkdirSync)(dir, { recursive: true });
+    return { result: true, error: null };
+  } catch (e) {
+    logger.error("[createorUpdateTag Error]: " + e?.message || String(e));
+    return { result: false, error: e?.message || String(e) };
+  }
+}
+__name(createorUpdateTag, "createorUpdateTag");
+async function getTag(name2) {
+  try {
+    let tag = await findTagByName(name2);
+    return tag;
+  } catch (e) {
+    logger.error("[getTag Error]: " + e?.message || String(e));
+    return null;
+  }
+}
+__name(getTag, "getTag");
+
+// src/services/img_service.ts
+var import_koishi2 = require("koishi");
+var import_path2 = require("path");
+var import_fs2 = require("fs");
+async function saveImg(name2, img, savePath2) {
+  try {
+    const Img = getImgsModel();
+    logger.info("[saveImg Info]: " + img);
+    let tag = await getTag(name2);
+    if (tag == null) {
+      throw new Error(`not found tag '${name2}'!`);
+    }
+    if (tag.get("status") !== 0) {
+      logger.info(`[saveImg Info]:tag '${name2}' is deleted`);
+      throw new Error(`tag '${name2}' is deleted!`);
+    }
+    if (savePath2 == null) {
+      throw new Error("saving path config wrong!");
+    }
+    let dir = (0, import_path2.join)(savePath2, String(tag.get("id")));
+    const now = new Date(Date.now() + 8 * 60 * 60 * 1e3);
+    const filename = now.getFullYear().toString() + String(now.getMonth() + 1).padStart(2, "0") + String(now.getDate()).padStart(2, "0") + String(now.getHours()).padStart(2, "0") + String(now.getMinutes()).padStart(2, "0") + String(now.getSeconds()).padStart(2, "0") + ".txt";
+    let filePath = (0, import_path2.join)(dir, filename);
+    await import_fs2.promises.writeFile(filePath, img);
+    const saveImg2 = await Img.create({ tag_id: tag.get("id"), img_url: filePath, createtime: now });
+    logger.info("[saveImg Info]: save image to '" + name2 + "' success");
+    return { result: true, error: null };
+  } catch (e) {
+    logger.error("[saveImg Error]: " + e?.message || String(e));
+    return { result: false, error: e?.message || String(e) };
+  }
+}
+__name(saveImg, "saveImg");
+async function randomImgByTag(name2, savePath2) {
+  try {
+    const Img = getImgsModel();
+    const existed = await getTag(name2);
+    if (!existed) {
+      throw new Error(`not found tag '${name2}'!`);
+    }
+    if (existed.status == 0) {
+      throw new Error(`not found tag '${name2}'!`);
+    }
+    let ImgList = await Img.findAll({
+      where: {
+        status: 0,
+        tag_id: existed.get("id")
+      }
+    });
+    if (ImgList.length <= 0) {
+      throw new Error("Don't have image!");
+    }
+    const random = new import_koishi2.Random(() => Math.random());
+    let result = ImgList[random.int(0, ImgList.length)];
+    const filePath = result.get("img_url");
+    const fileContent = await import_fs2.promises.readFile(filePath, { encoding: "utf-8" });
+    return fileContent;
+  } catch (e) {
+    logger.error("[randomImgByTag Error]: " + e?.message || String(e));
+    return null;
+  }
+}
+__name(randomImgByTag, "randomImgByTag");
+
+// src/index.ts
+var name = "cocoyyy-console";
+var Config = import_koishi3.Schema.object({
+  mysql: MysqlConfigSchema.description("MySQL 数据库配置"),
+  save: SaveConfigSchema.description("图片保存配置")
+});
+var menuList = [
+  {
+    name: "maketag",
+    description: "创建一个标签",
+    command: "maketag [标签]"
+  },
+  {
+    name: "add",
+    description: "给标签添加图片",
+    command: "add [标签] [图片]"
+  },
+  {
+    name: "get",
+    description: "给标签添加图片",
+    command: "get [标签]"
+  }
+];
+var logger = new import_koishi3.Logger(name);
+var savePath = null;
+async function apply(ctx, config) {
+  const mysqlConf = config?.mysql ?? loadMysqlConfigFromEnv();
+  initSequelize(mysqlConf);
+  const connected = await testConnect();
+  if (connected) {
+    await getTagsModel().sync();
+    await getImgsModel().sync();
+  }
+  savePath = resolveTagBaseDir(config?.save);
+  ctx.command("fullhelp", "帮助菜单").check(({ session }) => {
+    if (!connected) return;
+    if (!is_at_bot(session)) return;
+  }).action(async ({ session }) => {
+    return `帮助菜单[所有命令都需要@bot]:
+	${menuList.map((item) => item.command + ": " + item.description).join("\n	")}`;
+  });
+  ctx.command("maketag <参数>", "创建一个标签").check(({ session }) => {
+    if (!connected) return;
+    if (!is_at_bot(session)) return;
+  }).action(async ({ session }, ...args) => {
+    const tag = args?.[0];
+    if (!tag) return "请提供正确格式，如：@bot maketag [标签]";
+    let exec = await createorUpdateTag(tag, null, savePath);
+    if (!exec.result)
+      return `创建标签失败：${exec.error}`;
+    return `已创建标签：${tag}`;
+  });
+  ctx.command("add <参数>", "给标签添加图片").check(({ session }) => {
+    if (!connected) return;
+    if (!is_at_bot(session)) return;
+  }).action(async ({ session }, ...args) => {
+    const tag = args?.[0];
+    const img = args?.[1];
+    if (!tag || !img) return "请提供正确格式，如：@bot add [标签] [图片]";
+    let exec = await saveImg(tag, img, savePath);
+    if (!exec.result)
+      return `保存图片失败：${exec.error}`;
+    return "保存图片成功";
+  });
+  ctx.command("get <参数>", "获取标签对应图片").check(({ session }) => {
+    if (!connected) return;
+    if (!is_at_bot(session)) return;
+  }).action(async ({ session }, ...args) => {
+    const tag = args?.[0];
+    if (!tag) return "请提供正确格式，如：@bot get [标签]";
+    let exec = await randomImgByTag(tag, savePath);
+    if (!exec)
+      return `获取图片失败`;
+    return exec;
+  });
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  logger,
+  name,
+  savePath
+});

package/lib/infra/mysql_init.d.ts

@@ -0,0 +1,5 @@
+import { Sequelize } from 'sequelize';
+import type { MysqlConfig } from '../utils/config';
+export declare function initSequelize(cfg?: MysqlConfig): void;
+export declare function getSequelize(): Sequelize;
+export declare function testConnect(): Promise<boolean>;

package/lib/models/imgs.d.ts

@@ -0,0 +1,17 @@
+import { Model, Optional } from 'sequelize';
+export interface ImgAttributes {
+    id: number;
+    tag_id: number;
+    img_url: string;
+    status: number | null;
+    createtime: Date;
+}
+export type ImgCreationAttributes = Optional<ImgAttributes, 'id' | 'status' | 'createtime'>;
+export declare class ImgsModel extends Model<ImgAttributes, ImgCreationAttributes> implements ImgAttributes {
+    id: number;
+    tag_id: number;
+    img_url: string;
+    status: number | null;
+    createtime: Date;
+}
+export declare function getImgsModel(): typeof ImgsModel;

package/lib/models/tags.d.ts

@@ -0,0 +1,17 @@
+import { Model, Optional } from 'sequelize';
+export interface TagAttributes {
+    id: number;
+    tags: string;
+    alias: string | null;
+    status: number | null;
+    createtime: Date;
+}
+export type TagCreationAttributes = Optional<TagAttributes, 'id' | 'alias' | 'status' | 'createtime'>;
+export declare class TagsModel extends Model<TagAttributes, TagCreationAttributes> implements TagAttributes {
+    id: number;
+    tags: string;
+    alias: string | null;
+    status: number | null;
+    createtime: Date;
+}
+export declare function getTagsModel(): typeof TagsModel;

package/lib/services/img_service.d.ts

@@ -0,0 +1,6 @@
+declare function saveImg(name: string, img: string, savePath: string): Promise<{
+    result: boolean;
+    error: string | null;
+}>;
+declare function randomImgByTag(name: string, savePath: string): Promise<string | null>;
+export { saveImg, randomImgByTag };

package/lib/services/tag_service.d.ts

@@ -0,0 +1,7 @@
+import { TagsModel } from '../models/tags';
+declare function createorUpdateTag(name: string, alias?: string | null, savePath?: string | null): Promise<{
+    result: boolean;
+    error: string | null;
+}>;
+declare function getTag(name: string): Promise<TagsModel | null>;
+export { createorUpdateTag, getTag };

package/lib/utils/common.d.ts

@@ -0,0 +1 @@
+export declare function is_at_bot(session: any): boolean;

package/lib/utils/config.d.ts

@@ -0,0 +1,17 @@
+import { Schema } from 'koishi';
+interface MysqlConfig {
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database: string;
+}
+declare const MysqlConfigSchema: Schema<MysqlConfig>;
+declare function loadMysqlConfigFromEnv(env?: NodeJS.ProcessEnv): MysqlConfig;
+declare function toMysqlUri(cfg: MysqlConfig): string;
+interface SaveConfig {
+    save_path: string;
+}
+declare const SaveConfigSchema: Schema<SaveConfig>;
+declare function resolveTagBaseDir(config?: SaveConfig): string;
+export { MysqlConfigSchema, SaveConfigSchema, MysqlConfig, SaveConfig, loadMysqlConfigFromEnv, toMysqlUri, resolveTagBaseDir };

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "koishi-plugin-cocoyyy-console",
+  "description": "for self using, function console",
+  "version": "1.0.0",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "contributors": [ 
+    "黑椰Coco"
+  ],
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "license": "MIT",
+  "scripts": {},
+  "keywords": [
+    "chatbot",
+    "koishi",
+    "plugin"
+  ],
+  "devDependencies": {},
+  "peerDependencies": {
+    "koishi": "^4.18.7"
+  },
+  "dependencies": {
+    "mysql2": "^3.11.0",
+    "sequelize": "^6.37.3"
+  }
+}

package/readme.md

@@ -0,0 +1,5 @@
+# koishi-plugin-cocoyyy-console
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-cocoyyy-console?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-cocoyyy-console)
+
+for self using, function console