chattransfer 0.0.0-stage → 2.0.10

package/server/socket/index.js

@@ -0,0 +1,232 @@
+const socketIo = require('socket.io');
+const roomManager = require('./session-manager');
+const { trackEvent } = require('../telemetry/compat');
+const {
+  decorateGroupMessage,
+  decoratePrivateMessage
+} = require('../services/message-service');
+
+module.exports = function registerSocket(server, historyService) {
+  if (!historyService) {
+    throw new Error('historyService is required');
+  }
+
+  const io = socketIo(server, {
+    cors: {
+      origin: true,
+      methods: ['GET', 'POST']
+    },
+    pingTimeout: 30000,
+    pingInterval: 25000
+  });
+  const chatRoom = 'group-chat';
+
+  const getClientIp = (socket) => {
+    const address = socket.handshake.address || socket.request.connection.remoteAddress;
+
+    return address ? address.replace(/^::ffff:/, '') : '';
+  };
+
+  const broadcastUserList = () => {
+    io.to(chatRoom).emit('user_list_updated', {
+      users: roomManager.listUsers()
+    });
+  };
+
+  const trackMessage = (type, direction, params, socket) => {
+    trackEvent('message_action', {
+      chat_type: type,
+      msg_type: params.msgType || 'TEXT',
+      direction,
+      sender: params.sender,
+      visitor_id: params.visitorId || 'unknown-visitor',
+      user_agent: socket.handshake.headers['user-agent']
+    });
+  };
+
+  const persistMessage = async (message) => {
+    try {
+      return { message: await historyService.saveMessage(message), error: null };
+    } catch (error) {
+      console.error('[History] save message failed:', error.message);
+      return { message, error };
+    }
+  };
+
+  const broadcastHistoryCleared = ({ chatType, targetUser, sessionId }, sourceSocket) => {
+    const payload = { chatType, targetUser, sessionId };
+
+    if (chatType === 'group') {
+      io.to(chatRoom).emit('history_cleared', payload);
+      return;
+    }
+
+    sourceSocket.emit('history_cleared', payload);
+    const receiver = roomManager.getUser(targetUser);
+    if (receiver && receiver.status === roomManager.getOnline()) {
+      io.to(receiver.socketId).emit('history_cleared', payload);
+    }
+  };
+
+  io.on('connection', (socket) => {
+    console.log(`[Socket] connected: ${socket.id}`);
+
+    socket.on('login', ({ uid } = {}) => {
+      console.log(`[Socket] login: ${uid}`);
+    });
+
+    socket.on('online', (username) => {
+      console.log(`[Socket] online: ${username} ${socket.id}`);
+      socket.username = username;
+      socket.join(chatRoom);
+      roomManager.setOnline({
+        username,
+        socketId: socket.id,
+        ip: getClientIp(socket)
+      });
+      broadcastUserList();
+    });
+
+    socket.on('private_chat', async (params, ack) => {
+      const decorated = decoratePrivateMessage(params, roomManager.getUser(params.sender));
+      const { message: savedMessage, error } = await persistMessage(decorated);
+
+      if (typeof ack === 'function') {
+        ack(error ? { ...decorated, status: 'failed', error: 'Message persistence failed' } : savedMessage);
+      }
+
+      if (error) return;
+
+      trackMessage('private', 'send', decorated, socket);
+
+      const receiver = roomManager.getUser(savedMessage.receiver);
+
+      if (receiver && receiver.status === roomManager.getOnline()) {
+        socket.to(receiver.socketId).emit('reply_private_chat', savedMessage);
+
+        trackEvent('message_action', {
+          chat_type: 'private',
+          msg_type: decorated.msgType || 'TEXT',
+          direction: 'receive',
+          receiver: decorated.receiver,
+          user_agent: socket.handshake.headers['user-agent']
+        });
+      } else {
+        console.log(`${decorated.receiver} is offline`);
+      }
+    });
+
+    socket.on('group_online', (username, nickname) => {
+      console.log(`[Socket] group_online: ${username} ${socket.id} nickname=${nickname}`);
+      socket.join(chatRoom);
+      socket.username = username;
+      roomManager.setOnline({
+        username,
+        socketId: socket.id,
+        nickname,
+        ip: getClientIp(socket)
+      });
+      socket.emit('group_name_updated', {
+        groupName: roomManager.getGroupName(),
+        updatedBy: ''
+      });
+      broadcastUserList();
+    });
+
+    socket.on('update_nickname', ({ sender, nickname }) => {
+      roomManager.setNickname(sender, nickname);
+      broadcastUserList();
+    });
+
+    socket.on('update_group_name', ({ groupName, updatedBy }) => {
+      roomManager.setGroupName(groupName);
+      io.to(chatRoom).emit('group_name_updated', {
+        groupName: roomManager.getGroupName(),
+        updatedBy: updatedBy || ''
+      });
+    });
+
+    socket.on('group_chat', async (params, ack) => {
+      const decorated = decorateGroupMessage(params, roomManager.getUser(params.sender));
+      const { message: savedMessage, error } = await persistMessage(decorated);
+
+      if (typeof ack === 'function') {
+        ack(error ? { ...decorated, status: 'failed', error: 'Message persistence failed' } : savedMessage);
+      }
+
+      if (error) return;
+
+      trackMessage('group', 'send', decorated, socket);
+      socket.broadcast.to(chatRoom).emit('reply_group_chat', savedMessage);
+
+      trackEvent('message_action', {
+        chat_type: 'group',
+        msg_type: decorated.msgType || 'TEXT',
+        direction: 'broadcast',
+        user_agent: socket.handshake.headers['user-agent']
+      });
+    });
+
+    socket.on('history_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 data = await historyService.queryHistory({
+          requester,
+          chatType,
+          targetUser: params.targetUser,
+          cursor: params.cursor,
+          limit: params.limit
+        });
+
+        ack({ code: 0, data });
+      } catch (error) {
+        console.error('[History] query failed:', error.message);
+        ack({ code: -1, message: 'Failed to load history' });
+      }
+    });
+
+    socket.on('history_clear', 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 conversation = historyService.getConversation({
+          requester,
+          chatType,
+          targetUser: params.targetUser
+        });
+        const data = await historyService.clearHistory({
+          requester,
+          chatType,
+          targetUser: params.targetUser
+        });
+
+        broadcastHistoryCleared({
+          chatType,
+          targetUser: params.targetUser,
+          sessionId: conversation.sessionId
+        }, socket);
+        ack({ code: 0, data });
+      } catch (error) {
+        console.error('[History] clear failed:', error.message);
+        ack({ code: -1, message: 'Failed to clear history' });
+      }
+    });
+
+    socket.on('disconnect', () => {
+      console.log(`[Socket] disconnect: ${socket.username || 'unknown'} ${socket.id}`);
+      roomManager.setOffline(socket.username);
+      broadcastUserList();
+    });
+  });
+
+  return io;
+};

