koishi-plugin-monetary-bourse 1.0.0-alpha.1

package/lib/index.d.ts

@@ -0,0 +1,80 @@
+import { Context, Schema } from 'koishi';
+export declare const name = "monetary-bourse";
+export declare const inject: {
+    required: string[];
+    optional: string[];
+};
+interface MonetaryBankInterest {
+    id: number;
+    uid: number;
+    currency: string;
+    amount: number;
+    type: 'demand' | 'fixed';
+    rate: number;
+    cycle: 'day' | 'week' | 'month';
+    settlementDate: Date;
+    extendRequested: boolean;
+    nextRate?: number;
+    nextCycle?: 'day' | 'week' | 'month';
+}
+declare module 'koishi' {
+    interface Tables {
+        bourse_holding: BourseHolding;
+        bourse_pending: BoursePending;
+        bourse_history: BourseHistory;
+        bourse_state: BourseState;
+        monetary_bank_int: MonetaryBankInterest;
+    }
+}
+export interface BourseHolding {
+    id: number;
+    userId: string;
+    stockId: string;
+    amount: number;
+}
+export interface BoursePending {
+    id: number;
+    userId: string;
+    uid: number;
+    stockId: string;
+    type: 'buy' | 'sell';
+    amount: number;
+    price: number;
+    cost: number;
+    startTime: Date;
+    endTime: Date;
+}
+export interface BourseHistory {
+    id: number;
+    stockId: string;
+    price: number;
+    time: Date;
+}
+export interface BourseState {
+    key: string;
+    lastCycleStart: Date;
+    startPrice: number;
+    targetPrice: number;
+    trendFactor: number;
+    mode: 'auto' | 'manual';
+    endTime: Date;
+    marketOpenStatus?: 'open' | 'close' | 'auto';
+}
+export interface Config {
+    currency: string;
+    stockName: string;
+    initialPrice: number;
+    maxHoldings: number;
+    openHour: number;
+    closeHour: number;
+    freezeCostPerMinute: number;
+    minFreezeTime: number;
+    maxFreezeTime: number;
+    enableManualControl: boolean;
+    manualTargetPrice: number;
+    manualDuration: number;
+    marketStatus: 'open' | 'close' | 'auto';
+}
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): void;
+export {};

package/lib/index.js

