@openora/core 0.4.1-canary.60 → 0.4.1-canary.63

package/dist/engagement/chat-commands/service/chat-commands.service.js

@@ -1,61 +1,23 @@
-import { createHash } from 'node:crypto';
-import { and, eq, isNull, sql } from 'drizzle-orm';
-import { makeNotFoundError, makeConflictError, mapConcurrent, moneyToNumber, findOneOrThrow, serializeRow, createDomainError, } from '@openora/core/server';
+import { eq, asc, desc, count } from 'drizzle-orm';
+import { makeNotFoundError, makeConflictError, createDomainError, findOneOrThrow, pageToOffset, } from '@openora/core/server';
 import { chatChannel } from '@openora/core/contracts';
 import { ChatCommandTypeSchema } from '../contract/index.js';
-import { chatCommandConfig, chatGift } from '../schema/index.js';
+import { chatCommandConfig } from '../schema/index.js';
 export const CommandDisabledError = makeNotFoundError('ChatCommand');
-export const NoOnlineUsersError = makeConflictError('NoOnlineUsers', 'No other users are online in this room');
+export const ChatPlayerNotFoundError = makeNotFoundError('ChatPlayer');
 export const InsufficientBalanceError = makeConflictError('InsufficientBalance', 'Not enough balance');
 export const ExceedsLimitError = makeConflictError('ExceedsLimit', 'Amount exceeds the command limit');
 export const BelowMinimumError = makeConflictError('BelowMinimum', 'Amount is below the minimum for this command');
+export const NoOnlineUsersError = makeConflictError('NoOnlineUsers', 'No other users are online in this room');
+export const TooManyRecipientsError = makeConflictError('TooManyRecipients', 'Amount too small: you need at least $1 per recipient');
 export const RainCreditError = makeConflictError('RainCreditError', 'A recipient wallet is unavailable; rain aborted');
-export const ChatPlayerNotFoundError = makeNotFoundError('ChatPlayer');
 export const GiftNotFoundError = makeNotFoundError('ChatGift');
 export const GiftAlreadyClaimedError = makeConflictError('GiftAlreadyClaimed', 'This gift has already been claimed');
 export const GiftSelfClaimError = makeConflictError('GiftSelfClaim', 'You cannot claim your own gift');
-export const DonateSelfError = makeConflictError('DonateSelf', 'You cannot donate to yourself');
-export const SelfModerationActionError = makeConflictError('SelfModerationAction', 'You cannot block or ignore yourself');
-export const TooManyRecipientsError = makeConflictError('TooManyRecipients', 'Amount too small: you need at least $1 per recipient');
+export const GiftCreditError = makeConflictError('GiftCreditError', 'Recipient wallet is unavailable; gift claim aborted');
 export const ChatCommandIdempotencyKeyReuseError = makeConflictError('ChatCommandIdempotencyKeyReuse', 'This idempotency key was already used with different request parameters');
 export const ConcurrentCommandReplayError = makeConflictError('ConcurrentCommandReplay', 'This request is already being processed - please retry');
