koishi-plugin-prism 0.1.6 → 0.1.10

package/README.md

@@ -6,12 +6,12 @@
 
 ## 🌟 功能特性
 
-* 🎮 **玩家入场与结算**：通过 `/login` 和 `/logout` 指令开启或结算计费场次，支持 `/入场` 别名。
+* 🎮 **玩家入场与结算**：通过 `/login` 和 `/logout` 指令开启或结算计费场次，支持 `/入场` 别名；命令回复会引用触发消息，结账账单可私聊通知管理员与指定用户。
 * 💳 **账户钱包与资产管理**：支持查询钱包余额（`/wallet`）和持有的道具资产（`/items`）。
-* 🀄 **麻将桌位集成**：包含 `/mahjong <tableId>` 以及便捷的 `/上桌` / `/下桌` 控制。
+* 🀄 **麻将桌位集成**：包含 `/mahjong <tableId>` 以及便捷的 `/上桌` / `/下桌` 控制。`上桌` 仅允许已通过 `login`/`入场` 开启默认入场会话的玩家使用。`list` 会按音乐游戏和麻将桌分组，并对同一玩家的多个计时会话去重；麻将桌显示当前人数和容量。未满桌候座由机器人进程暂存，机器人重启后不会保留。
 * 🔌 **硬件设备状态与电源管理**：可直接在聊天中查看设备状态（`/show`）、远程开启/关闭电源（`/on`、`/off`）、远程投币（`/coin`）和模拟刷卡（`/scan`）。
 * 🎟️ **礼物兑换码**：使用 `/redeem <code>` 兑换系统发放的福利礼包。
-* 🛠️ **管理员高级指令**：允许管理员在聊天中查看玩家（`/admin.players`）、创建新玩家账户（`/admin.create-player`）、充值余额（`/admin.grant-balance`）、手动结账（`/admin.checkout`）以及制作礼包兑换码（`/admin.redeem-code`）。
+* 🛠️ **管理员快捷指令**：允许管理员为指定平台用户增加或扣除余额，并覆盖结账金额后立即结账。
 
 ## ⚙️ 配置说明
 
@@ -29,8 +29,12 @@
 | `defaultScanProvider` | `string` | `"aime"` | 默认模拟刷卡时的读卡器协议提供商（如 `"aime"`）。 |
 | `currencyName` | `string` | `"金币"` | 账户货币在显示时的自定义单位名称。 |
 | `resolveDisplayName` | `function` | - | 可选。自定义用于获取群内昵称作为玩家注册名的异步逻辑。 |
-| `enableStaffCommands` | `boolean` | `false` | 是否开启管理员/店员的高级控制指令。 |
-| `staffUserIds` | `string[]` | `[]` | 允许执行管理员指令的平台用户 ID（如 QQ 号）白名单。 |
+| `enableStaffCommands` | `boolean` | `false` | 是否开启管理员快捷指令。 |
+| `staffUserIds` | `string[]` | `[]` | 允许执行管理员快捷指令的平台用户 ID（如 QQ 号）白名单。空列表不授予目标用户操作权限。 |
+| `staffSessionToken` | `string` | - | 管理员写操作所需的 Staff 管理 Token。 |
+| `logoutNotifyUserIds` | `string[]` | `[]` | 结账成功后额外私聊完整账单的平台用户 ID。通知收件人为该列表与 `staffUserIds` 的去重并集。 |
+
+管理员快捷指令必须同时配置 `enableStaffCommands: true`、`staffUserIds` 和 `staffSessionToken`。目标用户参数使用 Koishi 的 `user` 选择器；只有白名单内的管理员可以操作其他用户。
 
 ## 📝 机器人指令列表
 
@@ -38,10 +42,12 @@
 * `register` - 绑定或注册当前平台账号到 PRiSM 账户。
 * `login` / `入场` - 开启当前玩家的计费场次。
 * `logout` - 结算当前玩家的计费场次。
+玩家在未产生任何费用时退场，机器人会简洁显示“本次未产生费用”和当前余额；存在收费或优惠明细时仍显示完整结算账单。
+结账成功后，机器人会向 `staffUserIds` 与 `logoutNotifyUserIds` 中的用户私聊同一份账单，账单会明确显示结账玩家身份。
 * `billing` - 预览当前玩家本场计费的消费费用。
 * `wallet` - 查看当前玩家的钱包余额。
 * `items` - 查看当前玩家持有的道具或资产。
