chattransfer 2.0.17 → 3.0.0

package/frontend/dist/index.html

@@ -5,8 +5,8 @@
     <link rel="icon" href="/assets/logo-DQUxWwh1.png" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>ChatTransfer</title>
-    <script type="module" crossorigin src="/assets/index-B2dOrakb.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DYJPnabS.css">
+    <script type="module" crossorigin src="/assets/index-BTJ_Fb6p.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-IvWY8A4p.css">
   </head>
   <body>
     <div id="app"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chattransfer",
-  "version": "2.0.17",
+  "version": "3.0.0",
   "description": "LAN instant messaging and file transfer tool",
   "main": "server/index.js",
   "engines": {
@@ -32,10 +32,11 @@
     "node-machine-id": "^1.1.12",
     "prebuild-install": "7.1.3",
     "qr-image": "^3.2.0",
-    "sqlite3": "5.1.7",
     "socket.io": "^4.8.3",
+    "sqlite3": "5.1.7",
     "underscore": "^1.10.2",
-    "urlencode": "^1.1.0"
+    "urlencode": "^1.1.0",
+    "yazl": "^3.3.1"
   },
   "bin": {
     "chattransfer": "bin/chattransfer.js"

package/server/cli-options.js

@@ -5,6 +5,8 @@ const CLI_OPTIONS = {
   port: { type: 'string' },
   'data-dir': { type: 'string' },
   'public-url': { type: 'string' },
+  'room-idle-retention-days': { type: 'string' },
+  'public-room-retention-days': { type: 'string' },
   'no-browser': { type: 'boolean', default: false },
   version: { type: 'boolean', default: false },
   help: { type: 'boolean', default: false }
@@ -33,6 +35,8 @@ function toStartOptions(cliValues, env = process.env) {
     port: cliValues.port,
     dataDir: cliValues['data-dir'],
     publicUrl: cliValues['public-url'],
+    roomIdleRetentionDays: cliValues['room-idle-retention-days'],
+    publicRoomRetentionDays: cliValues['public-room-retention-days'],
     openBrowser: cliValues['no-browser'] ? false : undefined
   }, env);
 }
@@ -49,6 +53,8 @@ function getHelpText() {
     '  --port <port>              Listen port (default: 55556)',
     '  --data-dir <path>          Runtime data directory',
     '  --public-url <url>         Public URL used by QR codes and links',
+    '  --room-idle-retention-days <days>  Delete idle rooms after N days (default: 7, 0 disables)',
+    '  --public-room-retention-days <days> Clear Public Lobby messages after N days (default: 7, 0 disables)',
     '  --no-browser               Do not open the local browser',
     '  --version                  Print the version',
     '  --help                     Print this help',
@@ -58,7 +64,9 @@ function getHelpText() {
     '  CHATTRANSFER_PORT',
     '  CHATTRANSFER_DATA_DIR',
     '  CHATTRANSFER_PUBLIC_URL',
-    '  CHATTRANSFER_NO_BROWSER'
+    '  CHATTRANSFER_NO_BROWSER',
+    '  CHATTRANSFER_ROOM_IDLE_RETENTION_DAYS',
+    '  CHATTRANSFER_PUBLIC_ROOM_RETENTION_DAYS'
   ].join('\n');
 }
 

package/server/index.js

@@ -7,6 +7,7 @@ const { getCachePath, getConfigFile, getDefaultCachePath } = require('./config')
 const registerRoutes = require('./routes/index');
 const registerSocket = require('./socket/index');
 const { MessageHistoryService } = require('./services/message-history-service');