package/server/socket/session-manager.js

@@ -0,0 +1,3 @@
+const { RoomManager } = require('../room-manager');
+
+module.exports = new RoomManager();

package/server/telemetry/amplitude-provider.js

@@ -0,0 +1,17 @@
+const axios = require('axios');
+
+class AmplitudeProvider {
+  constructor({ apiKey, endpoint }) {
+    this.apiKey = apiKey;
+    this.endpoint = endpoint || 'https://api2.amplitude.com/2/httpapi';
+  }
+
+  async track(event) {
+    await axios.post(this.endpoint, {
+      api_key: this.apiKey,
+      events: [event]
+    });
+  }
+}
+
+module.exports = AmplitudeProvider;

package/server/telemetry/compat.js

@@ -0,0 +1,17 @@
+const { loadConfig } = require('../config/loader');
+const { createTelemetryProvider } = require('./index');
+
+const provider = createTelemetryProvider(loadConfig());
+
+async function trackEvent(eventType, eventProperties = {}, customUserId = null) {
+  return provider.track({
+    event_type: eventType,
+    event_properties: eventProperties,
+    user_id: customUserId || undefined,
+    time: Date.now()
+  });
+}
+
+module.exports = {
+  trackEvent
+};

package/server/telemetry/index.js

@@ -0,0 +1,26 @@
+const { loadConfig } = require('../config/loader');
+const AmplitudeProvider = require('./amplitude-provider');
+const NoopProvider = require('./noop-provider');
+
+const providers = {
+  amplitude: AmplitudeProvider
+};
+
+function createTelemetryProvider(config = loadConfig()) {
+  const analytics = config.analytics || {};
+  const enabled = analytics.enabled && Boolean(analytics.apiKey);
+  const Provider = providers[analytics.provider || 'amplitude'];
+
+  if (!enabled || !Provider) {
+    return new NoopProvider();
+  }
+
+  return new Provider({
+    apiKey: analytics.apiKey,
+    endpoint: analytics.endpoint
+  });
+}
+
+module.exports = {
+  createTelemetryProvider
+};

package/server/telemetry/noop-provider.js

@@ -0,0 +1,7 @@
+class NoopProvider {
+  async track() {
+    return Promise.resolve();
+  }
+}
+
+module.exports = NoopProvider;

package/server/tool.js

