chattransfer 2.0.17 → 3.0.0

package/server/services/message-history-service.js

@@ -5,7 +5,11 @@ const sqlite3 = require('sqlite3');
 
 const DEFAULT_LIMIT = 100;
 const MAX_LIMIT = 200;
+const MAX_BATCH_ATTACHMENT_COUNT = 200;
+const MAX_BATCH_ATTACHMENT_TOTAL_SIZE = 2 * 1024 * 1024 * 1024;
 const GROUP_SESSION_ID = 'group';
+const DEFAULT_ROOM_ID = 'group_chat';
+const ROOM_CODE_ALPHABET = '23456789ABCDEFGHJKMNPQRSTUVWXYZ';
 
 class MessageHistoryService {
   constructor({ cachePath, databasePath }) {
@@ -20,6 +24,8 @@ class MessageHistoryService {
     this.historyDir = path.dirname(this.databasePath);
     this.db = null;
     this.writeLock = Promise.resolve();
+    this.publicRoomCleanupTimer = null;
+    this.idleRetentionDays = 7;
   }
 
   init() {
@@ -46,6 +52,7 @@ class MessageHistoryService {
   }
 
   close() {
+    this.stopPublicRoomCleanup();
     if (!this.db) return Promise.resolve();
 
     return new Promise((resolve, reject) => {
@@ -62,11 +69,13 @@ class MessageHistoryService {
   async saveMessageInTransaction(message) {
 
     const normalized = this.normalizeMessage(message);
-    const conversation = this.getConversation({
-      chatType: normalized.receiver === 'group_chat' ? 'group' : 'private',
-      requester: normalized.sender,
-      targetUser: normalized.receiver
-    });
+    const conversation = normalized.roomId
+      ? this.getRoomConversation(normalized.roomId)
+      : this.getConversation({
+        chatType: normalized.receiver === 'group_chat' ? 'group' : 'private',
+        requester: normalized.sender,
+        targetUser: normalized.receiver
+      });
 
     await this.run('BEGIN IMMEDIATE');
 
@@ -107,6 +116,16 @@ class MessageHistoryService {
         ]
       );
 
+      if (normalized.roomId && normalized.roomId !== DEFAULT_ROOM_ID) {
+        const activityAt = Date.now();
+        await this.run(
+          `UPDATE rooms
+           SET last_active_at = ?, updated_at = ?
+           WHERE id = ? AND status = 'active'`,
+          [activityAt, activityAt, normalized.roomId]
+        );
+      }
+
       await this.run('COMMIT');
       return normalized;
     } catch (error) {
@@ -115,10 +134,12 @@ class MessageHistoryService {
     }
   }
 
-  async queryHistory({ requester, chatType, targetUser, cursor = null, limit = DEFAULT_LIMIT }) {
+  async queryHistory({ requester, roomId, chatType, targetUser, cursor = null, limit = DEFAULT_LIMIT }) {
     this.ensureOpened();
 
-    const conversation = this.getConversation({ requester, chatType, targetUser });
+    const conversation = roomId
+      ? await this.getVerifiedRoomConversation(roomId, requester)
+      : this.getConversation({ requester, chatType, targetUser });
     const queryLimit = this.normalizeLimit(limit);
     const normalizedCursor = this.normalizeCursor(cursor);
     const direction = normalizedCursor === null ? 'DESC' : 'ASC';
@@ -147,19 +168,183 @@ class MessageHistoryService {
     };
   }
 
-  clearHistory({ requester, chatType, targetUser }) {
+  async queryAttachments({ requester, roomId, chatType, targetUser }) {
     this.ensureOpened();
 
-    return this.enqueueWrite(() => this.clearHistoryInTransaction({
+    const conversation = roomId
+      ? await this.getVerifiedRoomConversation(roomId, requester)
+      : this.getConversation({ requester, chatType, targetUser });
+    const rows = await this.all(
+      `SELECT seq, id, sender_id, sender_nickname, message_type, create_time, created_at,
+              file_path, file_name, file_size, file_mime_type
+       FROM messages
+       WHERE session_id = ? AND file_path IS NOT NULL
+       ORDER BY created_at ASC, seq ASC`,
+      [conversation.sessionId]
+    );
+
+    const attachments = [];
+    for (const row of rows) {
+      const physicalPath = this.resolveExistingFilePath(row.file_path);
+      if (!physicalPath) continue;
+      const stats = fs.statSync(physicalPath);
+      if (!stats.isFile()) continue;
+      const physicalFileName = path.posix.basename(row.file_path);
+
+      attachments.push({
+        msgId: row.id,
+        seq: row.seq,
+        sender: row.sender_id,
+        senderNickname: row.sender_nickname || row.sender_id,
+        msgType: row.message_type,
+        createTime: row.create_time,
+        createdAt: row.created_at,
+        fileName: row.file_name || physicalFileName,
+        fileSize: Number(row.file_size) || stats.size,
+        fileType: row.file_mime_type,
+        fileUrl: `/files/${encodeURIComponent(physicalFileName)}`,
+        filePath: row.file_path,
+        physicalPath,
+        available: true
+      });
+    }
+
+    return { attachments };
+  }
+
+  async getBatchAttachments({ requester, roomId, chatType, targetUser, messageIds }) {
+    this.ensureOpened();
+
+    if (!Array.isArray(messageIds) || messageIds.length === 0) {
+      throw new Error('No attachment selected');
+    }
+
+    const requestedIds = new Set(messageIds.filter((id) => typeof id === 'string' && id.length > 0));
+    if (requestedIds.size === 0) throw new Error('No attachment selected');
+    if (requestedIds.size > MAX_BATCH_ATTACHMENT_COUNT) {
+      throw new Error(`Batch download supports at most ${MAX_BATCH_ATTACHMENT_COUNT} files`);
+    }
+
+    const { attachments } = await this.queryAttachments({
       requester,
+      roomId,
       chatType,
       targetUser
-    }));
+    });
+    const attachmentMap = new Map(attachments.map((attachment) => [attachment.msgId, attachment]));
+    const selectedAttachments = [];
+
+    for (const messageId of requestedIds) {
+      const attachment = attachmentMap.get(messageId);
+      if (!attachment) throw new Error(`Attachment not found: ${messageId}`);
+      if (!attachment.available) throw new Error(`Attachment file missing: ${attachment.fileName}`);
+      selectedAttachments.push(attachment);
+    }
+
+    const totalSize = selectedAttachments.reduce((total, attachment) => (
+      total + (Number(attachment.fileSize) || 0)
+    ), 0);
+    if (totalSize > MAX_BATCH_ATTACHMENT_TOTAL_SIZE) {
+      throw new Error('Batch download exceeds the 2GB size limit');
+    }
+
+    return selectedAttachments;
+  }
+
+  async clearHistory({ requester, roomId, chatType, targetUser }) {
+    this.ensureOpened();
+
+    let conversation;
+    if (roomId) {
+      if (roomId === DEFAULT_ROOM_ID) {
+        throw new Error('Public Lobby history requires administrator');
+      }
+      await this.requireRoomOwner(roomId, requester);
+      conversation = this.getRoomConversation(roomId);
+    } else {
+      conversation = this.getConversation({ requester, chatType, targetUser });
+      if (conversation.chatType === 'group') {
+        throw new Error('Public Lobby history requires administrator');
+      }
+    }
+
+    return this.enqueueWrite(() => this.clearConversationHistory(conversation));
+  }
+
+  async clearPublicRoomHistory() {
+    this.ensureOpened();
+    const conversation = this.getRoomConversation(DEFAULT_ROOM_ID);
+    return this.enqueueWrite(() => this.clearConversationHistory(conversation));
+  }
+
+  async cleanupExpiredPublicRoomMessages({ retentionDays = 7, now = Date.now() } = {}) {
+    this.ensureOpened();
+    const days = Number(retentionDays);
+    if (!Number.isFinite(days) || days <= 0) {
+      return { deletedFiles: 0, skippedFiles: 0, failedFiles: 0 };
+    }
+
+    const cutoff = now - (days * 24 * 60 * 60 * 1000);
+
+    return this.enqueueWrite(async () => {
+      const files = await this.all(
+        `SELECT DISTINCT file_path
+         FROM messages
+         WHERE session_id = ? AND created_at < ? AND file_path IS NOT NULL`,
+        [GROUP_SESSION_ID, cutoff]
+      );
+
+      await this.run('BEGIN IMMEDIATE');
+
+      try {
+        for (const file of files) {
+          await this.run(
+            'INSERT OR IGNORE INTO file_cleanup_queue(file_path, created_at) VALUES (?, ?)',
+            [file.file_path, Date.now()]
+          );
+        }
+
+        await this.run(
+          'DELETE FROM messages WHERE session_id = ? AND created_at < ?',
+          [GROUP_SESSION_ID, cutoff]
+        );
+        await this.run('COMMIT');
+      } catch (error) {
+        await this.run('ROLLBACK').catch(() => {});
+        throw error;
+      }
+
+      const cleanup = await this.processCleanupQueue();
+      return {
+        deletedFiles: cleanup.deletedFiles,
+        skippedFiles: cleanup.skippedFiles,
+        failedFiles: cleanup.failedFiles
+      };
+    });
+  }
+
+  startPublicRoomCleanup({ retentionDays = 7, intervalMs = 6 * 60 * 60 * 1000 } = {}) {
+    this.stopPublicRoomCleanup();
+    if (!Number.isFinite(Number(retentionDays)) || Number(retentionDays) <= 0) return;
+
+    const run = () => {
+      this.cleanupExpiredPublicRoomMessages({ retentionDays }).catch((error) => {
+        console.error('[History] public room cleanup failed:', error.message);
+      });
+    };
+
+    run();
+    this.publicRoomCleanupTimer = setInterval(run, intervalMs);
+    this.publicRoomCleanupTimer.unref?.();
   }
 
-  async clearHistoryInTransaction({ requester, chatType, targetUser }) {
+  stopPublicRoomCleanup() {
+    if (!this.publicRoomCleanupTimer) return;
+    clearInterval(this.publicRoomCleanupTimer);
+    this.publicRoomCleanupTimer = null;
+  }
 
-    const conversation = this.getConversation({ requester, chatType, targetUser });
+  async clearConversationHistory(conversation) {
     const files = await this.all(
       'SELECT DISTINCT file_path FROM messages WHERE session_id = ? AND file_path IS NOT NULL',
       [conversation.sessionId]
@@ -277,6 +462,74 @@ class MessageHistoryService {
       last_error TEXT,
       created_at INTEGER NOT NULL
     )`);
+    await this.run(`CREATE TABLE IF NOT EXISTS rooms (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      code TEXT UNIQUE,
+      created_by TEXT,
+      owner_id TEXT,
+      status TEXT NOT NULL DEFAULT 'active',
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      deleted_at INTEGER,
+      last_active_at INTEGER,
+      deleted_reason TEXT
+    )`);
+    await this.run(`CREATE TABLE IF NOT EXISTS room_participants (
+      room_id TEXT NOT NULL,
+      user_id TEXT NOT NULL,
+      role TEXT NOT NULL DEFAULT 'member',
+      nickname TEXT,
+      joined_at INTEGER NOT NULL,
+      last_seen_at INTEGER,
+      PRIMARY KEY (room_id, user_id),
+      FOREIGN KEY (room_id) REFERENCES rooms(id)
+    )`);
+    await this.run(`CREATE INDEX IF NOT EXISTS idx_room_participants_user
+      ON room_participants(user_id, joined_at)`);
+    await this.ensureColumn('rooms', 'owner_id', 'TEXT');
+    await this.ensureColumn('rooms', 'deleted_at', 'INTEGER');
+    await this.ensureColumn('rooms', 'last_active_at', 'INTEGER');
+    await this.ensureColumn('rooms', 'deleted_reason', 'TEXT');
+    await this.ensureColumn('room_participants', 'role', "TEXT NOT NULL DEFAULT 'member'");
+    await this.run(
+      `UPDATE rooms
+       SET owner_id = created_by
+       WHERE id <> ? AND owner_id IS NULL AND created_by IS NOT NULL`,
+      [DEFAULT_ROOM_ID]
+    );
+    await this.run(
+      `UPDATE rooms
+       SET last_active_at = COALESCE(last_active_at, updated_at, created_at)
+       WHERE last_active_at IS NULL`
+    );
+    await this.run(
+      `UPDATE room_participants
+       SET role = 'owner'
+       WHERE EXISTS (
+         SELECT 1 FROM rooms
+         WHERE rooms.id = room_participants.room_id
+           AND rooms.owner_id = room_participants.user_id
+       )`
+    );
+    await this.run(
+      `INSERT OR IGNORE INTO rooms(
+        id, name, code, created_by, owner_id, status, created_at, updated_at
+      ) VALUES (?, ?, NULL, NULL, NULL, 'active', ?, ?)`,
+      [DEFAULT_ROOM_ID, 'Public Lobby', Date.now(), Date.now()]
+    );
+    await this.run(
+      `UPDATE rooms
+       SET name = 'Public Lobby'
+       WHERE id = ? AND name IN ('Default Room', 'Public Transit Station')`,
+      [DEFAULT_ROOM_ID]
+    );
+  }
+
+  async ensureColumn(table, column, definition) {
+    const columns = await this.all(`PRAGMA table_info(${table})`);
+    if (columns.some((item) => item.name === column)) return;
+    await this.run(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
   }
 
   getConversation({ requester, chatType, targetUser }) {
@@ -316,6 +569,463 @@ class MessageHistoryService {
     };
   }
 
+  getRoomConversation(roomId) {
+    if (!this.isValidRoomId(roomId)) {
+      throw new Error('Invalid room ID');
+    }
+
+    return {
+      sessionId: roomId === DEFAULT_ROOM_ID ? GROUP_SESSION_ID : `room:${roomId}`,
+      chatType: 'room',
+      roomId,
+      participants: []
+    };
+  }
+
+  async getVerifiedRoomConversation(roomId, requester) {
+    const conversation = this.getRoomConversation(roomId);
+    const room = await this.getRoom(roomId);
+    if (!room) throw new Error('Room not found');
+
+    if (roomId !== DEFAULT_ROOM_ID) {
+      const participant = await this.get(
+        'SELECT user_id FROM room_participants WHERE room_id = ? AND user_id = ?',
+        [roomId, requester]
+      );
+      if (!participant) throw new Error('Room access denied');
+    }
+
+    return conversation;
+  }
+
+  async createRoom({ name, createdBy, nickname = '' }) {
+    this.ensureOpened();
+
+    const roomName = String(name || '').trim();
+    if (!roomName || roomName.length > 60) {
+      throw new Error('Invalid room name');
+    }
+
+    const now = Date.now();
+    const room = {
+      id: crypto.randomUUID(),
+      name: roomName,
+      code: null,
+      createdBy: createdBy || null,
+      ownerId: createdBy || null,
+      status: 'active',
+      createdAt: now,
+      updatedAt: now,
+      lastActiveAt: now
+    };
+
+    return this.enqueueWrite(async () => {
+      for (let attempt = 0; attempt < 10; attempt += 1) {
+        room.code = this.generateRoomCode();
+
+        try {
+          await this.run(
+            `INSERT INTO rooms(
+              id, name, code, created_by, owner_id, status,
+              created_at, updated_at, last_active_at
+            )
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+            [
+              room.id,
+              room.name,
+              room.code,
+              room.createdBy,
+              room.ownerId,
+              room.status,
+              room.createdAt,
+              room.updatedAt,
+              room.lastActiveAt
+            ]
+          );
+          if (room.createdBy) {
+            await this.run(
+              `INSERT INTO room_participants(
+                room_id, user_id, role, nickname, joined_at, last_seen_at
+              ) VALUES (?, ?, 'owner', ?, ?, ?)
+              ON CONFLICT(room_id, user_id) DO UPDATE SET
+                role = 'owner',
+                nickname = COALESCE(room_participants.nickname, excluded.nickname),
+                last_seen_at = excluded.last_seen_at`,
+              [room.id, room.createdBy, nickname || null, now, now]
+            );
+          }
+          return { ...this.mapRoom(room), role: room.createdBy ? 'owner' : 'member' };
+        } catch (error) {
+          if (!String(error.message || '').includes('UNIQUE constraint failed: rooms.code')) {
+            throw error;
+          }
+        }
+      }
+
+      throw new Error('Unable to generate a unique room code');
+    });
+  }
+
+  async getRoom(roomId) {
+    this.ensureOpened();
+    if (!this.isValidRoomId(roomId)) return null;
+
+    const row = await this.get(
+      'SELECT * FROM rooms WHERE id = ? AND status = ?',
+      [roomId, 'active']
+    );
+    return row ? this.mapRoom(row) : null;
+  }
+
+  async getRoomByCode(code) {
+    this.ensureOpened();
+    const normalizedCode = this.normalizeRoomCode(code);
+    if (!normalizedCode) return null;
+
+    const row = await this.get(
+      'SELECT * FROM rooms WHERE code = ? AND status = ?',
+      [normalizedCode, 'active']
+    );
+    return row ? this.mapRoom(row) : null;
+  }
+
+  async joinRoom({ roomId, code, userId, nickname = '' }) {
+    this.ensureOpened();
+
+    if (!this.isValidUserId(userId)) throw new Error('Invalid user');
+    const room = await this.getRoom(roomId);
+    if (!room) throw new Error('Room not found');
+
+    const participant = await this.get(
+      'SELECT user_id, role FROM room_participants WHERE room_id = ? AND user_id = ?',
+      [room.id, userId]
+    );
+    const normalizedCode = this.normalizeRoomCode(code);
+
+    if (room.id !== DEFAULT_ROOM_ID && !participant) {
+      if (!normalizedCode) throw new Error('Room code required');
+      if (normalizedCode !== room.code) throw new Error('Invalid room code');
+    }
+
+    const now = Date.now();
+    await this.enqueueWrite(() => this.run(
+      `INSERT INTO room_participants(room_id, user_id, role, nickname, joined_at, last_seen_at)
+       VALUES (?, ?, 'member', ?, ?, ?)
+       ON CONFLICT(room_id, user_id) DO UPDATE SET
+         nickname = excluded.nickname,
+         last_seen_at = excluded.last_seen_at`,
+      [room.id, userId, nickname || null, now, now]
+    ));
+
+    if (room.id !== DEFAULT_ROOM_ID) {
+      await this.enqueueWrite(() => this.run(
+        'UPDATE rooms SET last_active_at = ?, updated_at = ? WHERE id = ?',
+        [now, now, room.id]
+      ));
+    }
+
+    return {
+      ...room,
+      role: participant?.role || 'member'
+    };
+  }
+
+  async listRoomsForUser(userId) {
+    this.ensureOpened();
+    if (!this.isValidUserId(userId)) throw new Error('Invalid user');
+
+    const rows = await this.all(
+      `SELECT r.*, p.role AS participant_role, p.joined_at, p.last_seen_at
+       FROM rooms r
+       INNER JOIN room_participants p ON p.room_id = r.id
+       WHERE p.user_id = ? AND r.status = 'active'
+       ORDER BY p.last_seen_at DESC, p.joined_at DESC`,
+      [userId]
+    );
+
+    return Promise.all(rows.map(async (row) => {
+      const room = this.mapRoom(row);
+      const session = this.getRoomConversation(room.id);
+      const lastMessage = await this.get(
+        `SELECT content, message_type, create_time, created_at
+         FROM messages
+         WHERE session_id = ?
+         ORDER BY seq DESC
+         LIMIT 1`,
+        [session.sessionId]
+      );
+
+      return {
+        ...room,
+        role: row.participant_role || 'member',
+        joinedAt: row.joined_at,
+        lastSeenAt: row.last_seen_at,
+        expiresAt: room.id !== DEFAULT_ROOM_ID && this.idleRetentionDays > 0
+          ? room.lastActiveAt + (this.idleRetentionDays * 24 * 60 * 60 * 1000)
+          : null,
+        lastMessage: lastMessage ? {
+          content: lastMessage.content || '',
+          msgType: lastMessage.message_type,
+          createTime: lastMessage.create_time,
+          createdAt: lastMessage.created_at
+        } : null
+      };
+    }));
+  }
+
+  configureIdleRetention(days = 7) {
+    const value = Number(days);
+    this.idleRetentionDays = Number.isFinite(value) && value >= 0 ? value : 7;
+  }
+
+  async listInactiveRooms({ retentionDays = this.idleRetentionDays, now = Date.now() } = {}) {
+    this.ensureOpened();
+    const days = Number(retentionDays);
+    if (!Number.isFinite(days) || days <= 0) return [];
+
+    const cutoff = now - (days * 24 * 60 * 60 * 1000);
+    const rows = await this.all(
+      `SELECT *
+       FROM rooms
+       WHERE status = 'active'
+         AND id <> ?
+         AND COALESCE(last_active_at, updated_at, created_at) < ?
+       ORDER BY COALESCE(last_active_at, updated_at, created_at) ASC`,
+      [DEFAULT_ROOM_ID, cutoff]
+    );
+
+    return rows.map((row) => this.mapRoom(row));
+  }
+
+  async deleteRoomBySystem({ roomId, reason = 'inactive', cutoff = null }) {
+    this.ensureOpened();
+    if (roomId === DEFAULT_ROOM_ID) return null;
+
+    return this.enqueueWrite(async () => {
+      const room = await this.getRoom(roomId);
+      if (!room) return null;
+      if (cutoff !== null && Number(room.lastActiveAt) >= Number(cutoff)) {
+        return null;
+      }
+
+      await this.run('BEGIN IMMEDIATE');
+
+      try {
+        const dissolved = await this.dissolveRoomContentsInTransaction(room, reason);
+        await this.run('COMMIT');
+        const cleanup = await this.processCleanupQueue();
+        return {
+          roomId,
+          roomName: room.name,
+          sessionId: dissolved.sessionId,
+          deletedReason: reason,
+          ...cleanup
+        };
+      } catch (error) {
+        await this.run('ROLLBACK').catch(() => {});
+        throw error;
+      }
+    });
+  }
+
+  async requireRoomOwner(roomId, requester) {
+    if (!this.isValidUserId(requester)) throw new Error('Invalid user');
+    if (roomId === DEFAULT_ROOM_ID) {
+      throw new Error('Public Lobby is managed by the server administrator');
+    }
+
+    const room = await this.getRoom(roomId);
+    if (!room) throw new Error('Room not found');
+
+    const participant = await this.get(
+      'SELECT role FROM room_participants WHERE room_id = ? AND user_id = ?',
+      [roomId, requester]
+    );
+    if (!participant) throw new Error('Room access denied');
+    if (participant.role !== 'owner' || room.ownerId !== requester) {
+      throw new Error('Room owner permission required');
+    }
+
+    return { ...room, role: 'owner' };
+  }
+
+  async updateRoomName({ roomId, name, requester }) {
+    this.ensureOpened();
+
+    const roomName = String(name || '').trim();
+    if (!roomName || roomName.length > 60) throw new Error('Invalid room name');
+    const room = await this.requireRoomOwner(roomId, requester);
+
+    const updatedAt = Date.now();
+    await this.enqueueWrite(() => this.run(
+      'UPDATE rooms SET name = ?, updated_at = ?, last_active_at = ? WHERE id = ?',
+      [roomName, updatedAt, updatedAt, roomId]
+    ));
+
+    return { ...room, name: roomName, updatedAt };
+  }
+
+  async regenerateRoomCode({ roomId, requester }) {
+    this.ensureOpened();
+
+    const room = await this.requireRoomOwner(roomId, requester);
+
+    const code = this.generateRoomCode();
+    const updatedAt = Date.now();
+    await this.enqueueWrite(() => this.run(
+      'UPDATE rooms SET code = ?, updated_at = ?, last_active_at = ? WHERE id = ?',
+      [code, updatedAt, updatedAt, roomId]
+    ));
+
+    return { ...room, code, updatedAt };
+  }
+
+  async leaveRoom({ roomId, userId }) {
+    this.ensureOpened();
+    if (!this.isValidUserId(userId)) throw new Error('Invalid user');
+    if (roomId === DEFAULT_ROOM_ID) {
+      throw new Error('Public Lobby cannot be left');
+    }
+
+    return this.enqueueWrite(async () => {
+      const room = await this.getRoom(roomId);
+      if (!room) throw new Error('Room not found');
+
+      const participant = await this.get(
+        'SELECT role FROM room_participants WHERE room_id = ? AND user_id = ?',
+        [roomId, userId]
+      );
+      if (!participant) throw new Error('Room access denied');
+
+      await this.run('BEGIN IMMEDIATE');
+
+      try {
+        await this.run(
+          'DELETE FROM room_participants WHERE room_id = ? AND user_id = ?',
+          [roomId, userId]
+        );
+
+        const remaining = await this.all(
+          `SELECT user_id, role FROM room_participants
+           WHERE room_id = ?
+           ORDER BY joined_at ASC, user_id ASC`,
+          [roomId]
+        );
+
+        if (remaining.length === 0) {
+          const dissolved = await this.dissolveRoomContentsInTransaction(room, 'last_member_left');
+          await this.run('COMMIT');
+          const cleanup = await this.processCleanupQueue();
+          return {
+            roomId,
+            sessionId: dissolved.sessionId,
+            dissolved: true,
+            newOwnerId: null,
+            ...cleanup
+          };
+        }
+
+        let newOwnerId = room.ownerId;
+        let ownerChanged = false;
+        if (participant.role === 'owner' || room.ownerId === userId) {
+          newOwnerId = remaining[0].user_id;
+          ownerChanged = true;
+          await this.run(
+            "UPDATE room_participants SET role = 'member' WHERE room_id = ?",
+            [roomId]
+          );
+          await this.run(
+            "UPDATE room_participants SET role = 'owner' WHERE room_id = ? AND user_id = ?",
+            [roomId, newOwnerId]
+          );
+          await this.run(
+            `UPDATE rooms
+             SET owner_id = ?, updated_at = ?, last_active_at = ?
+             WHERE id = ?`,
+            [newOwnerId, Date.now(), Date.now(), roomId]
+          );
+        }
+
+        if (!ownerChanged) {
+          const activityAt = Date.now();
+          await this.run(
+            'UPDATE rooms SET last_active_at = ?, updated_at = ? WHERE id = ?',
+            [activityAt, activityAt, roomId]
+          );
+        }
+
+        await this.run('COMMIT');
+        return {
+          roomId,
+          sessionId: this.getRoomConversation(roomId).sessionId,
+          dissolved: false,
+          newOwnerId,
+          ownerChanged
+        };
+      } catch (error) {
+        await this.run('ROLLBACK').catch(() => {});
+        throw error;
+      }
+    });
+  }
+
+  async dissolveRoom({ roomId, requester }) {
+    this.ensureOpened();
+    const room = await this.requireRoomOwner(roomId, requester);
+
+    return this.enqueueWrite(async () => {
+      await this.run('BEGIN IMMEDIATE');
+
+      try {
+        const dissolved = await this.dissolveRoomContentsInTransaction(room, 'manual');
+        await this.run('COMMIT');
+        const cleanup = await this.processCleanupQueue();
+        return {
+          roomId,
+          sessionId: dissolved.sessionId,
+          ...cleanup
+        };
+      } catch (error) {
+        await this.run('ROLLBACK').catch(() => {});
+        throw error;
+      }
+    });
+  }
+
+  async dissolveRoomContentsInTransaction(room, reason = 'manual') {
+    const conversation = this.getRoomConversation(room.id);
+    const files = await this.all(
+      'SELECT DISTINCT file_path FROM messages WHERE session_id = ? AND file_path IS NOT NULL',
+      [conversation.sessionId]
+    );
+    const now = Date.now();
+
+    for (const file of files) {
+      await this.run(
+        'INSERT OR IGNORE INTO file_cleanup_queue(file_path, created_at) VALUES (?, ?)',
+        [file.file_path, now]
+      );
+    }
+
+    await this.run(
+      'DELETE FROM messages WHERE session_id = ?',
+      [conversation.sessionId]
+    );
+    await this.run(
+      'DELETE FROM room_participants WHERE room_id = ?',
+      [room.id]
+    );
+    await this.run(
+      `UPDATE rooms
+       SET status = 'deleted', deleted_at = ?, updated_at = ?, code = NULL,
+           deleted_reason = ?
+       WHERE id = ?`,
+      [now, now, reason, room.id]
+    );
+
+    return { sessionId: conversation.sessionId };
+  }
+
   normalizeMessage(message) {
     if (!this.isValidUserId(message.sender)) {
       throw new Error('Invalid message sender');
@@ -411,10 +1121,65 @@ class MessageHistoryService {
     return physicalPath;
   }
 
+  resolveExistingFilePath(filePath) {
+    const physicalPath = this.resolveFilePath(filePath);
+    if (!physicalPath) return null;
+
+    try {
+      const realCachePath = fs.realpathSync(this.cachePath);
+      const realFilesPath = path.join(realCachePath, 'files');
+      const realPhysicalPath = fs.realpathSync(physicalPath);
+      const relativePath = path.relative(realFilesPath, realPhysicalPath);
+
+      if (
+        relativePath === '' ||
+        relativePath.startsWith('..') ||
+        path.isAbsolute(relativePath)
+      ) {
+        return null;
+      }
+
+      return realPhysicalPath;
+    } catch (error) {
+      return null;
+    }
+  }
+
   isValidUserId(value) {
     return typeof value === 'string' && value.trim().length > 0 && value.length <= 256;
   }
 
+  isValidRoomId(value) {
+    return value === DEFAULT_ROOM_ID || /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+  }
+
+  generateRoomCode() {
+    return Array.from(
+      { length: 8 },
+      () => ROOM_CODE_ALPHABET[crypto.randomInt(ROOM_CODE_ALPHABET.length)]
+    ).join('');
+  }
+
+  normalizeRoomCode(value) {
+    return String(value || '').toUpperCase().replace(/[^0-9A-Z]/g, '');
+  }
+
+  mapRoom(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      code: row.code,
+      createdBy: row.created_by,
+      ownerId: row.owner_id || null,
+      status: row.status,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      deletedAt: row.deleted_at || null,
+      deletedReason: row.deleted_reason || null,
+      lastActiveAt: row.last_active_at || row.updated_at || row.created_at || null
+    };
+  }
+
   normalizeLimit(limit) {
     const value = Number(limit);
     if (!Number.isFinite(value) || value <= 0) return DEFAULT_LIMIT;
@@ -472,5 +1237,6 @@ class MessageHistoryService {
 
 module.exports = {
   MessageHistoryService,
-  GROUP_SESSION_ID
+  GROUP_SESSION_ID,
+  DEFAULT_ROOM_ID
 };