+const { BatchDownloadService } = require('./services/batch-download-service');
 const { trackEvent } = require('./telemetry/compat');
 const {
   getDatabaseFile,
@@ -26,7 +27,7 @@ function createApp() {
   return app;
 }
 
-function createConfiguredApp(cachePath) {
+function createConfiguredApp(cachePath, historyService = null, batchDownloadService = null) {
   const app = createApp();
   const safeCachePath = cachePath
     ? { path: path.resolve(cachePath), changed: false }
@@ -43,7 +44,7 @@ function createConfiguredApp(cachePath) {
     console.warn(`[Cache] fallback to default: ${safeCachePath.path}`);
   }
 
-  registerRoutes(app, safeCachePath.path);
+  registerRoutes(app, safeCachePath.path, historyService, batchDownloadService);
   return app;
 }
 
@@ -115,6 +116,7 @@ async function start(options = {}) {
     cachePath: uploadsDir,
     databasePath: usesIndependentDatabaseFile() ? getDatabaseFile() : undefined
   });
+  const batchDownloadService = new BatchDownloadService({ historyService });
 
   try {
     await historyService.init();
@@ -123,16 +125,29 @@ async function start(options = {}) {
     return;
   }
 
-  const app = createConfiguredApp(uploadsDir);
+  historyService.configureIdleRetention(runtimeOptions.roomIdleRetentionDays);
+  const publicRoomRetentionDays = runtimeOptions.publicRoomRetentionDays;
+  if (Number.isFinite(publicRoomRetentionDays) && publicRoomRetentionDays > 0) {
+    historyService.startPublicRoomCleanup({ retentionDays: publicRoomRetentionDays });
+  }
+
+  const app = createConfiguredApp(uploadsDir, historyService, batchDownloadService);
   const server = http.createServer(app);
 
-  registerSocket(server, historyService);
+  const io = registerSocket(server, historyService, batchDownloadService, {
+    roomIdleRetentionDays: runtimeOptions.roomIdleRetentionDays
+  });
+  await io.idleCleanupReady;
 
   await new Promise((resolve, reject) => {
     server.once('error', reject);
     server.listen(port, runtimeOptions.host, resolve);
   });
 
+  server.once('close', () => {
+    historyService.stopPublicRoomCleanup();
+  });
+
   const homeUrl = runtimeOptions.publicUrl || `http://${clientIpAddress}:${port}`;
 
   console.log(`ChatTransfer v${pkg.version}`);
@@ -141,6 +156,7 @@ async function start(options = {}) {
   console.log(`CacheDir: ${uploadsDir}`);
   console.log(`Runtime: ${getRuntimeName()}`);
   console.log(`DataDir: ${path.dirname(getConfigFile())}`);
+  console.log(`Retention: idle-room=${runtimeOptions.roomIdleRetentionDays}d public-messages=${runtimeOptions.publicRoomRetentionDays}d`);
 
   trackEvent('app_start', {
     local_url: homeUrl,

package/server/room-manager.js

@@ -1,10 +1,20 @@
 const ONLINE = 'ONLINE';
 const OFFLINE = 'OFFLINE';
+const DEFAULT_ROOM_ID = 'group_chat';
 
 class RoomManager {
   constructor() {
-    this.users = new Map();
-    this.groupName = '';
+    this.rooms = new Map();
+    this.roomNames = new Map();
+    this.ensureRoom(DEFAULT_ROOM_ID);
+  }
+
+  ensureRoom(roomId = DEFAULT_ROOM_ID) {
+    if (!this.rooms.has(roomId)) {
+      this.rooms.set(roomId, { users: new Map() });
+    }
+
+    return this.rooms.get(roomId);
   }
 
   getOnline() {
@@ -15,22 +25,55 @@ class RoomManager {
     return OFFLINE;
   }
 
-  setOnline({ username, socketId, nickname = '', ip = '' }) {
-    const existing = this.users.get(username) || {};
-    this.users.set(username, {
-      socketId,
+  setOnline({ roomId = DEFAULT_ROOM_ID, username, socketId, nickname = '', ip = '' }) {
+    const room = this.ensureRoom(roomId);
+    const existing = room.users.get(username) || {
+      socketIds: new Set(),
+      status: OFFLINE,
+      nickname: '',
+      ip: '',
+      lastSeenAt: null,
+      onlineSince: null
+    };
+    const socketIds = new Set(existing.socketIds || []);
+    if (socketId) socketIds.add(socketId);
+    const wasOnline = existing.status === ONLINE && socketIds.size > 0;
+    const user = {
+      ...existing,
+      socketIds,
       status: ONLINE,
       nickname: nickname || existing.nickname || '',
-      ip
-    });
+      ip: ip || existing.ip || '',
+      onlineSince: wasOnline ? existing.onlineSince : Date.now()
+    };
+    room.users.set(username, user);
+
+    return {
+      user: this.getPublicUser(roomId, username),
+      becameOnline: !wasOnline
+    };
   }
 
-  getUser(username) {
-    return this.users.get(username);
+  getUser(roomId = DEFAULT_ROOM_ID, username) {
+    return this.ensureRoom(roomId).users.get(username);
+  }
+
+  getPublicUser(roomId = DEFAULT_ROOM_ID, username) {
+    const user = this.ensureRoom(roomId).users.get(username);
+    if (!user) return null;
+
+    return {
+      sender: username,
+      nickname: user.nickname || '',
+      ip: user.ip || '',
+      status: user.status,
+      lastSeenAt: user.lastSeenAt || null,
+      onlineSince: user.onlineSince || null
+    };
   }
 
-  setNickname(username, nickname) {
-    const user = this.users.get(username);
+  setNickname({ roomId = DEFAULT_ROOM_ID, username, nickname = '' }) {
+    const user = this.getUser(roomId, username);
 
     if (!user) {
       return false;
@@ -40,36 +83,85 @@ class RoomManager {
     return true;
   }
 
-  setOffline(username) {
-    const user = this.users.get(username);
+  removeSocket({ roomId = DEFAULT_ROOM_ID, username, socketId }) {
+    const user = this.getUser(roomId, username);
 
     if (!user) {
-      return false;
+      return { user: null, hasConnections: false };
+    }
+
+    user.socketIds.delete(socketId);
+    return {
+      user: this.getPublicUser(roomId, username),
+      hasConnections: user.socketIds.size > 0
+    };
+  }
+
+  markOffline({ roomId = DEFAULT_ROOM_ID, username }) {
+    const user = this.getUser(roomId, username);
+
+    if (!user) {
+      return { user: null, becameOffline: false };
     }
 
+    const becameOffline = user.status !== OFFLINE;
+    user.socketIds.clear();
     user.status = OFFLINE;
+    user.onlineSince = null;
+    user.lastSeenAt = Date.now();
+
+    return {
+      user: this.getPublicUser(roomId, username),
+      becameOffline
+    };
+  }
+
+  setOffline({ roomId = DEFAULT_ROOM_ID, username, socketId = null }) {
+    const user = this.getUser(roomId, username);
+
+    if (!user) {
+      return { user: null, becameOffline: false, hasConnections: false };
+    }
+
+    if (socketId) user.socketIds.delete(socketId);
+    const hasConnections = user.socketIds.size > 0;
+
+    return hasConnections
+      ? { user: this.getPublicUser(roomId, username), becameOffline: false, hasConnections }
+      : { ...this.markOffline({ roomId, username }), hasConnections: false };
+  }
+
+  listUsers(roomId = DEFAULT_ROOM_ID) {
+    const room = this.ensureRoom(roomId);
+    return [...room.users.keys()].map((username) => this.getPublicUser(roomId, username));
+  }
+
+  removeRoom(roomId = DEFAULT_ROOM_ID) {
+    if (roomId === DEFAULT_ROOM_ID) return false;
+    this.rooms.delete(roomId);
+    this.roomNames.delete(roomId);
     return true;
   }
 
-  listUsers() {
-    return [...this.users.entries()].map(([username, user]) => ({
-      sender: username,
-      nickname: user.nickname || '',
-      ip: user.ip || '',
-      status: user.status
-    }));
+  setRoomName(roomId = DEFAULT_ROOM_ID, name = '') {
+    this.roomNames.set(roomId, name || '');
+  }
+
+  getRoomName(roomId = DEFAULT_ROOM_ID) {
+    return this.roomNames.get(roomId) || '';
   }
 
   setGroupName(groupName) {
-    this.groupName = groupName || '';
+    this.setRoomName(DEFAULT_ROOM_ID, groupName);
   }
 
   getGroupName() {
-    return this.groupName;
+    return this.getRoomName(DEFAULT_ROOM_ID);
   }
 }
 
 module.exports = {
   RoomManager,
-  USER_STATUS: [ONLINE, OFFLINE]
+  USER_STATUS: [ONLINE, OFFLINE],
+  DEFAULT_ROOM_ID
 };

package/server/routes/batch-download.js

@@ -0,0 +1,31 @@
+const express = require('express');
+
+module.exports = function registerBatchDownloadRoutes(batchDownloadService) {
+  if (!batchDownloadService) {
+    throw new Error('batchDownloadService is required');
+  }
+
+  const router = express.Router();
+
+  router.get('/batch-download/:token', (req, res) => {
+    const record = batchDownloadService.consumeDownloadToken(req.params.token);
+
+    if (!record) {
+      return res.status(410).send({
+        code: -1,
+        message: 'Download link expired or already used'
+      });
+    }
+
+    if (!batchDownloadService.streamArchive(res, record)) {
+      return res.status(404).send({
+        code: -1,
+        message: 'No downloadable attachment files'
+      });
+    }
+
+    return undefined;
+  });
+
+  return router;
+};

package/server/routes/index.js

@@ -4,11 +4,20 @@ const { trackEvent } = require('../telemetry/compat');
 const fs = require('fs');
 const fileUpload = require('express-fileupload');
 const { getCachePath } = require('../config');
-
-module.exports = function registerRoutes(app, configuredUploadsDir = getCachePath()) {
+const { BatchDownloadService } = require('../services/batch-download-service');
+
+module.exports = function registerRoutes(
+  app,
+  configuredUploadsDir = getCachePath(),
+  historyService = null,
+  batchDownloadService = null
+) {
   const uploadsDir = path.resolve(configuredUploadsDir);
   const filesDir = path.join(uploadsDir, 'files');
   const tempDir = path.join(uploadsDir, 'tmp');
+  const sharedBatchDownloadService = batchDownloadService || (
+    historyService ? new BatchDownloadService({ historyService }) : null
+  );
 
   if (!fs.existsSync(filesDir)) {
     fs.mkdirSync(filesDir, { recursive: true });
@@ -31,6 +40,9 @@ module.exports = function registerRoutes(app, configuredUploadsDir = getCachePat
   app.use(require('./session'));
   app.use(require('./qr'));
   app.use(require('./files')(uploadsDir));
+  if (sharedBatchDownloadService) {
+    app.use(require('./batch-download')(sharedBatchDownloadService));
+  }
 
   app.use(express.static(path.join(__dirname, '../../frontend/dist')));
   app.use('/files', express.static(filesDir));

package/server/routes/qr.js

@@ -37,7 +37,11 @@ router.get('/getIndexInfo', (req, res) => {
 
 router.get('/getIndexInfo2', (req, res) => {
   const homeUrl = getRequestBaseUrl(req);
-  const loginUrl = `${homeUrl}/login?receiver=${req.query.receiver || 'group_chat'}`;
+  const roomId = req.query.roomId;
+  const roomCode = req.query.code;
+  const loginUrl = roomId && roomId !== 'group_chat'
+    ? `${homeUrl}/login?roomId=${encodeURIComponent(roomId)}&code=${encodeURIComponent(roomCode || '')}`
+    : `${homeUrl}/login?receiver=${req.query.receiver || 'group_chat'}`;
 
   res.send({
     code: 0,
@@ -51,7 +55,11 @@ router.get('/getIndexInfo2', (req, res) => {
 router.get('/scanLogin', (req, res) => {
   const homeUrl = getRequestBaseUrl(req);
   const receiver = req.query.receiver || 'group_chat';
-  const targetUrl = `${homeUrl}/chat?sender=${req.query.sender}&receiver=${receiver}`;
+  const roomId = req.query.roomId;
+  const roomCode = req.query.code;
+  const targetUrl = roomId && roomId !== 'group_chat'
+    ? `${homeUrl}/chat?sender=${req.query.sender}&roomId=${encodeURIComponent(roomId)}&code=${encodeURIComponent(roomCode || '')}`
+    : `${homeUrl}/chat?sender=${req.query.sender}&receiver=${receiver}`;
 
   res.send({
     code: 0,

package/server/services/batch-download-service.js

@@ -0,0 +1,175 @@
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const yazl = require('yazl');
+
+const DOWNLOAD_TOKEN_TTL = 10 * 60 * 1000;
+
+function sanitizeZipEntryName(name) {
+  const safeName = String(name || 'download')
+    .replace(/[\u0000-\u001f\u007f]/g, '')
+    .replace(/[\\/:*?"<>|]/g, '_')
+    .replace(/^\.+/, '_')
+    .trim();
+
+  return safeName || 'download';
+}
+
+function buildUniqueZipEntryName(fileName, usedNames) {
+  const baseName = sanitizeZipEntryName(fileName);
+  const extension = path.extname(baseName);
+  const nameWithoutExtension = extension ? baseName.slice(0, -extension.length) : baseName;
+  let candidate = baseName;
+  let index = 1;
+
+  while (usedNames.has(candidate.toLowerCase())) {
+    index += 1;
+    candidate = `${nameWithoutExtension} (${index})${extension}`;
+  }
+
+  usedNames.add(candidate.toLowerCase());
+  return candidate;
+}
+
+function buildManifest(attachments, missingAttachments = []) {
+  const lines = ['ChatTransfer batch download manifest', ''];
+
+  attachments.forEach((attachment, index) => {
+    lines.push(`${index + 1}. ${attachment.zipEntryName}`);
+    lines.push(`   Message ID: ${attachment.msgId}`);
+    lines.push(`   Time: ${attachment.createTime}`);
+    lines.push(`   Sender: ${attachment.senderNickname || attachment.sender}`);
+    lines.push(`   Size: ${Number(attachment.fileSize) || 0} bytes`);
+    lines.push('');
+  });
+
+  if (missingAttachments.length > 0) {
+    lines.push('Missing files:', '');
+    missingAttachments.forEach((attachment) => {
+      lines.push(`- ${attachment.fileName || attachment.msgId}`);
+    });
+  }
+
+  return lines.join('\n');
+}
+
+class BatchDownloadService {
+  constructor({ historyService }) {
+    if (!historyService) throw new Error('historyService is required');
+    this.historyService = historyService;
+    this.tokens = new Map();
+  }
+
+  async createDownloadToken({ requester, roomId, chatType, targetUser, messageIds }) {
+    const attachments = await this.historyService.getBatchAttachments({
+      requester,
+      roomId,
+      chatType,
+      targetUser,
+      messageIds
+    });
+
+    const token = crypto.randomBytes(24).toString('hex');
+    this.tokens.set(token, {
+      attachments,
+      roomId: roomId || null,
+      expiresAt: Date.now() + DOWNLOAD_TOKEN_TTL
+    });
+    this.cleanupTokens();
+
+    return {
+      token,
+      downloadUrl: `/batch-download/${token}`,
+      expiresIn: DOWNLOAD_TOKEN_TTL
+    };
+  }
+
+  consumeDownloadToken(token) {
+    if (typeof token !== 'string') return null;
+
+    const record = this.tokens.get(token);
+    if (!record) return null;
+    this.tokens.delete(token);
+
+    if (Date.now() > record.expiresAt) {
+      this.cleanupTokens();
+      return null;
+    }
+
+    return record;
+  }
+
+  cleanupTokens() {
+    const now = Date.now();
+    for (const [token, record] of this.tokens.entries()) {
+      if (now > record.expiresAt) this.tokens.delete(token);
+    }
+  }
+
+  revokeRoom(roomId) {
+    if (!roomId) return 0;
+
+    let revoked = 0;
+    for (const [token, record] of this.tokens.entries()) {
+      if (record.roomId !== roomId) continue;
+      this.tokens.delete(token);
+      revoked += 1;
+    }
+    return revoked;
+  }
+
+  streamArchive(res, record) {
+    const usedNames = new Set();
+    const availableAttachments = record.attachments
+      .map((attachment) => ({
+        ...attachment,
+        zipEntryName: buildUniqueZipEntryName(attachment.fileName, usedNames)
+      }))
+      .filter((attachment) => {
+        try {
+          return fs.statSync(attachment.physicalPath).isFile();
+        } catch (error) {
+          return false;
+        }
+      });
+
+    const missingAttachments = record.attachments.filter((attachment) => (
+      !availableAttachments.some((item) => item.msgId === attachment.msgId)
+    ));
+
+    if (availableAttachments.length === 0) {
+      return false;
+    }
+
+    const archive = new yazl.ZipFile();
+    const zipFileName = `ChatTransfer-${new Date().toISOString().replace(/[:.]/g, '-')}.zip`;
+    res.status(200);
+    res.setHeader('Content-Type', 'application/zip');
+    res.setHeader('Content-Disposition', `attachment; filename="${zipFileName}"`);
+    archive.outputStream.pipe(res);
+    archive.outputStream.once('error', (error) => {
+      console.error('[Batch download] archive failed:', error.message);
+      res.destroy(error);
+    });
+
+    availableAttachments.forEach((attachment) => {
+      const isAlreadyCompressed = /^(image|video)\//.test(attachment.fileType || '');
+      archive.addFile(attachment.physicalPath, attachment.zipEntryName, {
+        compress: !isAlreadyCompressed
+      });
+    });
+    archive.addBuffer(
+      Buffer.from(buildManifest(availableAttachments, missingAttachments), 'utf8'),
+      'manifest.txt'
+    );
+    archive.end();
+
+    return true;
+  }
+}
+
+module.exports = {
+  BatchDownloadService,
+  buildUniqueZipEntryName,
+  sanitizeZipEntryName
+};