@@ -0,0 +1,71 @@
+const os = require('os');
+const path = require('path');
+const { execFile } = require('child_process');
+var qr = require('qr-image');
+module.exports.getIPAddress = function () {
+  var interfaces = os.networkInterfaces();
+  for (var devName in interfaces) {
+    var iface = interfaces[devName];
+    for (var i = 0; i < iface.length; i++) {
+      var alias = iface[i];
+      if (alias.family === 'IPv4' && alias.address !== '127.0.0.1' && !alias.internal) {
+        return alias.address;
+      }
+    }
+  }
+}
+
+//打开默认浏览器
+module.exports.openDefaultBrowser = function (url, callback = () => {}) {
+  console.log("使用浏览器打开首页");
+  switch (process.platform) {
+    case "darwin":
+      execFile('open', [url], callback);
+      break;
+    case "win32":
+      execFile('cmd.exe', ['/c', 'start', '', url], callback);
+      break;
+    default:
+      execFile('xdg-open', [url], callback);
+  }
+}
+
+module.exports.getAppWritableRoot = function () {
+  if (process.pkg) {
+    // Pkg环境：使用可执行文件所在目录（可写）
+    console.log('Running in pkg environment');
+    return path.dirname(process.execPath);
+  } else {
+    // 开发环境：使用项目根目录（server目录的上级）
+    console.log('Running in development environment');
+    return path.join(__dirname, '..');
+  }
+}
+module.exports.initCachePath = function (cachePath,callback) {
+  console.log('开始初始化缓存目录');
+
+  // 如果不存在则创建，都则不创建
+  let fs = require('fs');
+  if(fs.existsSync(cachePath)){
+    console.log('缓存目录已存在，无需创建');
+    callback();
+    return;
+  };
+  fs.mkdir(cachePath, { recursive: true }, (err) => {
+    if (err) {
+      console.log('出错:',err)
+    } else {
+      console.log("初始化缓存目录成功")
+    }
+    callback(err);
+  })
+
+}
+
+module.exports.homeDir = os.userInfo().homedir;
+module.exports.geneQR = function(url){
+  var img_string = qr.imageSync(url, { type: 'png' ,size:10});
+  const base64Str = 'data:image/png;base64,' + Buffer.from(img_string, 'utf8').toString('base64')
+  return base64Str;
+}
+

package/server/utils/app-root.js

@@ -0,0 +1,11 @@
+const path = require('path');
+
+function getAppWritableRoot() {
+  return process.pkg
+    ? path.dirname(process.execPath)
+    : path.join(__dirname, '..', '..');
+}
+
+module.exports = {
+  getAppWritableRoot
+};

package/server/utils/network.js

@@ -0,0 +1,21 @@
+const os = require('os');
+
+function getIPAddress() {
+  const interfaces = os.networkInterfaces();
+
+  for (const interfaceName of Object.keys(interfaces)) {
+    const addresses = interfaces[interfaceName] || [];
+
+    for (const address of addresses) {
+      if (address.family === 'IPv4' && address.address !== '127.0.0.1' && !address.internal) {
+        return address.address;
+      }
+    }
+  }
+
+  return undefined;
+}
+
+module.exports = {
+  getIPAddress
+};

package/server/utils/request-url.js

@@ -0,0 +1,15 @@
+function getRequestBaseUrl(req) {
+  const publicUrl = process.env.CHATTRANSFER_PUBLIC_URL;
+
+  if (publicUrl) {
+    return publicUrl.replace(/\/$/, '');
+  }
+
+  const forwardedProtocol = req.headers['x-forwarded-proto'];
+  const protocol = forwardedProtocol || req.protocol;
+  return `${protocol}://${req.headers.host}`;
+}
+
+module.exports = {
+  getRequestBaseUrl
+};

package/server/utils/runtime-options.js