-* `list` - 查看当前在线/在店游玩玩家的列表。
+* `list` - 查看当前在线/在店游玩玩家的列表，按音乐游戏和麻将桌分组并对同一玩家的多个计时会话去重；麻将桌显示当前人数和容量。未满桌候座由机器人进程暂存，机器人重启后不会保留。
 * `show [deviceId]` - 查看设备电源与连接状态。
 * `history` - 查看自己的历史游玩记录。
 * `lock` - 发送开门指令。
@@ -50,15 +56,14 @@
 * `coin <deviceId> [count]` - 请求向指定设备投币指定枚数。
 * `scan <deviceId> <subject>` - 请求向设备发送模拟刷卡。
 * `redeem <code>` - 兑换礼物码。
-* `mahjong <tableId>` / `上桌 <tableId>` - 加入指定麻将桌。
+* `mahjong <tableId>` / `上桌 <tableId>` - 加入指定麻将桌；仅允许已通过 `login`/`入场` 开启默认入场会话的玩家使用。
 * `下桌 <tableId>` - 离开指定麻将桌。
 
-### 管理员指令 (需在白名单内并开启)
-* `admin.players` - 列出系统内注册的所有玩家。
-* `admin.create-player <displayName>` - 创建一个新的 PRiSM 玩家。
-* `admin.grant-balance <playerId> <amount>` - 为指定玩家发放充值余额。
-* `admin.redeem-code <code> <presentId>` - 快速创建单次使用的兑换码。
-* `admin.checkout <playerId>` - 代替并强制为指定玩家结账。
+### 管理员快捷指令
+启用 `enableStaffCommands`、配置 `staffUserIds` 白名单与 `staffSessionToken` 后可使用：
+* `add <target:user> <amount:number>` - 为目标用户增加余额。
+* `del <target:user> <amount:number>` - 从目标用户扣除余额。
+* `overwrite <target:user> <amount:number> [reason:text]` - 覆盖目标用户本次结账金额，并立即执行结账；未填写原因时使用默认管理员调价原因。
 
 ## 🛠️ 本地开发与构建
 

package/lib/index.d.ts

