koishi-plugin-eqserver-connect 0.0.1

package/lib/index.d.ts

@@ -0,0 +1,15 @@
+import { Context, Schema } from 'koishi';
+export declare const name = "eqserver-connect";
+export interface Config {
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database: string;
+    groupIds: string[];
+    timezoneOffset: number;
+    minReward: number;
+    maxReward: number;
+}
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -0,0 +1,314 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  name: () => name
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi = require("koishi");
+var import_pg = require("pg");
+const name = "eqserver-connect";
+const Config = import_koishi.Schema.object({
+  host: import_koishi.Schema.string().default("127.0.0.1").description("PostgreSQL IP"),
+  port: import_koishi.Schema.number().default(5432).description("PostgreSQL \u7AEF\u53E3"),
+  user: import_koishi.Schema.string().default("postgres").description("PostgreSQL \u8D26\u53F7"),
+  password: import_koishi.Schema.string().role("secret").default("").description("PostgreSQL \u5BC6\u7801"),
+  database: import_koishi.Schema.string().default("postgres").description("\u6570\u636E\u5E93\u540D"),
+  groupIds: import_koishi.Schema.array(import_koishi.Schema.string()).role("table").default([]).description("\u5141\u8BB8\u7B7E\u5230\u7684\u7FA4\u804A ID \u5217\u8868\uFF0C\u53EF\u586B channelId \u6216 platform:channelId\u3002sandbox \u7FA4\u804A\u9ED8\u8BA4\u5141\u8BB8\u3002"),
+  timezoneOffset: import_koishi.Schema.number().default(8).description("\u7B7E\u5230\u65F6\u533A\u504F\u79FB\uFF08\u5C0F\u65F6\uFF09\uFF0C\u9ED8\u8BA4 +8\u3002"),
+  minReward: import_koishi.Schema.number().default(100).description("\u7B7E\u5230\u6700\u5C0F\u5956\u52B1\u3002"),
+  maxReward: import_koishi.Schema.number().default(500).description("\u7B7E\u5230\u6700\u5927\u5956\u52B1\u3002")
+});
+const HOUR_MS = 60 * 60 * 1e3;
+function getSignDay(now, timezoneOffset) {
+  const shifted = now.getTime() + timezoneOffset * HOUR_MS - 12 * HOUR_MS;
+  return new Date(shifted).toISOString().slice(0, 10);
+}
+function normalizeGroupIds(groupIds) {
+  if (!Array.isArray(groupIds)) return [];
+  return [...new Set(
+    groupIds.map((item) => typeof item === "string" ? item.trim() : "").filter(Boolean)
+  )];
+}
+function isSandboxGroupSession(session) {
+  const platform = session.platform || "";
+  if (!platform.startsWith("sandbox")) return false;
+  if (!session.channelId) return false;
+  if (session.isDirect) return false;
+  if (session.userId && session.channelId === `@${session.userId}`) return false;
+  return true;
+}
+function isAllowedGroup(session, groupIds) {
+  if (!session.channelId) return false;
+  if (isSandboxGroupSession(session)) return true;
+  if (!groupIds.length) return false;
+  const plainId = session.channelId;
+  const scopedId = `${session.platform}:${session.channelId}`;
+  return groupIds.includes(plainId) || groupIds.includes(scopedId);
+}
+function getRewardRange(minReward, maxReward) {
+  const left = Math.max(0, Math.floor(Math.min(minReward, maxReward)));
+  const right = Math.max(left, Math.floor(Math.max(minReward, maxReward)));
+  return [left, right];
+}
+function randomInt(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function isUniqueViolation(error) {
+  if (!error || typeof error !== "object") return false;
+  return error.code === "23505";
+}
+async function getStorePlayersColumnType(client, columnName) {
+  const result = await client.query(
+    `
+      SELECT format_type(a.atttypid, a.atttypmod) AS column_type
+      FROM pg_attribute a
+      JOIN pg_class c ON a.attrelid = c.oid
+      JOIN pg_namespace n ON c.relnamespace = n.oid
+      WHERE c.relname = 'store_players'
+        AND n.nspname = ANY(current_schemas(false))
+        AND a.attname = $1
+        AND a.attnum > 0
+        AND NOT a.attisdropped
+      LIMIT 1
+    `,
+    [columnName]
+  );
+  if (!result.rowCount) {
+    throw new Error(`\u7F3A\u5C11\u5B57\u6BB5\uFF1Astore_players.${columnName}`);
+  }
+  return result.rows[0].column_type;
+}
+function apply(ctx, config) {
+  const logger = ctx.logger(name);
+  const pool = new import_pg.Pool({
+    host: config.host,
+    port: config.port,
+    user: config.user,
+    password: config.password,
+    database: config.database
+  });
+  const allowedGroupIds = normalizeGroupIds(config.groupIds);
+  const [minReward, maxReward] = getRewardRange(config.minReward, config.maxReward);
+  let initialized = false;
+  let initializeTask = null;
+  async function initDatabase() {
+    if (initialized) return;
+    if (initializeTask) return initializeTask;
+    initializeTask = (async () => {
+      const playerIdType = await getStorePlayersColumnType(pool, "id");
+      await getStorePlayersColumnType(pool, "authid");
+      await getStorePlayersColumnType(pool, "credits");
+      await pool.query(`
+        CREATE TABLE IF NOT EXISTS koishi_player_bind (
+          id BIGSERIAL PRIMARY KEY,
+          koishi_platform TEXT NOT NULL,
+          koishi_user_id TEXT NOT NULL,
+          player_id ${playerIdType} NOT NULL REFERENCES store_players(id) ON DELETE CASCADE,
+          authid TEXT NOT NULL UNIQUE,
+          created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+          updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+          UNIQUE (koishi_platform, koishi_user_id)
+        )
+      `);
+      await pool.query(`
+        CREATE TABLE IF NOT EXISTS koishi_signin (
+          id BIGSERIAL PRIMARY KEY,
+          player_id ${playerIdType} NOT NULL REFERENCES store_players(id) ON DELETE CASCADE,
+          koishi_platform TEXT NOT NULL,
+          koishi_user_id TEXT NOT NULL,
+          sign_day DATE NOT NULL,
+          reward INTEGER NOT NULL,
+          signed_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+          UNIQUE (player_id, sign_day)
+        )
+      `);
+      await pool.query(`
+        CREATE INDEX IF NOT EXISTS idx_koishi_signin_player_signed_at
+        ON koishi_signin (player_id, signed_at DESC)
+      `);
+      initialized = true;
+      logger.info("PostgreSQL connected and tables are ready.");
+    })();
+    try {
+      await initializeTask;
+    } catch (error) {
+      logger.error(error);
+      throw error;
+    } finally {
+      initializeTask = null;
+    }
+  }
+  async function ensureDatabaseReady() {
+    try {
+      await initDatabase();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  ctx.on("ready", () => {
+    void initDatabase().catch((error) => {
+      logger.warn("init failed, commands will retry on demand.");
+      logger.error(error);
+    });
+  });
+  ctx.on("dispose", () => {
+    void pool.end().catch((error) => logger.warn(String(error)));
+  });
+  ctx.command("register <authid:text>", "\u7ED1\u5B9A\u6069\u60C5\u670D\u52A1\u5668\u73A9\u5BB6").alias("\u6CE8\u518C").action(async ({ session }, authid) => {
+    if (!session?.userId) return "\u65E0\u6CD5\u8BC6\u522B Koishi \u7528\u6237\u3002";
+    if (!authid?.trim()) return "\u7528\u6CD5\uFF1A\u6CE8\u518C [steamid]\uFF0C\u5728\u6E38\u620F\u5185\u8F93\u5165!steamid\u83B7\u53D6\u4F60\u81EA\u5DF1\u7684steamid";
+    const authidText = authid.trim();
+    if (!/^\d+:\d+$/.test(authidText)) {
+      return "steamid \u683C\u5F0F\u9519\u8BEF\uFF0C\u793A\u4F8B\uFF1A\u6CE8\u518C 1:99999999\uFF0C\u5728\u6E38\u620F\u5185\u8F93\u5165!steamid\u83B7\u53D6\u4F60\u81EA\u5DF1\u7684steamid";
+    }
+    if (!await ensureDatabaseReady()) {
+      return "\u6570\u636E\u5E93\u8FDE\u63A5\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u63D2\u4EF6\u8BBE\u7F6E\u3002";
+    }
+    const platform = session.platform || "unknown";
+    const userId = session.userId;
+    const client = await pool.connect();
+    try {
+      const playerResult = await client.query(
+        `
+            SELECT id
+            FROM store_players
+            WHERE authid = $1
+            LIMIT 1
+          `,
+        [authidText]
+      );
+      if (!playerResult.rowCount) {
+        return `\u672A\u627E\u5230 authid=${authidText} \u5BF9\u5E94\u7684\u73A9\u5BB6\u3002`;
+      }
+      const playerId = playerResult.rows[0].id;
+      const occupied = await client.query(
+        `
+            SELECT koishi_platform, koishi_user_id
+            FROM koishi_player_bind
+            WHERE authid = $1
+            LIMIT 1
+          `,
+        [authidText]
+      );
+      if (occupied.rowCount && (occupied.rows[0].koishi_platform !== platform || occupied.rows[0].koishi_user_id !== userId)) {
+        return "\u8BE5 authid \u5DF2\u88AB\u5176\u4ED6 Koishi \u8D26\u53F7\u7ED1\u5B9A\u3002";
+      }
+      await client.query(
+        `
+            INSERT INTO koishi_player_bind (koishi_platform, koishi_user_id, player_id, authid)
+            VALUES ($1, $2, $3, $4)
+            ON CONFLICT (koishi_platform, koishi_user_id)
+            DO UPDATE SET
+              player_id = EXCLUDED.player_id,
+              authid = EXCLUDED.authid,
+              updated_at = NOW()
+          `,
+        [platform, userId, playerId, authidText]
+      );
+      return `\u6CE8\u518C\u6210\u529F\uFF0C\u5DF2\u7ED1\u5B9A\u73A9\u5BB6 ID\uFF1A${String(playerId)}`;
+    } catch (error) {
+      logger.error(error);
+      return "\u6CE8\u518C\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002";
+    } finally {
+      client.release();
+    }
+  });
+  ctx.command("qd", "\u6BCF\u65E5\u7B7E\u5230").alias("\u7B7E\u5230").action(async ({ session }) => {
+    if (!session?.userId) return "\u65E0\u6CD5\u8BC6\u522B Koishi \u7528\u6237\u3002";
+    if (!isAllowedGroup(session, allowedGroupIds)) return;
+    if (!await ensureDatabaseReady()) {
+      return "\u6570\u636E\u5E93\u8FDE\u63A5\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u63D2\u4EF6\u8BBE\u7F6E\u3002";
+    }
+    const platform = session.platform || "unknown";
+    const userId = session.userId;
+    const bindResult = await pool.query(
+      `
+          SELECT player_id, authid
+          FROM koishi_player_bind
+          WHERE koishi_platform = $1
+            AND koishi_user_id = $2
+          LIMIT 1
+        `,
+      [platform, userId]
+    );
+    if (!bindResult.rowCount) {
+      return "\u4F60\u8FD8\u6CA1\u6709\u6CE8\u518C\uFF0C\u8BF7\u5148\u53D1\u9001\uFF1A\u6CE8\u518C [steamid]\uFF0C\u5728\u6E38\u620F\u5185\u8F93\u5165!steamid\u83B7\u53D6\u4F60\u81EA\u5DF1\u7684steamid";
+    }
+    const bind = bindResult.rows[0];
+    const signDay = getSignDay(/* @__PURE__ */ new Date(), config.timezoneOffset);
+    const reward = randomInt(minReward, maxReward);
+    const client = await pool.connect();
+    try {
+      await client.query("BEGIN");
+      const existed = await client.query(
+        `
+            SELECT reward
+            FROM koishi_signin
+            WHERE player_id = $1
+              AND sign_day = $2
+            LIMIT 1
+          `,
+        [bind.player_id, signDay]
+      );
+      if (existed.rowCount) {
+        await client.query("ROLLBACK");
+        return `\u4ECA\u5929\u5DF2\u7ECF\u7B7E\u5230\u8FC7\u4E86\uFF0C\u4E0A\u6B21\u83B7\u5F97 ${existed.rows[0].reward} \u6069\u60C5\u5E01\u3002`;
+      }
+      await client.query(
+        `
+            INSERT INTO koishi_signin (player_id, koishi_platform, koishi_user_id, sign_day, reward)
+            VALUES ($1, $2, $3, $4, $5)
+          `,
+        [bind.player_id, platform, userId, signDay, reward]
+      );
+      const creditResult = await client.query(
+        `
+            UPDATE store_players
+            SET credits = COALESCE(credits, 0) + $1
+            WHERE id = $2
+            RETURNING credits
+          `,
+        [reward, bind.player_id]
+      );
+      if (!creditResult.rowCount) {
+        throw new Error(`\u672A\u627E\u5230\u73A9\u5BB6 ID\uFF1A${String(bind.player_id)}`);
+      }
+      await client.query("COMMIT");
+      return `\u7B7E\u5230\u6210\u529F\uFF0C\u83B7\u5F97 ${reward} \u6069\u60C5\u5E01\u3002\u5F53\u524D \u6069\u60C5\u5E01\uFF1A${String(creditResult.rows[0].credits)}`;
+    } catch (error) {
+      await client.query("ROLLBACK").catch(() => null);
+      if (isUniqueViolation(error)) {
+        return "\u4ECA\u5929\u5DF2\u7ECF\u7B7E\u5230\u8FC7\u4E86\u3002";
+      }
+      logger.error(error);
+      return "\u7B7E\u5230\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002";
+    } finally {
+      client.release();
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  name
+});

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "koishi-plugin-eqserver-connect",
+  "description": "EQ server PostgreSQL connector with register + daily signin",
+  "version": "0.0.1",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "license": "MIT",
+  "scripts": {},
+  "keywords": [
+    "chatbot",
+    "koishi",
+    "plugin",
+    "postgresql",
+    "signin"
+  ],
+  "peerDependencies": {
+    "koishi": "^4.18.0"
+  },
+  "dependencies": {
+    "pg": "^8.13.1"
+  }
+}

package/readme.md

@@ -0,0 +1,20 @@
+# koishi-plugin-eqserver-connect
+
+PostgreSQL connector plugin for Koishi:
+
+- Register player mapping with `注册 <authid>` (alias: `register`).
+- Daily sign-in with `签到` (alias: `qd`).
+- One sign-in per day, reset at 12:00 (configurable timezone offset).
+- Rewards `100-500` by default, and directly adds to `store_players.credits`.
+- Group whitelist in plugin config (`groupIds`), with sandbox groups allowed by default.
+
+## Required database table
+
+The plugin expects an existing table:
+
+- `store_players(id, authid, credits, ...)`
+
+It auto-creates:
+
+- `koishi_player_bind` (Koishi user -> player binding)
+- `koishi_signin` (daily sign-in records)