@@ -0,0 +1,777 @@
+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,
+  inject: () => inject,
+  name: () => name
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi = require("koishi");
+var name = "monetary-bourse";
+var inject = {
+  required: ["database", "puppeteer"],
+  optional: ["monetary"]
+};
+var logger = new import_koishi.Logger("bourse");
+var Config = import_koishi.Schema.intersect([
+  import_koishi.Schema.object({
+    currency: import_koishi.Schema.string().default("信用点").description("货币单位名称"),
+    stockName: import_koishi.Schema.string().default("Koishi股份").description("股票名称"),
+    initialPrice: import_koishi.Schema.number().min(0.01).default(1200).description("股票初始价格"),
+    maxHoldings: import_koishi.Schema.number().min(1).step(1).default(1e5).description("单人最大持仓限制")
+  }).description("基础设置"),
+  import_koishi.Schema.object({
+    marketStatus: import_koishi.Schema.union(["open", "close", "auto"]).default("auto").description("股市开关状态：open=强制开启，close=强制关闭，auto=按时间自动")
+  }).description("股市开关"),
+  import_koishi.Schema.object({
+    openHour: import_koishi.Schema.number().min(0).max(23).step(1).default(8).description("开市时间 (小时)"),
+    closeHour: import_koishi.Schema.number().min(0).max(23).step(1).default(23).description("休市时间 (小时)")
+  }).description("交易时间"),
+  import_koishi.Schema.object({
+    freezeCostPerMinute: import_koishi.Schema.number().min(1).default(100).description("每多少货币计为1分钟冻结时间"),
+    minFreezeTime: import_koishi.Schema.number().min(0).default(10).description("最小冻结时间(分钟)"),
+    maxFreezeTime: import_koishi.Schema.number().min(0).default(1440).description("最大交易冻结时间(分钟)")
+  }).description("冻结机制"),
+  import_koishi.Schema.object({
+    enableManualControl: import_koishi.Schema.boolean().default(false).description("开启手动宏观调控(覆盖自动)"),
+    manualTargetPrice: import_koishi.Schema.number().min(0.01).default(1e3).description("手动目标价格"),
+    manualDuration: import_koishi.Schema.number().min(1).default(24).description("手动调控周期(小时)")
+  }).description("手动宏观调控")
+]);
+function apply(ctx, config) {
+  ctx.model.extend("bourse_holding", {
+    id: "unsigned",
+    userId: "string",
+    stockId: "string",
+    amount: "integer"
+  }, { primary: ["userId", "stockId"] });
+  ctx.model.extend("bourse_pending", {
+    id: "unsigned",
+    userId: "string",
+    uid: "unsigned",
+    stockId: "string",
+    type: "string",
+    amount: "integer",
+    price: "double",
+    cost: "double",
+    startTime: "timestamp",
+    endTime: "timestamp"
+  }, { autoInc: true });
+  ctx.model.extend("bourse_history", {
+    id: "unsigned",
+    stockId: "string",
+    price: "double",
+    time: "timestamp"
+  }, { autoInc: true });
+  ctx.model.extend("bourse_state", {
+    key: "string",
+    lastCycleStart: "timestamp",
+    startPrice: "double",
+    targetPrice: "double",
+    trendFactor: "double",
+    mode: "string",
+    endTime: "timestamp",
+    marketOpenStatus: "string"
+  }, { primary: "key" });
+  const stockId = "MAIN";
+  let currentPrice = config.initialPrice;
+  ctx.on("ready", async () => {
+    const history = await ctx.database.get("bourse_history", { stockId }, { limit: 1, sort: { time: "desc" } });
+    if (history.length > 0) {
+      currentPrice = history[0].price;
+    } else {
+      await ctx.database.create("bourse_history", { stockId, price: currentPrice, time: /* @__PURE__ */ new Date() });
+    }
+  });
+  ctx.setInterval(async () => {
+    if (!await isMarketOpen()) return;
+    await updatePrice();
+    await processPendingTransactions();
+    const oneMonthAgo = new Date(Date.now() - 30 * 24 * 3600 * 1e3);
+    await ctx.database.remove("bourse_history", { time: { $lt: oneMonthAgo } });
+  }, 2 * 60 * 1e3);
+  async function isMarketOpen() {
+    if (config.marketStatus === "open") return true;
+    if (config.marketStatus === "close") return false;
+    const states = await ctx.database.get("bourse_state", { key: "macro_state" });
+    const state = states[0];
+    if (state && state.marketOpenStatus) {
+      if (state.marketOpenStatus === "open") return true;
+      if (state.marketOpenStatus === "close") return false;
+    }
+    const now = /* @__PURE__ */ new Date();
+    const day = now.getDay();
+    const hour = now.getHours();
+    if (day === 0 || day === 6) return false;
+    if (hour < config.openHour || hour >= config.closeHour) return false;
+    return true;
+  }
+  __name(isMarketOpen, "isMarketOpen");
+  async function getCashBalance(uid, currency) {
+    if (!uid || typeof uid !== "number" || Number.isNaN(uid)) {
+      logger.warn(`getCashBalance: 无效的uid: ${uid}`);
+      return 0;
+    }
+    try {
+      const records = await ctx.database.get("monetary", { uid, currency });
+      logger.info(`getCashBalance: uid=${uid}, currency=${currency}, records=${JSON.stringify(records)}`);
+      if (records && records.length > 0) {
+        const value = Number(records[0].value || 0);
+        return Number.isNaN(value) ? 0 : value;
+      }
+      return 0;
+    } catch (err) {
+      logger.error(`getCashBalance 失败: uid=${uid}, currency=${currency}`, err);
+      return 0;
+    }
+  }
+  __name(getCashBalance, "getCashBalance");
+  async function changeCashBalance(uid, currency, delta) {
+    if (!uid || typeof uid !== "number" || Number.isNaN(uid)) {
+      logger.warn(`changeCashBalance: 无效的uid: ${uid}`);
+      return false;
+    }
+    try {
+      const records = await ctx.database.get("monetary", { uid, currency });
+      if (!records || records.length === 0) {
+        if (delta < 0) return false;
+        try {
+          await ctx.database.create("monetary", { uid, currency, value: delta });
+          logger.info(`changeCashBalance: 创建新记录 uid=${uid}, currency=${currency}, value=${delta}`);
+          return true;
+        } catch (createErr) {
+          logger.error(`changeCashBalance 创建记录失败:`, createErr);
+          return false;
+        }
+      }
+      const current = Number(records[0].value || 0);
+      const newValue = current + delta;
+      if (newValue < 0) {
+        logger.warn(`changeCashBalance: 余额不足 current=${current}, delta=${delta}`);
+        return false;
+      }
+      await ctx.database.set("monetary", { uid, currency }, { value: newValue });
+      logger.info(`changeCashBalance: uid=${uid}, currency=${currency}, ${current} -> ${newValue}`);
+      return true;
+    } catch (err) {
+      logger.error(`changeCashBalance 失败: uid=${uid}, currency=${currency}, delta=${delta}`, err);
+      return false;
+    }
+  }
+  __name(changeCashBalance, "changeCashBalance");
+  async function getBankDemandBalance(uid, currency) {
+    if (!uid || typeof uid !== "number" || Number.isNaN(uid)) return 0;
+    try {
+      const tables = ctx.database.tables;
+      if (!tables || !("monetary_bank_int" in tables)) {
+        logger.info("getBankDemandBalance: monetary_bank_int 表不存在");
+        return 0;
+      }
+      const records = await ctx.database.get("monetary_bank_int", { uid, currency, type: "demand" });
+      logger.info(`getBankDemandBalance: uid=${uid}, currency=${currency}, records=${records.length}`);
+      let total = 0;
+      for (const record of records) {
+        total += Number(record.amount || 0);
+      }
+      return total;
+    } catch (err) {
+      logger.warn(`getBankDemandBalance 失败: uid=${uid}`, err);
+      return 0;
+    }
+  }
+  __name(getBankDemandBalance, "getBankDemandBalance");
+  async function deductBankDemand(uid, currency, amount) {
+    if (!uid || typeof uid !== "number" || Number.isNaN(uid) || amount <= 0) return false;
+    try {
+      const tables = ctx.database.tables;
+      if (!tables || !("monetary_bank_int" in tables)) return false;
+      const demandRecords = await ctx.database.select("monetary_bank_int").where({ uid, currency, type: "demand" }).orderBy("settlementDate", "asc").execute();
+      let remaining = amount;
+      for (const record of demandRecords) {
+        if (remaining <= 0) break;
+        if (record.amount <= remaining) {
+          remaining -= record.amount;
+          await ctx.database.remove("monetary_bank_int", { id: record.id });
+        } else {
+          await ctx.database.set("monetary_bank_int", { id: record.id }, { amount: record.amount - remaining });
+          remaining = 0;
+        }
+      }
+      logger.info(`deductBankDemand: uid=${uid}, amount=${amount}, remaining=${remaining}`);
+      return remaining === 0;
+    } catch (err) {
+      logger.error(`deductBankDemand 失败:`, err);
+      return false;
+    }
+  }
+  __name(deductBankDemand, "deductBankDemand");
+  async function pay(uid, cost, currency) {
+    logger.info(`pay: uid=${uid}, cost=${cost}, currency=${currency}`);
+    const cash = await getCashBalance(uid, currency);
+    const bankDemand = await getBankDemandBalance(uid, currency);
+    logger.info(`pay: 现金=${cash}, 活期=${bankDemand}, 需要=${cost}`);
+    if (cash + bankDemand < cost) {
+      return { success: false, msg: `资金不足！需要 ${cost.toFixed(2)}，当前现金 ${cash} + 活期 ${bankDemand}` };
+    }
+    let remainingCost = cost;
+    const cashDeduct = Math.min(cash, remainingCost);
+    if (cashDeduct > 0) {
+      const success = await changeCashBalance(uid, currency, -cashDeduct);
+      if (!success) return { success: false, msg: "扣除现金失败，请重试" };
+      remainingCost -= cashDeduct;
+    }
+    if (remainingCost > 0) {
+      const success = await deductBankDemand(uid, currency, remainingCost);
+      if (!success) {
+        if (cashDeduct > 0) await changeCashBalance(uid, currency, cashDeduct);
+        return { success: false, msg: "银行活期扣款失败" };
+      }
+    }
+    return { success: true };
+  }
+  __name(pay, "pay");
+  async function updatePrice() {
+    let state = (await ctx.database.get("bourse_state", { key: "macro_state" }))[0];
+    const now = /* @__PURE__ */ new Date();
+    if (state) {
+      if (!state.lastCycleStart) state.lastCycleStart = new Date(Date.now() - 24 * 3600 * 1e3);
+      if (!(state.lastCycleStart instanceof Date)) state.lastCycleStart = new Date(state.lastCycleStart);
+      if (!state.endTime) state.endTime = new Date(state.lastCycleStart.getTime() + 24 * 3600 * 1e3);
+      if (!(state.endTime instanceof Date)) state.endTime = new Date(state.endTime);
+    }
+    if (config.enableManualControl) {
+      if (!state || state.mode !== "manual" || Math.abs(state.targetPrice - config.manualTargetPrice) > 0.01) {
+        const durationHours = config.manualDuration;
+        const targetPrice = config.manualTargetPrice;
+        const endTime = new Date(now.getTime() + durationHours * 3600 * 1e3);
+        const minutes = durationHours * 60;
+        const trendFactor = (targetPrice - currentPrice) / minutes;
+        const newState = {
+          key: "macro_state",
+          lastCycleStart: now,
+          startPrice: currentPrice,
+          targetPrice,
+          trendFactor,
+          mode: "manual",
+          endTime
+        };
+        if (!state) await ctx.database.create("bourse_state", newState);
+        else await ctx.database.set("bourse_state", "macro_state", newState);
+        state = newState;
+      }
+    }
+    let needNewState = false;
+    if (!config.enableManualControl) {
+      if (!state) {
+        needNewState = true;
+      } else {
+        const endTime = state.endTime || new Date(state.lastCycleStart.getTime() + 24 * 3600 * 1e3);
+        if (now > endTime) {
+          needNewState = true;
+        }
+      }
+      if (needNewState) {
+        const durationHours = 24;
+        const fluctuation = 0.25;
+        const targetRatio = 1 + (Math.random() * 2 - 1) * fluctuation;
+        const targetPrice = currentPrice * targetRatio;
+        const endTime = new Date(now.getTime() + durationHours * 3600 * 1e3);
+        const minutes = durationHours * 60;
+        const trendFactor = (targetPrice - currentPrice) / minutes;
+        const newState = {
+          key: "macro_state",
+          lastCycleStart: now,
+          startPrice: currentPrice,
+          targetPrice,
+          trendFactor,
+          mode: "auto",
+          endTime
+        };
+        if (!state) {
+          await ctx.database.create("bourse_state", newState);
+        } else {
+          await ctx.database.set("bourse_state", "macro_state", newState);
+        }
+        state = newState;
+      }
+    }
+    const trend = state.trendFactor * 2;
+    const volatility = currentPrice * 5e-3 * (Math.random() * 2 - 1);
+    const totalDuration = state.endTime.getTime() - state.lastCycleStart.getTime();
+    const elapsed = now.getTime() - state.lastCycleStart.getTime();
+    const prevElapsed = elapsed - 2 * 60 * 1e3;
+    const waveCount = 3;
+    const amplitude = state.startPrice * 0.15;
+    const getWaveValue = /* @__PURE__ */ __name((t) => {
+      const progress = t / totalDuration;
+      return amplitude * Math.sin(2 * Math.PI * waveCount * progress);
+    }, "getWaveValue");
+    const waveDelta = getWaveValue(elapsed) - getWaveValue(prevElapsed);
+    let newPrice = currentPrice + trend + volatility + waveDelta;
+    if (newPrice < 1) newPrice = 1;
+    currentPrice = newPrice;
+    await ctx.database.create("bourse_history", { stockId, price: newPrice, time: /* @__PURE__ */ new Date() });
+  }
+  __name(updatePrice, "updatePrice");
+  async function processPendingTransactions() {
+    const now = /* @__PURE__ */ new Date();
+    const pending = await ctx.database.get("bourse_pending", { endTime: { $lte: now } });
+    for (const txn of pending) {
+      if (txn.type === "buy") {
+        const holding = await ctx.database.get("bourse_holding", { userId: txn.userId, stockId });
+        if (holding.length === 0) {
+          await ctx.database.create("bourse_holding", { userId: txn.userId, stockId, amount: txn.amount });
+        } else {
+          await ctx.database.set("bourse_holding", { userId: txn.userId, stockId }, { amount: holding[0].amount + txn.amount });
+        }
+      } else if (txn.type === "sell") {
+        if (txn.uid && typeof txn.uid === "number") {
+          const amount = Number(txn.cost.toFixed(2));
+          await changeCashBalance(txn.uid, config.currency, amount);
+        } else {
+          logger.warn(`processPendingTransactions: 卖出订单缺少有效uid, txn.id=${txn.id}`);
+        }
+      }
+      await ctx.database.remove("bourse_pending", { id: txn.id });
+    }
+  }
+  __name(processPendingTransactions, "processPendingTransactions");
+  ctx.command("stock [interval:string]", "查看股市行情").action(async ({ session }, interval) => {
+    if (["buy", "sell", "my"].includes(interval)) {
+      const parts = session.content.trim().split(/\s+/).slice(2);
+      const rest = parts.join(" ");
+      return session.execute(`stock.${interval} ${rest}`);
+    }
+    if (!await isMarketOpen()) return "股市目前休市中。（开放时间：工作日 " + config.openHour + ":00 - " + config.closeHour + ":00）";
+    let history;
+    const now = /* @__PURE__ */ new Date();
+    if (interval === "day") {
+      const startTime = new Date(now.getTime() - 24 * 3600 * 1e3);
+      history = await ctx.database.get("bourse_history", {
+        stockId,
+        time: { $gte: startTime }
+      }, { sort: { time: "asc" } });
+    } else if (interval === "week") {
+      const startTime = new Date(now.getTime() - 7 * 24 * 3600 * 1e3);
+      history = await ctx.database.get("bourse_history", {
+        stockId,
+        time: { $gte: startTime }
+      }, { sort: { time: "asc" } });
+    } else {
+      history = await ctx.database.get("bourse_history", { stockId }, {
+        limit: 100,
+        sort: { time: "desc" }
+      });
+      history = history.reverse();
+    }
+    if (history.length === 0) return "暂无行情数据。";
+    if (history.length > 300) {
+      const step = Math.ceil(history.length / 300);
+      history = history.filter((_, index) => index % step === 0);
+    }
+    const latest = history[history.length - 1];
+    const formattedData = history.map((h2) => {
+      let timeStr = h2.time.toLocaleTimeString();
+      if (interval === "week" || interval === "day") {
+        timeStr = `${h2.time.getMonth() + 1}-${h2.time.getDate()} ${h2.time.getHours()}:${h2.time.getMinutes().toString().padStart(2, "0")}`;
+      }
+      return {
+        time: timeStr,
+        price: h2.price,
+        timestamp: h2.time.getTime()
+      };
+    });
+    const high = Math.max(...formattedData.map((d) => d.price));
+    const low = Math.min(...formattedData.map((d) => d.price));
+    const title = config.stockName + (interval === "week" ? " (周走势)" : interval === "day" ? " (日走势)" : " (实时)");
+    const img = await renderStockImage(ctx, formattedData, title, latest.price, high, low);
+    return img;
+  });
+  ctx.command("stock.buy <amount:number>", "买入股票").userFields(["id"]).action(async ({ session }, amount) => {
+    if (!amount || amount <= 0 || !Number.isInteger(amount)) return "请输入有效的购买股数（整数）。";
+    if (!await isMarketOpen()) return "休市中，无法交易。";
+    const uid = session.user?.id;
+    const visibleUserId = session.userId;
+    if (!uid || typeof uid !== "number") {
+      return "无法获取用户ID，请稍后重试。";
+    }
+    const cost = Number((currentPrice * amount).toFixed(2));
+    const payResult = await pay(uid, cost, config.currency);
+    if (!payResult.success) {
+      return payResult.msg;
+    }
+    let freezeMinutes = cost / config.freezeCostPerMinute;
+    if (freezeMinutes < config.minFreezeTime) freezeMinutes = config.minFreezeTime;
+    if (freezeMinutes > config.maxFreezeTime) freezeMinutes = config.maxFreezeTime;
+    const freezeMs = freezeMinutes * 60 * 1e3;
+    const endTime = new Date(Date.now() + freezeMs);
+    await ctx.database.create("bourse_pending", {
+      userId: visibleUserId,
+      uid,
+      stockId,
+      type: "buy",
+      amount,
+      price: currentPrice,
+      cost,
+      startTime: /* @__PURE__ */ new Date(),
+      endTime
+    });
+    return `交易申请已提交！
+花费: ${cost.toFixed(2)} ${config.currency}
+冻结时间: ${freezeMinutes.toFixed(1)}分钟
+股票将在解冻后到账。`;
+  });
+  ctx.command("stock.sell <amount:number>", "卖出股票").userFields(["id"]).action(async ({ session }, amount) => {
+    if (!amount || amount <= 0 || !Number.isInteger(amount)) return "请输入有效的卖出股数。";
+    if (!await isMarketOpen()) return "休市中，无法交易。";
+    const uid = session.user?.id;
+    const visibleUserId = session.userId;
+    if (!uid || typeof uid !== "number") {
+      return "无法获取用户ID，请稍后重试。";
+    }
+    const holding = await ctx.database.get("bourse_holding", { userId: visibleUserId, stockId });
+    if (holding.length === 0 || holding[0].amount < amount) {
+      return `持仓不足！当前持有: ${holding.length ? holding[0].amount : 0} 股。`;
+    }
+    const newAmount = holding[0].amount - amount;
+    if (newAmount === 0) {
+      await ctx.database.remove("bourse_holding", { userId: visibleUserId, stockId });
+    } else {
+      await ctx.database.set("bourse_holding", { userId: visibleUserId, stockId }, { amount: newAmount });
+    }
+    const gain = Number((currentPrice * amount).toFixed(2));
+    let freezeMinutes = gain / config.freezeCostPerMinute;
+    if (freezeMinutes < config.minFreezeTime) freezeMinutes = config.minFreezeTime;
+    if (freezeMinutes > config.maxFreezeTime) freezeMinutes = config.maxFreezeTime;
+    const freezeMs = freezeMinutes * 60 * 1e3;
+    const endTime = new Date(Date.now() + freezeMs);
+    await ctx.database.create("bourse_pending", {
+      userId: visibleUserId,
+      uid,
+      stockId,
+      type: "sell",
+      amount,
+      price: currentPrice,
+      cost: gain,
+      startTime: /* @__PURE__ */ new Date(),
+      endTime
+    });
+    return `卖出挂单已提交！
+预计收益: ${gain.toFixed(2)} ${config.currency}
+资金冻结: ${freezeMinutes.toFixed(1)}分钟
+资金将在解冻后到账。`;
+  });
+  ctx.command("stock.my", "我的持仓").action(async ({ session }) => {
+    const userId = session.userId;
+    const holdings = await ctx.database.get("bourse_holding", { userId });
+    const pending = await ctx.database.get("bourse_pending", { userId });
+    let msg = `=== ${session.username} 的股票账户 ===
+`;
+    if (holdings.length > 0) {
+      const h2 = holdings[0];
+      const value = h2.amount * currentPrice;
+      msg += `持仓: ${config.stockName} x${h2.amount} 股
+`;
+      msg += `当前市值: ${value.toFixed(2)} ${config.currency}
+`;
+    } else {
+      msg += `持仓: 无
+`;
+    }
+    if (pending.length > 0) {
+      msg += `
+--- 进行中的交易 ---
+`;
+      for (const p of pending) {
+        const timeLeft = Math.max(0, Math.ceil((p.endTime.getTime() - Date.now()) / 1e3));
+        const typeStr = p.type === "buy" ? "买入" : "卖出";
+        msg += `[${typeStr}] ${p.amount}股 | 剩余冻结: ${timeLeft}秒
+`;
+      }
+    }
+    return msg;
+  });
+  ctx.command("stock.control <price:number> [hours:number]", "管理员：设置宏观调控目标", { authority: 3 }).action(async ({ session }, price, hours) => {
+    if (!price || price <= 0) return "请输入有效的目标价格。";
+    const duration = hours || 24;
+    const now = /* @__PURE__ */ new Date();
+    const endTime = new Date(now.getTime() + duration * 3600 * 1e3);
+    const minutes = duration * 60;
+    const trendFactor = (price - currentPrice) / minutes;
+    const newState = {
+      key: "macro_state",
+      lastCycleStart: now,
+      startPrice: currentPrice,
+      targetPrice: price,
+      trendFactor,
+      mode: "manual",
+      endTime
+    };
+    const existing = await ctx.database.get("bourse_state", { key: "macro_state" });
+    if (existing.length === 0) {
+      await ctx.database.create("bourse_state", newState);
+    } else {
+      await ctx.database.set("bourse_state", "macro_state", newState);
+    }
+    return `宏观调控已设置：
+目标价格：${price}
+期限：${duration}小时
+模式：手动干预
+到期后将自动切回随机调控。`;
+  });
+  ctx.command("bourse.admin.market <status>", "设置股市开关状态 (open/close/auto)", { authority: 3 }).action(async ({ session }, status) => {
+    if (!["open", "close", "auto"].includes(status)) return "无效状态，请使用 open, close, 或 auto";
+    const key = "macro_state";
+    const existing = await ctx.database.get("bourse_state", { key });
+    if (existing.length === 0) {
+      const now = /* @__PURE__ */ new Date();
+      await ctx.database.create("bourse_state", {
+        key,
+        lastCycleStart: now,
+        startPrice: config.initialPrice,
+        targetPrice: config.initialPrice,
+        trendFactor: 0,
+        mode: "auto",
+        endTime: new Date(now.getTime() + 24 * 3600 * 1e3),
+        marketOpenStatus: status
+      });
+    } else {
+      await ctx.database.set("bourse_state", { key }, { marketOpenStatus: status });
+    }
+    return `股市状态已设置为: ${status}`;
+  });
+  async function renderStockImage(ctx2, data, name2, current, high, low) {
+    if (data.length < 2) return "数据不足，无法绘制走势图。";
+    const startPrice = data[0].price;
+    const change = current - startPrice;
+    const changePercent = change / startPrice * 100;
+    const isUp = change >= 0;
+    const color = isUp ? "#d93025" : "#188038";
+    const points = JSON.stringify(data.map((d) => d.price));
+    const times = JSON.stringify(data.map((d) => d.time));
+    const timestamps = JSON.stringify(data.map((d) => d.timestamp));
+    const html = `
+    <html>
+    <head>
+      <style>
+        body { margin: 0; padding: 20px; font-family: 'Segoe UI', Roboto, Helvetica, Arial, sans-serif; background: #f5f7fa; width: 700px; box-sizing: border-box; }
+        .card { background: white; padding: 25px; border-radius: 16px; box-shadow: 0 10px 25px rgba(0,0,0,0.05); }
+        .header { display: flex; justify-content: space-between; align-items: flex-start; margin-bottom: 20px; }
+        .title-group { display: flex; flex-direction: column; }
+        .title { font-size: 28px; font-weight: 800; color: #1a1a1a; letter-spacing: -0.5px; }
+        .sub-info { font-size: 14px; color: #888; margin-top: 5px; font-weight: 500; }
+        .price-group { text-align: right; }
+        .price { font-size: 42px; font-weight: 800; color: ${color}; letter-spacing: -1px; line-height: 1; }
+        .change { font-size: 18px; font-weight: 600; color: ${color}; margin-top: 5px; display: flex; align-items: center; justify-content: flex-end; gap: 5px; }
+        .badge { background: #f0f2f5; padding: 4px 8px; border-radius: 6px; font-size: 12px; color: #555; font-weight: 600; }
+        canvas { width: 100%; height: 350px; }
+      </style>
+    </head>
+    <body>
+      <div class="card">
+        <div class="header">
+          <div class="title-group">
+            <div class="title">${name2}</div>
+            <div class="sub-info">
+              <span class="badge">High: ${high.toFixed(2)}</span>
+              <span class="badge">Low: ${low.toFixed(2)}</span>
+            </div>
+          </div>
+          <div class="price-group">
+            <div class="price">${current.toFixed(2)}</div>
+            <div class="change">
+              <span>${change >= 0 ? "+" : ""}${change.toFixed(2)}</span>
+              <span>(${changePercent.toFixed(2)}%)</span>
+            </div>
+          </div>
+        </div>
+        <canvas id="chart" width="1300" height="700"></canvas>
+      </div>
+      <script>
+        const canvas = document.getElementById('chart');
+        const ctx = canvas.getContext('2d');
+        const prices = ${points};
+        const times = ${times};
+        const timestamps = ${timestamps};
+        const width = canvas.width;
+        const height = canvas.height;
+        const padding = { top: 20, bottom: 40, left: 40, right: 100 };
+        
+        const max = Math.max(...prices);
+        const min = Math.min(...prices);
+        const range = max - min || 1;
+        const yMin = min - range * 0.1;
+        const yMax = max + range * 0.1;
+        const yRange = yMax - yMin;
+
+        const minTime = timestamps[0];
+        const maxTime = timestamps[timestamps.length - 1];
+        const timeRange = maxTime - minTime || 1;
+
+        function getX(t) { return ((t - minTime) / timeRange) * (width - padding.left - padding.right) + padding.left; }
+        function getY(p) { return height - padding.bottom - ((p - yMin) / yRange) * (height - padding.top - padding.bottom); }
+        
+        // 1. Draw Grid
+        ctx.strokeStyle = '#f0f0f0';
+        ctx.lineWidth = 2;
+        ctx.beginPath();
+        const gridSteps = 5;
+        for (let i = 0; i <= gridSteps; i++) {
+            const y = height - padding.bottom - (i / gridSteps) * (height - padding.top - padding.bottom);
+            ctx.moveTo(padding.left, y);
+            ctx.lineTo(width - padding.right, y);
+        }
+        ctx.stroke();
+
+        // 2. Draw Area (Gradient Fill)
+        const gradient = ctx.createLinearGradient(0, 0, 0, height);
+        gradient.addColorStop(0, '${isUp ? "rgba(217, 48, 37, 0.15)" : "rgba(24, 128, 56, 0.15)"}');
+        gradient.addColorStop(1, 'rgba(255, 255, 255, 0)');
+
+        ctx.beginPath();
+        ctx.moveTo(getX(timestamps[0]), height - padding.bottom);
+        // Use Bezier curves for smoothing
+        for (let i = 0; i < prices.length - 1; i++) {
+            const x = getX(timestamps[i]);
+            const y = getY(prices[i]);
+            const nextX = getX(timestamps[i + 1]);
+            const nextY = getY(prices[i + 1]);
+            const cpX = (x + nextX) / 2;
+            if (i === 0) ctx.moveTo(x, y);
+            ctx.quadraticCurveTo(x, y, cpX, (y + nextY) / 2);
+        }
+        // Connect to last point
+        ctx.lineTo(getX(timestamps[prices.length - 1]), getY(prices[prices.length - 1]));
+        
+        // Close path for fill
+        ctx.lineTo(getX(timestamps[prices.length - 1]), height - padding.bottom);
+        ctx.closePath();
+        ctx.fillStyle = gradient;
+        ctx.fill();
+
+        // 3. Draw Line (Smooth)
+        ctx.lineWidth = 4;
+        ctx.lineJoin = 'round';
+        ctx.lineCap = 'round';
+        ctx.strokeStyle = '${color}';
+        ctx.shadowColor = '${isUp ? "rgba(217, 48, 37, 0.3)" : "rgba(24, 128, 56, 0.3)"}';
+        ctx.shadowBlur = 10;
+        
+        ctx.beginPath();
+        for (let i = 0; i < prices.length - 1; i++) {
+            const x = getX(timestamps[i]);
+            const y = getY(prices[i]);
+            const nextX = getX(timestamps[i + 1]);
+            const nextY = getY(prices[i + 1]);
+            const cpX = (x + nextX) / 2;
+            if (i === 0) ctx.moveTo(x, y);
+            // Use quadratic curve for simple smoothing between points
+            // Actually, to pass through points, we need a different approach or just straight lines for accuracy.
+            // But for "beautify", slight smoothing is okay. 
+            // A simple smoothing is to use midpoints as control points.
+            // Let's stick to straight lines for accuracy but add shadow/glow.
+            // Or use a simple spline.
+            // Let's revert to straight lines for financial accuracy but keep the glow.
+            ctx.lineTo(nextX, nextY);
+        }
+        ctx.stroke();
+        ctx.shadowBlur = 0;
+
+        // 4. Draw Last Point Marker
+        const lastX = getX(timestamps[prices.length - 1]);
+        const lastY = getY(prices[prices.length - 1]);
+        
+        ctx.beginPath();
+        ctx.arc(lastX, lastY, 6, 0, Math.PI * 2);
+        ctx.fillStyle = 'white';
+        ctx.fill();
+        
+        ctx.beginPath();
+        ctx.arc(lastX, lastY, 4, 0, Math.PI * 2);
+        ctx.fillStyle = '${color}';
+        ctx.fill();
+
+        // 5. Draw Dashed Line to Y-Axis
+        ctx.beginPath();
+        ctx.setLineDash([4, 4]);
+        ctx.strokeStyle = '#ccc';
+        ctx.lineWidth = 1;
+        ctx.moveTo(padding.left, lastY);
+        ctx.lineTo(width - padding.right, lastY);
+        ctx.stroke();
+        ctx.setLineDash([]);
+
+        // 6. Draw Axis Labels
+        ctx.fillStyle = '#999';
+        ctx.font = '600 20px "Segoe UI", sans-serif';
+        ctx.textAlign = 'left';
+        ctx.textBaseline = 'middle';
+
+        for (let i = 0; i <= gridSteps; i++) {
+            const val = yMin + (i / gridSteps) * yRange;
+            const y = height - padding.bottom - (i / gridSteps) * (height - padding.top - padding.bottom);
+            ctx.fillText(val.toFixed(2), width - padding.right + 10, y);
+        }
+        
+        ctx.fillStyle = '${color}';
+        ctx.font = 'bold 20px "Segoe UI", sans-serif';
+        ctx.fillText(prices[prices.length-1].toFixed(2), width - padding.right + 10, lastY);
+
+        ctx.textAlign = 'center';
+        ctx.fillStyle = '#999';
+        ctx.font = '500 18px "Segoe UI", sans-serif';
+        
+        const timeStep = Math.ceil(times.length / 5);
+        for (let i = 0; i < times.length; i += timeStep) {
+           if (i === 0) ctx.textAlign = 'left';
+           else if (i >= times.length - 1) ctx.textAlign = 'right';
+           else ctx.textAlign = 'center';
+           
+           ctx.fillText(times[i], getX(timestamps[i]), height - 10);
+        }
+        if ((times.length - 1) % timeStep !== 0) {
+             ctx.textAlign = 'right';
+             ctx.fillText(times[times.length-1], getX(timestamps[times.length-1]), height - 10);
+        }
+
+      </script>
+    </body>
+    </html>
+    `;
+    const page = await ctx2.puppeteer.page();
+    await page.setContent(html);
+    const element = await page.$(".card");
+    const imgBuf = await element?.screenshot({ encoding: "binary" });
+    await page.close();
+    return import_koishi.h.image(imgBuf, "image/png");
+  }
+  __name(renderStockImage, "renderStockImage");
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  inject,
+  name
+});

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "koishi-plugin-monetary-bourse",
+  "version": "1.0.0-alpha.1",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "koishi": {
+    "description": {
+      "en": "`Provide exchange functionality for monetary money`",
+      "zh": "为monetary货币提供交易所功能"
+    },
+    "service": {
+      "required": [
+        "database",
+        "monetary"
+      ]
+    },
+    "preview:": true
+  },
+  "license": "MIT",
+  "keywords": [
+    "chatbot",
+    "koishi",
+    "plugin",
+    "交易所",
+    "stock",
+    "股票",
+    "金融",
+    "monetary",
+    "货币",
+    "炒股",
+    "投资",
+    "理财",
+    "经济",
+    "economy"
+  ],
+  "author": {
+    "name": "BYWled",
+    "email": "bywled@qq.com",
+    "url": "https://github.com/BYWled"
+  },
+  "homepage": "https://github.com/BYWled/koishi-plugin-monetary-bourse",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BYWled/koishi-plugin-monetary-bourse"
+  },
+  "peerDependencies": {
+    "koishi": "^4.17.0",
+    "koishi-plugin-monetary": "*",
+    "koishi-plugin-puppeteer": "*"
+  },
+  "dependencies": {
+    "koishi": "^4.18.0",
+    "koishi-plugin-monetary": "^0.1.0"
+  }
+}

package/readme.md

@@ -0,0 +1,7 @@
+# koishi-plugin-monetary-bourse
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-monetary-bourse?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-monetary-bourse)
+
+Provide exchange functionality for monetary
+
+为monetary货币提供交易所功能