@@ -0,0 +1,88 @@
+const path = require('path');
+
+const DEFAULT_HOST = '0.0.0.0';
+const DEFAULT_PORT = 55555;
+
+function isTruthy(value) {
+  return ['1', 'true', 'yes', 'on'].includes(String(value).toLowerCase());
+}
+
+function parsePort(value, source) {
+  const port = Number(value);
+
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`Invalid ${source}: ${value}`);
+  }
+
+  return port;
+}
+
+function normalizePublicUrl(value) {
+  if (!value) return null;
+
+  try {
+    const url = new URL(value);
+
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+      throw new Error('Invalid public URL protocol');
+    }
+
+    const basePath = url.pathname === '/' ? '' : url.pathname.replace(/\/$/, '');
+    return `${url.protocol}//${url.host}${basePath}`;
+  } catch (error) {
+    throw new Error(`Invalid public URL: ${value}`);
+  }
+}
+
+function shouldOpenBrowser({ env = process.env, explicitValue, platform = process.platform } = {}) {
+  if (typeof explicitValue === 'boolean') {
+    return explicitValue;
+  }
+
+  if (env.CHATTRANSFER_NO_BROWSER !== undefined) {
+    return !isTruthy(env.CHATTRANSFER_NO_BROWSER);
+  }
+
+  if (platform === 'linux' && !env.DISPLAY && !env.WAYLAND_DISPLAY) {
+    return false;
+  }
+
+  return true;
+}
+
+function resolveStartOptions(overrides = {}, env = process.env) {
+  const portValue = overrides.port ?? env.CHATTRANSFER_PORT;
+  const port = portValue === undefined || portValue === null || portValue === ''
+    ? DEFAULT_PORT
+    : parsePort(portValue, 'port');
+  const host = overrides.host ?? env.CHATTRANSFER_HOST ?? DEFAULT_HOST;
+  const dataDir = overrides.dataDir ?? env.CHATTRANSFER_DATA_DIR;
+  const publicUrl = normalizePublicUrl(overrides.publicUrl ?? env.CHATTRANSFER_PUBLIC_URL);
+  const openBrowser = shouldOpenBrowser({
+    env,
+    explicitValue: overrides.openBrowser
+  });
+
+  if (typeof host !== 'string' || !host.trim()) {
+    throw new Error('Invalid host');
+  }
+
+  return {
+    host: host.trim(),
+    port,
+    explicitPort: overrides.port !== undefined || env.CHATTRANSFER_PORT !== undefined,
+    dataDir: dataDir ? path.resolve(String(dataDir)) : null,
+    publicUrl,
+    openBrowser
+  };
+}
+
+module.exports = {
+  DEFAULT_HOST,
+  DEFAULT_PORT,
+  isTruthy,
+  normalizePublicUrl,
+  parsePort,
+  resolveStartOptions,
+  shouldOpenBrowser
+};

package/server/utils/runtime-paths.js

@@ -0,0 +1,87 @@
+const os = require('os');
+const path = require('path');
+
+const RUNTIMES = new Set(['development', 'npm', 'pkg', 'docker']);
+
+function getRuntimeName() {
+  const runtime = process.env.CHATTRANSFER_RUNTIME;
+
+  if (runtime && RUNTIMES.has(runtime)) {
+    return runtime;
+  }
+
+  return process.pkg ? 'pkg' : 'development';
+}
+
+function getUserDataDir() {
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Application Support', 'ChatTransfer');
+  }
+
+  if (process.platform === 'win32') {
+    const appData = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
+    return path.join(appData, 'ChatTransfer');
+  }
+
+  const xdgDataHome = process.env.XDG_DATA_HOME || path.join(os.homedir(), '.local', 'share');
+  return path.join(xdgDataHome, 'ChatTransfer');
+}
+
+function getDefaultDataDir() {
+  const explicitDataDir = process.env.CHATTRANSFER_DATA_DIR;
+
+  if (explicitDataDir) {
+    return path.resolve(explicitDataDir);
+  }
+
+  if (process.env.CHATTRANSFER_CONFIG_FILE) {
+    return path.dirname(path.resolve(process.env.CHATTRANSFER_CONFIG_FILE));
+  }
+
+  const runtime = getRuntimeName();
+
+  if (runtime === 'pkg') {
+    return path.dirname(process.execPath);
+  }
+
+  if (runtime === 'npm' || runtime === 'docker') {
+    return getUserDataDir();
+  }
+
+  return path.join(__dirname, '..', '..');
+}
+
+function getConfigFile() {
+  return process.env.CHATTRANSFER_CONFIG_FILE
+    ? path.resolve(process.env.CHATTRANSFER_CONFIG_FILE)
+    : path.join(getDefaultDataDir(), 'config.json');
+}
+
+function getTelemetryConfigFile() {
+  return path.join(getDefaultDataDir(), 'config', 'local.json');
+}
+
+function getDatabaseFile() {
+  const runtime = getRuntimeName();
+
+  if (runtime === 'npm' || runtime === 'docker') {
+    return path.join(getDefaultDataDir(), 'chattransfer.db');
+  }
+
+  return path.join(getDefaultDataDir(), 'uploads', 'history', 'chattransfer.db');
+}
+
+function usesIndependentDatabaseFile() {
+  const runtime = getRuntimeName();
+  return runtime === 'npm' || runtime === 'docker';
+}
+
+module.exports = {
+  getConfigFile,
+  getDatabaseFile,
+  getDefaultDataDir,
+  getRuntimeName,
+  getTelemetryConfigFile,
+  getUserDataDir,
+  usesIndependentDatabaseFile
+};