chattransfer 2.0.17 → 2.0.18

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-PrmIL31V.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-DDcqIagG.css">
   </head>
   <body>
     <div id="app"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chattransfer",
-  "version": "2.0.17",
+  "version": "2.0.18",
   "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/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,10 +125,10 @@ async function start(options = {}) {
     return;
   }
 
-  const app = createConfiguredApp(uploadsDir);
+  const app = createConfiguredApp(uploadsDir, historyService, batchDownloadService);
   const server = http.createServer(app);
 
-  registerSocket(server, historyService);
+  registerSocket(server, historyService, batchDownloadService);
 
   await new Promise((resolve, reject) => {
     server.once('error', reject);

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/services/batch-download-service.js

@@ -0,0 +1,161 @@
+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, chatType, targetUser, messageIds }) {
+    const attachments = await this.historyService.getBatchAttachments({
+      requester,
+      chatType,
+      targetUser,
+      messageIds
+    });
+
+    const token = crypto.randomBytes(24).toString('hex');
+    this.tokens.set(token, {
+      attachments,
+      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);
+    }
+  }
+
+  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
+};

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

@@ -5,6 +5,8 @@ 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';
 
 class MessageHistoryService {
@@ -147,6 +149,82 @@ class MessageHistoryService {
     };
   }
 
+  async queryAttachments({ requester, chatType, targetUser }) {
+    this.ensureOpened();
+
+    const conversation = 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, 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, 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;
+  }
+
   clearHistory({ requester, chatType, targetUser }) {
     this.ensureOpened();
 
@@ -411,6 +489,30 @@ 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;
   }

package/server/socket/index.js

@@ -6,10 +6,13 @@ const {
   decoratePrivateMessage
 } = require('../services/message-service');
 
-module.exports = function registerSocket(server, historyService) {
+module.exports = function registerSocket(server, historyService, batchDownloadService) {
   if (!historyService) {
     throw new Error('historyService is required');
   }
+  if (!batchDownloadService) {
+    throw new Error('batchDownloadService is required');
+  }
 
   const io = socketIo(server, {
     cors: {
@@ -190,6 +193,67 @@ module.exports = function registerSocket(server, historyService) {
       }
     });
 
+    socket.on('attachment_query', async (params = {}, ack) => {
+      if (typeof ack !== 'function') return;
+
+      try {
+        const requester = socket.username || params.requester;
+        const chatType = params.chatType || (
+          params.targetUser === 'group_chat' ? 'group' : 'private'
+        );
+        const { attachments } = await historyService.queryAttachments({
+          requester,
+          chatType,
+          targetUser: params.targetUser
+        });
+
+        ack({
+          code: 0,
+          data: {
+            attachments: attachments.map((attachment) => ({
+              msgId: attachment.msgId,
+              seq: attachment.seq,
+              sender: attachment.sender,
+              senderNickname: attachment.senderNickname,
+              msgType: attachment.msgType,
+              createTime: attachment.createTime,
+              createdAt: attachment.createdAt,
+              fileName: attachment.fileName,
+              fileSize: attachment.fileSize,
+              fileType: attachment.fileType,
+              fileUrl: attachment.fileUrl,
+              available: attachment.available
+            }))
+          }
+        });
+      } catch (error) {
+        console.error('[Attachment] query failed:', error.message);
+        ack({ code: -1, message: 'Failed to load attachments' });
+      }
+    });
+
+    socket.on('attachment_download', async (params = {}, ack) => {
+      if (typeof ack !== 'function') return;
+
+      try {
+        const requester = socket.username || params.requester;
+        const chatType = params.chatType || (
+          params.targetUser === 'group_chat' ? 'group' : 'private'
+        );
+        const data = await batchDownloadService.createDownloadToken({
+          requester,
+          chatType,
+          targetUser: params.targetUser,
+          messageIds: params.messageIds
+        });
+
+        ack({ code: 0, data });
+      } catch (error) {
+        console.error('[Attachment] download request failed:', error.message);
+        ack({ code: -1, message: error.message });
+      }
+    });
+
     socket.on('history_clear', async (params = {}, ack) => {
       if (typeof ack !== 'function') return;