@@ -24,6 +24,7 @@ export type PrismKoishiPluginConfig = {
     currencyName: string;
     enableStaffCommands?: boolean;
     staffUserIds?: string[];
+    logoutNotifyUserIds?: string[];
     mahjongTables?: string;
     mahjongTableSize?: number;
     mahjongLabelPrefix?: string;
@@ -56,6 +57,7 @@ export type KoishiLikeContext = {
 export type KoishiActionContext = {
     session: {
         userId: string;
+        messageId?: string;
         senderId?: string;
         senderName?: string;
         username?: string;
@@ -63,6 +65,7 @@ export type KoishiActionContext = {
             getUser?(id: string): Promise<{
                 name?: string;
             }>;
+            broadcast?(userIds: string[], content: string): Promise<void>;
         };
     };
 };

package/lib/index.js

@@ -20,6 +20,7 @@ exports.Config = koishi_1.Schema.object({
     loginSessionLabel: koishi_1.Schema.string().default("音游区间").description("默认入场场次标签 (防重复入场)"),
     enableStaffCommands: koishi_1.Schema.boolean().default(false).description("是否启用管理员指令"),
     staffUserIds: koishi_1.Schema.array(koishi_1.Schema.string()).default([]).description("允许执行管理员指令的平台用户ID列表"),
+    logoutNotifyUserIds: koishi_1.Schema.array(koishi_1.Schema.string()).default([]).description("结账账单私聊通知的平台用户ID列表"),
     powerOffInterval: koishi_1.Schema.number().default(0).description("无人自动关机等待秒数 (0为禁用)"),
     mahjongTables: koishi_1.Schema.string().description("麻将桌配置"),
     mahjongTableSize: koishi_1.Schema.number().default(4).description("麻将桌人数限制"),
@@ -52,47 +53,41 @@ const USAGE = {
     prism_redeem: "/prism redeem <兑换码>",
     list: "/list",
     show: "/show [设备ID]",
-    staff_create_player: "/prism.admin.create-player <玩家昵称>",
-    staff_grant_balance: "/prism.admin.grant-balance <玩家ID> <金额>",
-    staff_redeem_code: "/prism.admin.redeem-code <兑换码> <礼物ID>",
-    staff_checkout: "/prism.admin.checkout <玩家ID>",
 };
 function applyPrismKoishiPlugin(ctx, config) {
     const service = new PrismKoishiService(ctx, config);
     const wrap = (handler) => async (context, ...args) => {
         try {
-            return await handler(context, ...args);
+            const message = await handler(context, ...args);
+            return context.session?.messageId ? `${(0, koishi_1.h)("quote", { id: context.session.messageId })}${message}` : message;
         }
         catch (error) {
-            return service.handleCommandError(error);
+            const message = service.handleCommandError(error);
+            return context.session?.messageId ? `${(0, koishi_1.h)("quote", { id: context.session.messageId })}${message}` : message;
         }
     };
     ctx.command("register", "绑定或注册当前平台用户到 PRiSM").action(wrap(async (context) => service.register(await service.sender(context))));
-    ctx.command("login", "开启当前玩家的计费场次").action(wrap(async (context) => service.login(await service.sender(context))));
-    ctx.command("入场", "入场 (alias of login)").action(wrap(async (context) => service.login(await service.sender(context))));
+    ctx.command("login [target:user]", "开启玩家计费场次").action(wrap(async (context, target) => service.loginForTarget(await service.sender(context), target)));
+    ctx.command("入场 [target:user]", "入场").action(wrap(async (context, target) => service.loginForTarget(await service.sender(context), target)));
     ctx.command("mahjong <tableId>", "加入指定麻将桌").action(wrap(async (context, tableId) => service.mahjongJoin(await service.sender(context), tableId)));
     ctx.command("上桌 <tableId>", "加入指定麻将桌").action(wrap(async (context, tableId) => service.mahjongJoin(await service.sender(context), tableId)));
     ctx.command("下桌 <tableId>", "离开指定麻将桌").action(wrap(async (context, tableId) => service.mahjongLeave(await service.sender(context), tableId)));
-    ctx.command("logout", "结算当前玩家的计费场次").action(wrap(async (context) => service.logout(await service.sender(context))));
-    ctx.command("billing", "预览当前玩家的结账费用").action(wrap(async (context) => service.billing(await service.sender(context))));
-    ctx.command("wallet", "查看当前玩家钱包余额").action(wrap(async (context) => service.wallet(await service.sender(context))));
-    ctx.command("items", "查看当前玩家持有资产").action(wrap(async (context) => service.items(await service.sender(context))));
+    ctx.command("logout [target:user]", "结算玩家计费场次").action(wrap(async (context, target) => service.withTarget(await service.sender(context), target, (sender) => service.logout(sender, context.session?.bot))));
+    ctx.command("billing [target:user]", "预览玩家结账费用").action(wrap(async (context, target) => service.withTarget(await service.sender(context), target, (sender) => service.billing(sender))));
+    ctx.command("wallet [target:user]", "查看玩家钱包").action(wrap(async (context, target) => service.withTarget(await service.sender(context), target, (sender) => service.wallet(sender))));
+    ctx.command("items [target:user]", "查看玩家资产").action(wrap(async (context, target) => service.withTarget(await service.sender(context), target, (sender) => service.items(sender))));
     ctx.command("list", "查看当前在线玩家列表").action(wrap(async (context) => service.listActiveSessions(await service.sender(context))));
     ctx.command("show [deviceId]", "查看设备电源状态").action(wrap(async (context, deviceId) => service.listDeviceStates(deviceId)));
-    ctx.command("history", "查看当前玩家历史场次").action(wrap(async (context) => service.history(await service.sender(context))));
+    ctx.command("history [target:user]", "查看玩家历史").action(wrap(async (context, target) => service.withTarget(await service.sender(context), target, (sender) => service.history(sender))));
     ctx.command("lock", "向默认门锁设备发送开门指令").action(wrap(async (context) => service.lock(await service.sender(context))));
     ctx.command("on <deviceId>", "请求启动指定设备电源").action(wrap(async (context, deviceId) => service.powerOn(await service.sender(context), deviceId)));
     ctx.command("off <deviceId>", "请求关闭指定设备电源").action(wrap(async (context, deviceId) => service.powerOff(await service.sender(context), deviceId)));
     ctx.command("coin <deviceId> [count]", "请求向指定设备投币").action(wrap(async (context, deviceId, count) => service.coin(await service.sender(context), deviceId, count)));
     ctx.command("scan <deviceId> <subject>", "请求指定设备模拟刷卡").action(wrap(async (context, deviceId, subject) => service.scan(await service.sender(context), deviceId, subject)));
     ctx.command("redeem <code>", "兑换 PRiSM 礼物码").action(wrap(async (context, code) => service.redeem(await service.sender(context), code)));
-    if (config.enableStaffCommands) {
-        ctx.command("admin.players", "列出 PRiSM 玩家").action(wrap(async (context) => service.staffPlayers(await service.sender(context))));
-        ctx.command("admin.create-player <displayName>", "创建 PRiSM 玩家").action(wrap(async (context, displayName) => service.staffCreatePlayer(await service.sender(context), displayName)));
-        ctx.command("admin.grant-balance <playerId> <amount>", "给指定玩家发放充值余额").action(wrap(async (context, playerId, amount) => service.staffGrantBalance(await service.sender(context), playerId, amount)));
-        ctx.command("admin.redeem-code <code> <presentId>", "创建单次使用兑换码").action(wrap(async (context, code, presentId) => service.staffRedeemCode(await service.sender(context), code, presentId)));
-        ctx.command("admin.checkout <playerId>", "替指定玩家结账").action(wrap(async (context, playerId) => service.staffCheckout(await service.sender(context), playerId)));
-    }
+    ctx.command("add <target:user> <amount:number>", "增加玩家余额").action(wrap(async (context, target, amount) => service.adjustTargetBalance(await service.sender(context), target, amount, 1)));
+    ctx.command("del <target:user> <amount:number>", "扣除玩家余额").action(wrap(async (context, target, amount) => service.adjustTargetBalance(await service.sender(context), target, amount, -1)));
+    ctx.command("overwrite <target:user> <amount:number> [reason:text]", "覆盖结账金额并立即结账").action(wrap(async (context, target, amount, reason) => service.overwriteTargetCheckout(await service.sender(context), target, amount, reason)));
     const intervalMs = (config.powerOffInterval ?? 0) * 1000;
     if (intervalMs > 0 && typeof ctx.setInterval === "function") {
         ctx.setInterval(() => {
@@ -278,35 +273,18 @@ class PrismApiClient {
             token: this.config.integrationToken,
         });
     }
-    // Staff commands
-    async listStaffPlayers() {
-        return this.request("GET", "/rpc/staff/players", {
-            token: this.requireStaffSessionToken(),
-        });
-    }
-    async createStaffPlayer(displayName) {
-        return this.request("POST", "/rpc/staff/players", {
-            token: this.requireStaffSessionToken(),
-            body: { displayName },
-        });
-    }
-    async grantStaffAssets(playerId, assets) {
-        return this.request("POST", "/rpc/staff/players/:playerId/adjustments/assets", {
+    async adjustStaffAssets(playerId, adjustments) {
+        return this.request("POST", "/rpc/staff/players/:playerId/assets/adjustments", {
             token: this.requireStaffSessionToken(),
             params: { playerId },
-            body: { assets },
+            body: { adjustments },
         });
     }
-    async createStaffRedeemCode(input) {
-        return this.request("POST", "/rpc/staff/redeem-codes", {
-            token: this.requireStaffSessionToken(),
-            body: input,
-        });
-    }
-    async staffCheckout(playerId) {
-        return this.request("POST", "/rpc/staff/players/:playerId/settlements/checkout", {
+    async checkoutWithOverride(playerId, total, reason) {
+        return this.request("POST", "/rpc/staff/players/:playerId/checkout/override", {
             token: this.requireStaffSessionToken(),
             params: { playerId },
+            body: { total, reason },
         });
     }
 }
@@ -374,10 +352,55 @@ class PrismKoishiService {
         await this.client.resolveOrRegisterIdentity(this.identity(sender));
         return "注册成功";
     }
+    async loginForTarget(actor, targetSubject) {
+        return this.withTarget(actor, targetSubject, async (sender, isTargeted) => {
+            await this.client.startSessionByIdentity(this.identity(sender), this.loginSessionBody());
+            return isTargeted ? `✅ 已为用户 ${sender.id} 入场成功` : "✅ 入场成功";
+        });
+    }
     async login(sender) {
         await this.client.startSessionByIdentity(this.identity(sender), this.loginSessionBody());
         return "✅ 入场成功";
     }
+    async withTarget(actor, targetSubject, action) {
+        const target = this.targetSender(actor, targetSubject);
+        if (typeof target === "string")
+            return target;
+        return action(target, target !== actor);
+    }
+    async adjustTargetBalance(actor, targetSubject, rawAmount, direction) {
+        return this.withTarget(actor, targetSubject, async (sender) => {
+            const amount = Number(rawAmount);
+            if (!Number.isFinite(amount) || amount <= 0)
+                return "金额必须大于 0";
+            const player = await this.resolvePlayer(sender);
+            const playerId = String(player.id ?? "");
+            if (!playerId)
+                return "找不到玩家";
+            const isAddition = direction === 1;
+            await this.client.adjustStaffAssets(playerId, [{
+                    assetType: "currency",
+                    assetCode: "paid",
+                    quantityDelta: amount * direction,
+                    reason: isAddition ? "Koishi 管理员增加余额" : "Koishi 管理员扣除余额",
+                }]);
+            return `✅ 已为用户 ${sender.id}${isAddition ? "增加" : "扣除"} ${formatNumber(amount)} ${this.config.currencyName}`;
+        });
+    }
+    async overwriteTargetCheckout(actor, targetSubject, rawAmount, rawReason) {
+        return this.withTarget(actor, targetSubject, async (sender) => {
+            const total = Number(rawAmount);
+            if (!Number.isFinite(total) || total < 0)
+                return "金额必须为非负数";
+            const player = await this.resolvePlayer(sender);
+            const playerId = String(player.id ?? "");
+            if (!playerId)
+                return "找不到玩家";
+            const reason = cleanText(rawReason) || "Koishi 管理员手动调价";
+            await this.client.checkoutWithOverride(playerId, total, reason);
+            return `✅ 已为用户 ${sender.id} 覆盖结账为 ${formatNumber(total)} ${this.config.currencyName}`;
+        });
+    }
     async mahjongJoin(sender, rawTableId) {
         const tableId = cleanText(rawTableId);
         if (!tableId)
@@ -389,6 +412,11 @@ class PrismKoishiService {
         const tableSubject = tableConfig.displayName || `${tableKey} 桌`;
         const player = await this.resolvePlayer(sender);
         const playerId = String(player.id ?? "");
+        const activeResult = (await this.client.listActiveSessions());
+        const activeSessions = (activeResult.sessions ?? []);
+        if (!this.hasEntrySession(playerId, activeSessions)) {
+            return "请先入场后再上桌。";
+        }
         const existing = this.mahjongTableForPlayer(playerId);
         if (existing)
             return `你已经在 ${existing} 桌了。`;
@@ -450,7 +478,7 @@ class PrismKoishiService {
         const result = (await this.client.previewCheckoutByIdentity(this.identity(sender)));
         return this.formatCheckoutPreview(result, sender);
     }
-    async logout(sender) {
+    async logout(sender, bot) {
         const result = (await this.client.confirmCheckoutByIdentity(this.identity(sender)));
         const settlement = result?.playerSettlement ?? result?.settlement ?? {};
         const records = result?.settlements ?? [];
@@ -479,7 +507,12 @@ class PrismKoishiService {
             adjustments: result?.adjustments ?? [],
             assetHoldings: result?.assetHoldings ?? [],
         };
-        return this.formatCheckoutPreview(synthetic, sender, "✅ 退场成功 · 结算账单");
+        const receipt = await this.formatCheckoutPreview(synthetic, sender, "✅ 退场成功 · 结算账单");
+        const recipients = [...new Set([...(this.config.staffUserIds ?? []), ...(this.config.logoutNotifyUserIds ?? [])])];
+        if (recipients.length > 0 && bot?.broadcast) {
+            await bot.broadcast(recipients, receipt);
+        }
+        return receipt;
     }
     async wallet(sender) {
         const result = (await this.client.getWalletByIdentity(this.identity(sender)));
@@ -552,28 +585,14 @@ class PrismKoishiService {
     async listActiveSessions(sender) {
         const result = (await this.client.listActiveSessions());
         const sessions = (result?.sessions ?? []);
-        if (sessions.length === 0)
-            return "🫥 窝里目前没有玩家呢";
-        const lines = [`👥 窝里目前共有 ${sessions.length} 人`];
-        for (const session of sessions) {
-            const identitySubject = findSubjectForSession(session, this.config.provider);
-            let display;
-            if (identitySubject) {
-                const platformName = await this.resolvePlatformName(identitySubject);
-                if (platformName) {
-                    display = `${platformName} ( ${identitySubject} )`;
-                }
-                else {
-                    display = `${session.playerDisplayName || identitySubject} ( ${identitySubject} )`;
-                }
-            }
-            else {
-                display = session.playerDisplayName || session.playerId || "未知玩家";
-            }
-            const timeStr = formatDateTime(session.startedAt);
-            lines.push(`玩家: ${display}\n入场时间: ${timeStr}`);
-        }
-        return lines.join("\n\n");
+        const tableByLabel = new Map(uniqueMahjongConfigs(this.mahjongTableConfigs()).map((table) => [
+            mahjongSessionLabel(table, this.config.mahjongLabelPrefix ?? "麻将桌"),
+            table,
+        ]));
+        const players = groupSessionsByPlayer(sessions);
+        const groups = await this.buildPlayerGroups(players, tableByLabel);
+        this.mergeWaitingSeats(groups);
+        return formatPlayerGroups(groups, this.config.mahjongTableSize ?? 4, this.config.mahjongLabelPrefix ?? "麻将桌");
     }
     async listDeviceStates(rawAlias) {
         const alias = cleanText(rawAlias);
@@ -592,87 +611,6 @@ class PrismKoishiService {
             .map((d) => `${d.label || d.deviceId}: ${d.state?.state ?? "unknown"}`)
             .join("\n");
     }
-    async staffPlayers(sender) {
-        const denied = this.staffDenied(sender);
-        if (denied)
-            return denied;
-        const result = (await this.client.listStaffPlayers());
-        const players = (result?.players ?? []);
-        if (players.length === 0)
-            return "🫥 窝里目前没有玩家呢";
-        return [
-            `👥 窝里目前共有 ${players.length} 人`,
-            "",
-            ...players.map((p) => {
-                const lines = [`玩家: ${p?.displayName ?? p?.id ?? ""} (${p?.id ?? ""})`];
-                if (p?.status)
-                    lines.push(`状态: ${p.status}`);
-                if (p?.walletTotal != null)
-                    lines.push(`余额: ${p.walletTotal} ${this.config.currencyName}`);
-                return lines.join("\n");
-            }),
-        ].join("\n");
-    }
-    async staffCreatePlayer(sender, rawDisplayName) {
-        const displayName = cleanText(rawDisplayName);
-        if (!displayName)
-            return commandUsage("staff_create_player");
-        const denied = this.staffDenied(sender);
-        if (denied)
-            return denied;
-        const result = (await this.client.createStaffPlayer?.(displayName));
-        const player = result?.player ?? {};
-        return `创建成功\n玩家: ${player?.displayName ?? displayName}\nID: ${player?.id ?? ""}`;
-    }
-    async staffGrantBalance(sender, rawPlayerId, rawAmount) {
-        const playerId = cleanText(rawPlayerId);
-        const amount = cleanText(rawAmount);
-        if (!playerId || !amount)
-            return commandUsage("staff_grant_balance");
-        const denied = this.staffDenied(sender);
-        if (denied)
-            return denied;
-        await this.client.grantStaffAssets?.(playerId, [
-            {
-                assetType: "currency",
-                assetCode: "paid",
-                amount: Number(amount),
-                mergeStrategy: "stack",
-                activeAt: null,
-                expiresAt: null,
-            },
-        ]);
-        return `✅ 已为玩家 ${playerId} 发放 ${amount} ${this.config.currencyName}`;
-    }
-    async staffRedeemCode(sender, rawCode, rawPresentId) {
-        const code = cleanText(rawCode);
-        const presentId = cleanText(rawPresentId);
-        if (!code || !presentId)
-            return commandUsage("staff_redeem_code");
-        const denied = this.staffDenied(sender);
-        if (denied)
-            return denied;
-        const result = (await this.client.createStaffRedeemCode?.({
-            code,
-            presentId,
-            activeAt: null,
-            expiresAt: null,
-            maxUseCount: 1,
-        }));
-        const redeemCode = result?.redeemCode?.code ?? code;
-        return `成功生成 1 个兑换码:\n${redeemCode}`;
-    }
-    async staffCheckout(sender, rawPlayerId) {
-        const playerId = cleanText(rawPlayerId);
-        if (!playerId)
-            return commandUsage("staff_checkout");
-        const denied = this.staffDenied(sender);
-        if (denied)
-            return denied;
-        const result = (await this.client.staffCheckout?.(playerId));
-        const settlement = result?.settlement ?? {};
-        return `\n✅ 已为用户 ${playerId} 退场\n消费: ${formatNumber(settlement?.total ?? 0)} ${this.config.currencyName}`;
-    }
     async autoPowerOffLoop() {
         const interval = this.config.powerOffInterval ?? 0;
         if (interval <= 0)
@@ -712,6 +650,64 @@ class PrismKoishiService {
             return null;
         }
     }
+    async displayNameForPlayer(player) {
+        let identitySubject;
+        for (const session of player.sessions) {
+            const subject = findSubjectForSession(session, this.config.provider);
+            if (!subject)
+                continue;
+            identitySubject ??= subject;
+            const platformName = await this.resolvePlatformName(subject);
+            if (platformName)
+                return platformName;
+        }
+        return player.sessions.find((session) => session.playerDisplayName)?.playerDisplayName
+            || identitySubject
+            || player.displayName
+            || player.playerId
+            || "未知玩家";
+    }
+    async buildPlayerGroups(players, tableByLabel) {
+        const groups = {
+            music: [],
+            mahjong: uniqueMahjongConfigs(this.mahjongTableConfigs()).map((table) => ({ table, players: [] })),
+        };
+        const groupForTable = new Map(groups.mahjong.map((group) => [group.table.tableId, group]));
+        for (const player of players.values()) {
+            player.displayName = await this.displayNameForPlayer(player);
+            const table = player.sessions
+                .map((session) => tableByLabel.get(session.label ?? ""))
+                .find((value) => Boolean(value));
+            if (table) {
+                groupForTable.get(table.tableId)?.players.push(player);
+            }
+            else {
+                groups.music.push(player);
+            }
+        }
+        return groups;
+    }
+    mergeWaitingSeats(groups) {
+        for (const [tableId, state] of this.mahjongTables) {
+            const group = groups.mahjong.find((candidate) => candidate.table.tableId === tableId);
+            if (!group)
+                continue;
+            for (const seat of state.waiting) {
+                if (group.players.some((player) => player.playerId === seat.playerId))
+                    continue;
+                const existing = [groups.music, ...groups.mahjong.map((candidate) => candidate.players)]
+                    .flat()
+                    .find((player) => player.playerId === seat.playerId);
+                groups.music = groups.music.filter((player) => player.playerId !== seat.playerId);
+                for (const candidate of groups.mahjong) {
+                    if (candidate !== group) {
+                        candidate.players = candidate.players.filter((player) => player.playerId !== seat.playerId);
+                    }
+                }
+                group.players.push(existing ?? { playerId: seat.playerId, sessions: [], displayName: seat.displayName });
+            }
+        }
+    }
     async resolvePlayerDisplay(sender, playerId) {
         if (!sender)
             return playerId || "未知玩家";
@@ -736,6 +732,10 @@ class PrismKoishiService {
     async resolvePlayer(sender) {
         return (await this.client.resolveOrRegisterIdentity(this.identity(sender)));
     }
+    hasEntrySession(playerId, sessions) {
+        const label = this.config.loginSessionLabel?.trim();
+        return sessions.some((session) => session.playerId === playerId && (label ? session.label === label : true));
+    }
     identity(sender) {
         return {
             provider: this.config.provider,
@@ -744,6 +744,15 @@ class PrismKoishiService {
             displayName: sender.name || `${this.config.provider.toUpperCase()} ${sender.id}`,
         };
     }
+    targetSender(actor, targetSubject) {
+        const subject = cleanText(targetSubject);
+        if (!subject)
+            return actor;
+        const denied = this.targetStaffDenied(actor);
+        if (denied)
+            return denied;
+        return { id: subject, name: subject };
+    }
     loginSessionBody() {
         const pricingConfigIds = (this.config.loginPricingConfigIds ?? [])
             .map((id) => id.trim())
@@ -764,6 +773,14 @@ class PrismKoishiService {
             return "权限不足";
         return null;
     }
+    targetStaffDenied(sender) {
+        if (!this.config.enableStaffCommands)
+            return "员工命令未启用";
+        const allowed = this.config.staffUserIds ?? [];
+        if (!allowed.includes(sender.id))
+            return "权限不足";
+        return null;
+    }
     async formatCheckoutPreview(result, sender, title = "【结算账单】") {
         if (result?.billing && result?.session) {
             return formatLegacyBilling(result, this.config.currencyName);
@@ -796,6 +813,24 @@ class PrismKoishiService {
         const lines = [];
         lines.push(title);
         lines.push(await this.resolvePlayerDisplay(sender, playerId));
+        let balance = 0;
+        let hasBalance = false;
+        for (const holding of assetHoldings) {
+            const code = String(holding?.assetCode ?? "").toLowerCase();
+            if (code.includes("paid") || code.includes("free") || code.includes("currency")) {
+                balance += toNumber(holding?.quantity ?? 0);
+                hasBalance = true;
+            }
+        }
+        const hasNonZeroSessionTotal = sessionPreviews.some((session) => toNumber(session?.total ?? 0) !== 0);
+        const hasNonZeroAdjustment = hasAdjustmentEntries(adjustments, sessionPreviews);
+        if (!hasNonZeroSessionTotal && !hasNonZeroAdjustment) {
+            lines.push("");
+            lines.push("本次未产生费用");
+            if (hasBalance)
+                lines.push(`余额：${formatNumber(balance)}${currency}`);
+            return lines.join("\n");
+        }
         const validStarts = sessionPreviews.map((s) => parseDateTime(s?.startedAt)).filter(Boolean);
         const validEnds = sessionPreviews.map((s) => sessionDisplayEnd(s, previewedAt)).filter(Boolean);
         if (validStarts.length > 0) {
@@ -828,20 +863,9 @@ class PrismKoishiService {
                 lines.push(`  └ ${adjLabel}：${formatNumber(amount)}${currency}`);
             }
         }
-        let balance = 0;
-        let hasBalance = false;
-        for (const holding of assetHoldings) {
-            const code = String(holding?.assetCode ?? "").toLowerCase();
-            if (code.includes("paid") || code.includes("free") || code.includes("currency")) {
-                balance += toNumber(holding?.quantity ?? 0);
-                hasBalance = true;
-            }
-        }
         lines.push("");
         lines.push(`计费总价：${formatNumber(subtotal)}${currency}`);
-        const hasDiscount = adjustments.some((adj) => toNumber(firstDefined(adj ?? {}, "amount", "saved", 0)) !== 0)
-            || sessionPreviews.some((sp) => (sp?.adjustments ?? []).some((adj) => toNumber(firstDefined(adj ?? {}, "amount", "saved", 0)) !== 0));
-        if (hasDiscount)
+        if (hasNonZeroAdjustment)
             lines.push(`优惠后价格：${formatNumber(total)}${currency}`);
         if (hasBalance)
             lines.push(`扣款后余额：${formatNumber(balance)}${currency}`);
@@ -924,6 +948,45 @@ function parseMahjongTables(value, labelPrefix) {
     }
     return tables;
 }
+function uniqueMahjongConfigs(tables) {
+    return [...new Map([...tables.values()].map((table) => [table.tableId, table])).values()];
+}
+function mahjongSessionLabel(table, labelPrefix) {
+    return table.displayName || `${labelPrefix} ${table.tableId}`;
+}
+function groupSessionsByPlayer(sessions) {
+    const players = new Map();
+    for (const session of sessions) {
+        const playerId = session.playerId || findSubjectForSession(session, "") || "";
+        if (!playerId)
+            continue;
+        const player = players.get(playerId) ?? { playerId, sessions: [] };
+        player.sessions.push(session);
+        players.set(playerId, player);
+    }
+    return players;
+}
+function formatPlayerGroups(groups, tableSize, mahjongLabelPrefix) {
+    const populatedMahjongGroups = groups.mahjong.filter((group) => group.players.length > 0);
+    const total = groups.music.length + populatedMahjongGroups.reduce((sum, group) => sum + group.players.length, 0);
+    if (total === 0)
+        return "🫥 窝里目前没有玩家呢";
+    const lines = [`[总计 ${total} 人]`];
+    if (groups.music.length > 0) {
+        lines.push(`🎵 音乐游戏 ( ${groups.music.length}人 )：\n${formatPlayerNames(groups.music)}`);
+    }
+    for (const group of populatedMahjongGroups) {
+        lines.push(`${formatMahjongTableLabel(group.table, mahjongLabelPrefix)} ( ${group.players.length}/${tableSize} )：\n${formatPlayerNames(group.players)}`);
+    }
+    return lines.join("\n");
+}
+function formatMahjongTableLabel(table, labelPrefix) {
+    const label = mahjongSessionLabel(table, labelPrefix);
+    return table.displayName ? label : `🀄️ ${label}`;
+}
+function formatPlayerNames(players) {
+    return players.map((player) => `- ${player.displayName || player.playerId || "未知玩家"}`).join(", ");
+}
 function splitOnce(text, sep) {
     const idx = text.indexOf(sep);
     if (idx === -1)
@@ -967,6 +1030,9 @@ function toNumber(value) {
         return asFloat;
     return 0;
 }
+function hasAdjustmentEntries(adjustments, sessionPreviews) {
+    return adjustments.some((adjustment) => toNumber(firstDefined(adjustment ?? {}, "amount", "saved", 0)) !== 0) || sessionPreviews.some((session) => (session?.adjustments ?? []).some((adjustment) => toNumber(firstDefined(adjustment ?? {}, "amount", "saved", 0)) !== 0));
+}
 function formatNumber(value) {
     if (typeof value === "boolean")
         return value ? "1" : "0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koishi-plugin-prism",
-  "version": "0.1.6",
+  "version": "0.1.10",
   "description": "PRiSM Next 计费与设备管理系统的 Koishi 机器人集成插件",
   "main": "./lib/index.js",
   "exports": {
@@ -48,4 +48,4 @@
     "test": "bun test test",
     "typecheck": "tsc -p tsconfig.json"
   }
-}
+}