-export const ChatRoomNotMemberError = createDomainError('ChatRoomNotMemberError', (roomId) => `You are not a member of room: ${roomId}`);
-const COMMAND_IDEMPOTENCY_TTL_MS = 5 * 60 * 1000;
-// The replay guard must match on the COMPLETE request, not just the amount - a reused
-// key with a different room, recipient count, or donate target is a distinct request,
-// not a replay of the original. `idempotencyKey` itself is excluded so the fingerprint
-// is stable for the row it guards.
-export function fingerprintCommand(input) {
-    const canonical = input.type === 'gift'
-        ? { type: input.type, amount: input.amount, roomId: input.roomId }
-        : input.type === 'rain'
-            ? {
-                type: input.type,
-                amount: input.amount,
-                recipientCount: input.recipientCount,
-                roomId: input.roomId,
-            }
-            : {
-                type: input.type,
-                amount: input.amount,
-                targetUsername: input.targetUsername,
-                roomId: input.roomId,
-            };
-    return createHash('sha256').update(JSON.stringify(canonical)).digest('hex');
-}
-function shuffleArray(arr) {
-    const result = [...arr];
-    for (let i = result.length - 1; i > 0; i--) {
-        const j = Math.floor(Math.random() * (i + 1));
-        const a = result.at(i);
-        const b = result.at(j);
-        if (a !== undefined && b !== undefined) {
-            result[i] = b;
-            result[j] = a;
-        }
-    }
-    return result;
-}
+export const ChatRoomNotMemberError = createDomainError('ChatRoomNotMemberError', (roomId) => roomId ? `You are not a member of room: ${roomId}` : 'You are not a member of global chat');
 function toDescriptor(row) {
     return {
         key: ChatCommandTypeSchema.parse(row.key),
@@ -63,34 +25,29 @@ function toDescriptor(row) {
         label: row.label,
         description: row.description ?? null,
         config: row.config ?? null,
+        updatedAt: row.updatedAt.toISOString(),
     };
 }
+const ADMIN_COMMAND_SORT_COLUMNS = {
+    key: chatCommandConfig.key,
+    updatedAt: chatCommandConfig.updatedAt,
+};
 export class ChatCommandsService {
     drizzle;
-    systemWriter;
-    wallet;
     directory;
-    audit;
-    transport;
-    events;
     blockWriter;
-    gameReporting;
-    roomAccess;
-    cache;
-    idempotencyTtlMs;
-    constructor(drizzle, systemWriter, wallet, directory, audit, transport, events, blockWriter, gameReporting, roomAccess, cache, idempotencyTtlMs = COMMAND_IDEMPOTENCY_TTL_MS) {
+    giftCommands;
+    rainCommands;
+    transport;
+    audit;
+    constructor(drizzle, directory, blockWriter, giftCommands, rainCommands, transport, audit) {
         this.drizzle = drizzle;
-        this.systemWriter = systemWriter;
-        this.wallet = wallet;
         this.directory = directory;
-        this.audit = audit;
-        this.transport = transport;
-        this.events = events;
         this.blockWriter = blockWriter;
-        this.gameReporting = gameReporting;
-        this.roomAccess = roomAccess;
-        this.cache = cache;
-        this.idempotencyTtlMs = idempotencyTtlMs;
+        this.giftCommands = giftCommands;
+        this.rainCommands = rainCommands;
+        this.transport = transport;
+        this.audit = audit;
     }
     async listCommands(includeDisabled = false) {
         const rows = await this.drizzle.db
@@ -99,512 +56,19 @@ export class ChatCommandsService {
             .where(includeDisabled ? undefined : eq(chatCommandConfig.enabled, true));
         return rows.map(toDescriptor);
     }
-    async searchMentions(q, limit, viewerId) {
-        const ids = await this.directory.findPlayerIds(q, limit);
-        if (ids.length === 0) {
-            return [];
-        }
-        const excluded = new Set(await this.blockWriter.getExcludedUserIds(viewerId));
-        const filteredIds = ids.filter((id) => !excluded.has(id));
-        if (filteredIds.length === 0) {
-            return [];
-        }
-        const summaries = await this.directory.lookupPlayers(filteredIds);
-        return summaries.map((s) => ({ userId: s.userId, username: s.username }));
-    }
-    async searchPlayers(q, limit, viewerId) {
-        const ids = await this.directory.findPlayerIds(q, limit);
-        if (ids.length === 0) {
-            return [];
-        }
-        const excluded = new Set(await this.blockWriter.getExcludedUserIds(viewerId));
-        const filteredIds = ids.filter((id) => !excluded.has(id));
-        if (filteredIds.length === 0) {
-            return [];
-        }
-        const summaries = await this.directory.lookupPlayers(filteredIds);
-        return summaries.map((s) => ({
-            userId: s.userId,
-            username: s.username,
-            avatarUrl: s.avatarUrl,
-            level: s.level,
-        }));
-    }
-    async getPlayerProfile(userId, viewerId) {
-        const summaries = await this.directory.lookupPlayers([userId]);
-        const summary = summaries.find((s) => s.userId === userId);
-        if (!summary) {
-            throw new ChatPlayerNotFoundError(userId);
-        }
-        const isSelf = userId === viewerId;
-        const stats = isSelf ? await this.gameReporting.getPlayerStats(userId) : null;
-        return {
-            userId: summary.userId,
-            username: summary.username,
-            avatarUrl: summary.avatarUrl,
-            level: summary.level,
-            joinedAt: isSelf ? summary.createdAt.toISOString() : null,
-            totalWagered: stats?.totalWagered ?? null,
-            totalBets: stats?.totalBets ?? null,
-            currency: isSelf ? summary.currency : null,
-        };
-    }
-    async executeCommand(input, actorId) {
-        if (input.roomId) {
-            try {
-                await this.roomAccess.verifyRoomAccess(input.roomId, actorId);
-            }
-            catch (error) {
-                if (error instanceof Error && error.name === 'ChatRoomNotMemberError') {
-                    throw new ChatRoomNotMemberError(input.roomId);
-                }
-                throw error;
-            }
-        }
-        const [row] = await this.drizzle.db
-            .select()
-            .from(chatCommandConfig)
-            .where(eq(chatCommandConfig.key, input.type))
-            .limit(1);
-        if (!row || !row.enabled) {
-            throw new CommandDisabledError(input.type);
-        }
-        if (input.type === 'gift') {
-            return this.handleGift(input, actorId, row.config ?? null);
-        }
-        if (input.type === 'donate') {
-            return this.handleDonate(input, actorId, row.config ?? null);
-        }
-        if (input.type === 'block' || input.type === 'ignore') {
-            return this.handleBlockAction(input, actorId);
-        }
-        if (input.type === 'rain') {
-            return this.handleRain(input, actorId, row.config ?? null);
-        }
-        // exhaustive — TypeScript cannot narrow a union-literal discriminant ('block'|'ignore') away
-        throw new CommandDisabledError(input.type);
-    }
-    async findCommandReplay(commandType, actorId, idempotencyKey, fingerprint) {
-        const record = await this.cache.get(this.idempotencyCacheKey(commandType, actorId, idempotencyKey));
-        if (!record) {
-            return null;
-        }
-        if (record.fingerprint !== fingerprint) {
-            throw new ChatCommandIdempotencyKeyReuseError();
-        }
-        if (!record.result) {
-            throw new ConcurrentCommandReplayError();
-        }
-        return record.result;
-    }
-    idempotencyCacheKey(commandType, actorId, idempotencyKey) {
-        return `chat-command:idempotency:${actorId}:${commandType}:${idempotencyKey}`;
-    }
-    async reserveCommandIdempotency(commandType, actorId, idempotencyKey, fingerprint) {
-        const reserved = await this.cache.setIfAbsent(this.idempotencyCacheKey(commandType, actorId, idempotencyKey), { fingerprint, result: null }, { ttlMs: this.idempotencyTtlMs });
-        if (!reserved) {
-            throw new ConcurrentCommandReplayError();
-        }
-    }
-    async completeCommandIdempotency(commandType, actorId, idempotencyKey, fingerprint, result) {
-        await this.cache.set(this.idempotencyCacheKey(commandType, actorId, idempotencyKey), { fingerprint, result }, { ttlMs: this.idempotencyTtlMs });
-    }
-    async runWithCommandReservation(commandType, actorId, idempotencyKey, work) {
-        try {
-            return await work();
-        }
-        catch (error) {
-            await this.cache.delete(this.idempotencyCacheKey(commandType, actorId, idempotencyKey));
-            throw error;
-        }
-    }
-    // Exact, case-insensitive username resolution for callers holding a complete, already-known
-    // username (never a partial search term) - `/donate`, `/block`, `/ignore`. Distinct from
-    // findPlayerIds' capped fuzzy substring search, which can silently drop the real match once
-    // more than 20 unrelated accounts substring-collide with a short/common username.
-    async resolveExactPlayer(username) {
-        const summary = await this.directory.getPlayerByUsername(username);
-        if (!summary) {
-            throw new ChatPlayerNotFoundError(username);
-        }
-        return summary;
-    }
-    async handleGift(input, actorId, config) {
-        if (config?.maxAmount !== undefined &&
-            moneyToNumber(input.amount) > moneyToNumber(config.maxAmount)) {
-            throw new ExceedsLimitError();
-        }
-        if (config?.minAmount !== undefined &&
-            moneyToNumber(input.amount) < moneyToNumber(config.minAmount)) {
-            throw new BelowMinimumError();
-        }
-        const fingerprint = fingerprintCommand(input);
-        const replay = await this.findCommandReplay('gift', actorId, input.idempotencyKey, fingerprint);
-        if (replay) {
-            return replay;
-        }
-        await this.reserveCommandIdempotency('gift', actorId, input.idempotencyKey, fingerprint);
-        // Resolve sender's username for the gift card metadata.
-        const senderSummaries = await this.directory.lookupPlayers([actorId]);
-        const senderSummary = senderSummaries.find((s) => s.userId === actorId);
-        if (!senderSummary) {
-            throw new ChatPlayerNotFoundError(actorId);
-        }
-        const senderUsername = senderSummary.username;
-        const { msg, giftId, currency } = await this.runWithCommandReservation('gift', actorId, input.idempotencyKey, () => this.drizzle.db.transaction(async (tx) => {
-            const debit = await this.wallet.debit(tx, {
-                userId: actorId,
-                amount: input.amount,
-                type: 'gift',
-            });
-            if (!debit.ok) {
-                throw new InsufficientBalanceError();
-            }
-            const [giftRow] = await tx
-                .insert(chatGift)
-                .values({
-                senderId: actorId,
-                senderUsername,
-                amount: input.amount,
-                currency: debit.currency,
-                roomId: input.roomId,
-                // messageId will be updated after postSystemMessage; we use a placeholder UUID
-                // that is immediately overwritten by the UPDATE below in the same transaction.
-                // Pattern: insert with a temporary value, then set the real foreign reference.
-                messageId: '00000000-0000-0000-0000-000000000000',
-            })
-                .returning();
-            if (!giftRow) {
-                throw new InsufficientBalanceError();
-            }
-            const systemMsg = await this.systemWriter.postSystemMessage({
-                roomId: input.roomId,
-                actorId,
-                tx,
-                metadata: {
-                    command: 'gift',
-                    giftId: giftRow.id,
-                    senderId: actorId,
-                    senderUsername,
-                    amount: input.amount,
-                    currency: debit.currency,
-                },
-            });
-            // Back-fill the real message id now that we have it.
-            await tx
-                .update(chatGift)
-                .set({ messageId: systemMsg.id })
-                .where(eq(chatGift.id, giftRow.id));
-            await this.audit.recordInTransaction(tx, {
-                actorId,
-                actorType: 'player',
-                action: 'chat.gift',
-                resourceType: 'chat_gift',
-                resourceId: giftRow.id,
-                before: null,
-                after: { amount: input.amount, roomId: input.roomId },
-            });
-            return { msg: systemMsg, giftId: giftRow.id, currency: debit.currency };
-        }));
-        await this.completeCommandIdempotency('gift', actorId, input.idempotencyKey, fingerprint, msg);
-        // The caller now owns the commit boundary: postSystemMessage was passed `tx` above so
-        // it did not auto-publish - publish only now that this transaction has committed.
-        void this.transport.publish(chatChannel(input.roomId), msg);
-        void this.events.emit('chat.gift.sent', {
-            giftId,
-            senderId: actorId,
-            senderUsername,
-            amount: input.amount,
-            currency,
-            roomId: input.roomId,
-            messageId: msg.id,
-        });
-        return msg;
-    }
-    async getGift(giftId, viewerId) {
-        const rows = await this.drizzle.db
-            .select()
-            .from(chatGift)
-            .where(eq(chatGift.id, giftId))
-            .limit(1);
-        const row = findOneOrThrow(rows, new GiftNotFoundError(giftId));
-        await this.roomAccess.verifyRoomAccess(row.roomId, viewerId);
-        const serialized = serializeRow(row, {
-            dateFields: ['claimedAt', 'createdAt'],
-            decimalFields: ['amount'],
-        });
-        return {
-            id: serialized.id,
-            senderId: serialized.senderId,
-            senderUsername: serialized.senderUsername,
-            amount: serialized.amount,
-            currency: serialized.currency,
-            claimedBy: serialized.claimedBy ?? null,
-            claimedByUsername: serialized.claimedByUsername ?? null,
-            claimedAt: serialized.claimedAt ?? null,
-            createdAt: serialized.createdAt,
-        };
-    }
-    async claimGift(giftId, claimerId) {
-        // Resolve claimer's username upfront — if the claimer is somehow not in the
-        // directory that is a hard server error (defensive guard).
-        const claimerSummaries = await this.directory.lookupPlayers([claimerId]);
-        const claimerSummary = claimerSummaries.find((s) => s.userId === claimerId);
-        if (!claimerSummary) {
-            throw new GiftNotFoundError(claimerId);
-        }
-        const claimerUsername = claimerSummary.username;
-        // Fetch gift to check self-claim BEFORE attempting the atomic update.
-        const existing = await this.drizzle.db
-            .select()
-            .from(chatGift)
-            .where(eq(chatGift.id, giftId))
-            .limit(1);
-        const giftRow = findOneOrThrow(existing, new GiftNotFoundError(giftId));
-        await this.roomAccess.verifyRoomAccess(giftRow.roomId, claimerId);
-        if (giftRow.senderId === claimerId) {
-            throw new GiftSelfClaimError();
-        }
-        const { claimed, currency, roomId } = await this.drizzle.db.transaction(async (tx) => {
-            const claimedAt = new Date();
-            const results = await tx
-                .update(chatGift)
-                .set({ claimedBy: claimerId, claimedByUsername: claimerUsername, claimedAt })
-                .where(and(eq(chatGift.id, giftId), isNull(chatGift.claimedBy)))
-                .returning();
-            if (results.length === 0) {
-                // Another claimer won the race.
-                throw new GiftAlreadyClaimedError();
-            }
-            const updated = findOneOrThrow(results, new GiftAlreadyClaimedError());
-            const credit = await this.wallet.credit(tx, {
-                userId: claimerId,
-                amount: updated.amount,
-                currency: updated.currency,
-                type: 'gift',
-            });
-            if (!credit.ok) {
-                throw new GiftNotFoundError(claimerId);
-            }
-            await this.audit.recordInTransaction(tx, {
-                actorId: claimerId,
-                actorType: 'player',
-                action: 'chat.gift.claimed',
-                resourceType: 'chat_gift',
-                resourceId: giftId,
-                before: null,
-                after: { claimedBy: claimerId, amount: updated.amount },
-            });
-            return { claimed: updated, currency: updated.currency, roomId: updated.roomId };
-        });
-        void this.transport.publish(chatChannel(roomId), {
-            event: 'gift.claimed',
-            giftId,
-            claimedBy: claimerId,
-            claimedByUsername: claimerUsername,
-            claimedAt: claimed.claimedAt?.toISOString() ?? new Date().toISOString(),
-        });
-        void this.events.emit('chat.gift.claimed', {
-            giftId,
-            claimerId,
-            claimerUsername,
-            senderId: giftRow.senderId,
-            amount: claimed.amount,
-            currency,
-            roomId,
-        });
-        return {
-            claimedBy: claimerId,
-            claimedByUsername: claimerUsername,
-            claimedAt: claimed.claimedAt?.toISOString() ?? new Date().toISOString(),
-        };
-    }
-    async handleRain(input, actorId, config) {
-        if (config?.maxAmount !== undefined &&
-            moneyToNumber(input.amount) > moneyToNumber(config.maxAmount)) {
-            throw new ExceedsLimitError();
-        }
-        if (config?.minAmount !== undefined &&
-            moneyToNumber(input.amount) < moneyToNumber(config.minAmount)) {
-            throw new BelowMinimumError();
-        }
-        const configMax = config?.maxRecipients ?? 50;
-        if (input.recipientCount > configMax) {
-            throw new ExceedsLimitError();
-        }
-        const amountUnits = Math.floor(moneyToNumber(input.amount));
-        if (input.recipientCount > amountUnits) {
-            throw new TooManyRecipientsError();
-        }
-        const fingerprint = fingerprintCommand(input);
-        const replay = await this.findCommandReplay('rain', actorId, input.idempotencyKey, fingerprint);
-        if (replay) {
-            return replay;
-        }
-        await this.reserveCommandIdempotency('rain', actorId, input.idempotencyKey, fingerprint);
-        const allOnline = await this.transport.getOnlineUserIds(chatChannel(input.roomId));
-        const recipients = shuffleArray(allOnline.filter((id) => id !== actorId)).slice(0, input.recipientCount);
-        if (recipients.length === 0) {
-            throw new NoOnlineUsersError();
-        }
-        const { msg, currency, totalDistributed } = await this.runWithCommandReservation('rain', actorId, input.idempotencyKey, () => this.drizzle.db.transaction(async (tx) => {
-            const splitResult = await tx.execute(sql `SELECT
-              (floor(floor(${input.amount}::numeric) / ${recipients.length}))::text AS per_recipient,
-              (floor(floor(${input.amount}::numeric) / ${recipients.length}) * ${recipients.length})::text AS total_distributed`);
-            const { per_recipient: perRecipient, total_distributed: totalDistributed } = splitResult
-                .rows[0];
-            const debit = await this.wallet.debit(tx, {
-                userId: actorId,
-                amount: totalDistributed,
-                type: 'rain',
-            });
-            if (!debit.ok) {
-                throw new InsufficientBalanceError();
-            }
-            const credits = await mapConcurrent(recipients, 10, (userId) => this.wallet.credit(tx, {
-                userId,
-                amount: perRecipient,
-                currency: debit.currency,
-                type: 'rain',
-            }));
-            if (credits.some((c) => !c.ok)) {
-                throw new RainCreditError();
-            }
-            const systemMsg = await this.systemWriter.postSystemMessage({
-                roomId: input.roomId,
-                actorId,
-                tx,
-                metadata: {
-                    command: 'rain',
-                    fromUserId: actorId,
-                    amount: totalDistributed,
-                    currency: debit.currency,
-                    recipientCount: recipients.length,
-                    perRecipient,
-                },
-            });
-            await this.audit.recordInTransaction(tx, {
-                actorId,
-                actorType: 'player',
-                action: 'chat.rain',
-                resourceType: 'chat_room',
-                resourceId: input.roomId,
-                before: null,
-                after: { amount: totalDistributed, recipientCount: recipients.length },
-            });
-            return { msg: systemMsg, currency: debit.currency, totalDistributed };
-        }));
-        await this.completeCommandIdempotency('rain', actorId, input.idempotencyKey, fingerprint, msg);
-        void this.transport.publish(chatChannel(input.roomId), msg);
-        void this.events.emit('chat.rain.distributed', {
-            fromUserId: actorId,
-            recipients,
-            recipientCount: recipients.length,
-            totalAmount: totalDistributed,
-            currency,
-            roomId: input.roomId,
-        });
-        return msg;
-    }
-    async handleDonate(input, actorId, config) {
-        if (config?.maxAmount !== undefined &&
-            moneyToNumber(input.amount) > moneyToNumber(config.maxAmount)) {
-            throw new ExceedsLimitError();
-        }
-        if (config?.minAmount !== undefined &&
-            moneyToNumber(input.amount) < moneyToNumber(config.minAmount)) {
-            throw new BelowMinimumError();
-        }
-        const target = await this.resolveExactPlayer(input.targetUsername);
-        if (target.userId === actorId) {
-            throw new DonateSelfError();
-        }
-        const senderSummaries = await this.directory.lookupPlayers([actorId]);
-        const sender = senderSummaries.find((s) => s.userId === actorId);
-        if (!sender) {
-            throw new ChatPlayerNotFoundError(actorId);
-        }
-        const fingerprint = fingerprintCommand(input);
-        const replay = await this.findCommandReplay('donate', actorId, input.idempotencyKey, fingerprint);
-        if (replay) {
-            return replay;
-        }
-        await this.reserveCommandIdempotency('donate', actorId, input.idempotencyKey, fingerprint);
-        const { msg, currency } = await this.runWithCommandReservation('donate', actorId, input.idempotencyKey, () => this.drizzle.db.transaction(async (tx) => {
-            const debit = await this.wallet.debit(tx, {
-                userId: actorId,
-                amount: input.amount,
-                type: 'tip',
-            });
-            if (!debit.ok) {
-                throw new InsufficientBalanceError();
-            }
-            const credit = await this.wallet.credit(tx, {
-                userId: target.userId,
-                amount: input.amount,
-                currency: debit.currency,
-                type: 'tip',
-            });
-            if (!credit.ok) {
-                throw new ChatPlayerNotFoundError(target.userId);
-            }
-            const systemMsg = await this.systemWriter.postSystemMessage({
-                roomId: input.roomId,
-                actorId,
-                tx,
-                metadata: {
-                    command: 'donate',
-                    recipientId: target.userId,
-                    recipientUsername: target.username,
-                    amount: input.amount,
-                    currency: debit.currency,
-                },
-            });
-            await this.audit.recordInTransaction(tx, {
-                actorId,
-                actorType: 'player',
-                action: 'chat.donate',
-                resourceType: 'chat_donation',
-                resourceId: systemMsg.id,
-                before: null,
-                after: { recipientId: target.userId, amount: input.amount, currency: debit.currency },
-            });
-            return { msg: systemMsg, currency: debit.currency };
-        }));
-        await this.completeCommandIdempotency('donate', actorId, input.idempotencyKey, fingerprint, msg);
-        void this.transport.publish(chatChannel(input.roomId), msg);
-        void this.events.emit('chat.donate.sent', {
-            senderId: actorId,
-            senderUsername: sender.username,
-            recipientId: target.userId,
-            recipientUsername: target.username,
-            amount: input.amount,
-            currency,
-            roomId: input.roomId,
-        });
-        return msg;
-    }
-    /** Command must be used to update users that chat commands setup has been invalidated and needs to be refetched */
-    async handleBlockAction(input, actorId) {
-        const summary = await this.resolveExactPlayer(input.targetUsername);
-        if (summary.userId === actorId) {
-            throw new SelfModerationActionError();
-        }
-        if (input.type === 'block') {
-            await this.blockWriter.blockUser(actorId, summary.userId);
-        }
-        else {
-            await this.blockWriter.ignoreUser(actorId, summary.userId);
-        }
-        return this.systemWriter.postSystemMessage({
-            roomId: input.roomId,
-            actorId,
-            metadata: {
-                command: input.type,
-                targetUserId: summary.userId,
-                displayName: summary.username,
-            },
-        });
+    async adminListCommands({ page, limit, sortBy, sortOrder, }) {
+        const dir = sortOrder === 'asc' ? asc : desc;
+        const col = ADMIN_COMMAND_SORT_COLUMNS[sortBy];
+        const [rows, [{ n }]] = await Promise.all([
+            this.drizzle.db
+                .select()
+                .from(chatCommandConfig)
+                .orderBy(dir(col))
+                .limit(limit)
+                .offset(pageToOffset(page, limit)),
+            this.drizzle.db.select({ n: count() }).from(chatCommandConfig),
+        ]);
+        return { items: rows.map(toDescriptor), total: Number(n), page, limit };
     }
     async adminUpdateCommand(input, actorId) {
         const rows = await this.drizzle.db
@@ -637,5 +101,113 @@ export class ChatCommandsService {
         });
         return toDescriptor(row);
     }
+    async searchMentions(q, limit, viewerId) {
+        const ids = await this.directory.findPlayerIds(q, limit);
+        if (ids.length === 0) {
+            return [];
+        }
+        const excluded = new Set(await this.blockWriter.getExcludedUserIds(viewerId));
+        const filteredIds = ids.filter((id) => !excluded.has(id));
+        if (filteredIds.length === 0) {
+            return [];
+        }
+        const summaries = await this.directory.lookupPlayers(filteredIds);
+        return summaries.map((s) => ({ userId: s.userId, username: s.username }));
+    }
+    async postGift(input, actorId) {
+        const result = await this.giftCommands.sendGift(input, actorId);
+        if (result.ok) {
+            return result.message;
+        }
+        switch (result.reason) {
+            case 'disabled':
+                throw new CommandDisabledError('gift');
+            case 'player_not_found':
+                throw new ChatPlayerNotFoundError(result.playerId);
+            case 'insufficient_balance':
+                throw new InsufficientBalanceError();
+            case 'exceeds_limit':
+                throw new ExceedsLimitError();
+            case 'below_minimum':
+                throw new BelowMinimumError();
+            case 'idempotency_key_reuse':
+                throw new ChatCommandIdempotencyKeyReuseError();
+            case 'concurrent_replay':
+                throw new ConcurrentCommandReplayError();
+            case 'room_not_member':
+                throw new ChatRoomNotMemberError(input.roomId);
+        }
+    }
+    async claimGift(giftId, claimerId) {
+        const result = await this.giftCommands.claimGift(giftId, claimerId);
+        if (result.ok) {
+            return {
+                claimedBy: result.claimedBy,
+                claimedByUsername: result.claimedByUsername,
+                claimedAt: result.claimedAt,
+            };
+        }
+        switch (result.reason) {
+            case 'gift_not_found':
+                throw new GiftNotFoundError(giftId);
+            case 'already_claimed':
+                throw new GiftAlreadyClaimedError();
+            case 'self_claim':
+                throw new GiftSelfClaimError();
+            case 'room_not_member':
+                throw new ChatRoomNotMemberError(result.roomId ?? null);
+            case 'gift_credit_failed':
+                throw new GiftCreditError();
+        }
+    }
+    async getGift(giftId, viewerId) {
+        const result = await this.giftCommands.getGift(giftId, viewerId);
+        if (result.ok) {
+            return result.gift;
+        }
+        switch (result.reason) {
+            case 'gift_not_found':
+                throw new GiftNotFoundError(giftId);
+            case 'room_not_member':
+                throw new ChatRoomNotMemberError(result.roomId ?? null);
+        }
+    }
+    // Zero rain business logic here - the RAIN_COMMANDS port (bound by
+    // social-transfers) owns money movement, limit checks, idempotency, and
+    // posting/publishing the resulting chat message. This module only resolves
+    // who is online (it owns presence for the whole chat-command surface via
+    // its own dependency on `chat`) and translates the port's discriminated
+    // result into the typed errors this module's router maps to transport codes.
+    async postRain(input, actorId) {
+        const onlineUserIds = await this.transport.getOnlineUserIds(chatChannel(input.roomId));
+        const result = await this.rainCommands.sendRain({ ...input, onlineUserIds }, actorId);
+        if (result.ok) {
+            return result.message;
+        }
+        switch (result.reason) {
+            case 'disabled':
+                throw new CommandDisabledError('rain');
+            case 'player_not_found':
+                throw new ChatPlayerNotFoundError(result.playerId);
+            case 'insufficient_balance':
+                throw new InsufficientBalanceError();
+            case 'exceeds_limit':
+                throw new ExceedsLimitError();
+            case 'below_minimum':
+                throw new BelowMinimumError();
+            case 'no_online_users':
+                throw new NoOnlineUsersError();
+            case 'too_many_recipients':
+                throw new TooManyRecipientsError();
+            case 'rain_credit_failed':
+                throw new RainCreditError();
+            case 'idempotency_key_reuse':
+                throw new ChatCommandIdempotencyKeyReuseError();
+            case 'concurrent_replay':
+                throw new ConcurrentCommandReplayError();
+            case 'room_not_member':
+                throw new ChatRoomNotMemberError(input.roomId);
+        }
+    }
 }
 //# sourceMappingURL=chat-commands.service.js.map