@ian2018cs/agenthub 0.1.43 → 0.1.45

package/server/index.js

@@ -55,11 +55,13 @@ import usageRoutes from './routes/usage.js';
 import skillsRoutes from './routes/skills.js';
 import mcpReposRoutes from './routes/mcp-repos.js';
 import settingsRoutes from './routes/settings.js';
-import { initializeDatabase, userDb } from './database/db.js';
+import { initializeDatabase, userDb, imageDb } from './database/db.js';
 import { validateApiKey, authenticateToken, authenticateWebSocket } from './middleware/auth.js';
 import { getUserPaths, initCodexDirectories, initGeminiDirectories } from './services/user-directories.js';
 import { startUsageScanner } from './services/usage-scanner.js';
 import { startFeishuService, stopFeishuService } from './services/feishu/index.js';
+import { saveImage, getImagePath } from './services/image-storage.js';
+import { startImageCleanup } from './services/image-cleanup.js';
 
 // File system watcher for projects folder - per user
 const userWatchers = new Map(); // Map<userUuid, { watcher, clients: Set<ws> }>
@@ -382,13 +384,40 @@ app.get('/api/projects/:projectName/sessions/:sessionId/messages', authenticateT
 
         const result = await getSessionMessages(projectName, sessionId, parsedLimit, parsedOffset, req.user.uuid);
 
+        // Query persistent images for this session
+        let sessionImages = [];
+        try {
+            const images = imageDb.getImagesBySession(sessionId);
+            if (images.length > 0) {
+                // Group by upload_batch_id
+                const batchMap = new Map();
+                for (const img of images) {
+                    if (!batchMap.has(img.upload_batch_id)) {
+                        batchMap.set(img.upload_batch_id, {
+                            batchId: img.upload_batch_id,
+                            messageContent: img.message_content,
+                            createdAt: img.created_at,
+                            images: [],
+                        });
+                    }
+                    batchMap.get(img.upload_batch_id).images.push({
+                        id: img.id,
+                        name: img.original_name,
+                    });
+                }
+                sessionImages = Array.from(batchMap.values());
+            }
+        } catch (err) {
+            console.error('[WARN] Failed to load session images:', err.message);
+        }
+
         // Handle both old and new response formats
         if (Array.isArray(result)) {
             // Backward compatibility: no pagination parameters were provided
-            res.json({ messages: result });
+            res.json({ messages: result, sessionImages });
         } else {
             // New format with pagination info
-            res.json(result);
+            res.json({ ...result, sessionImages });
         }
     } catch (error) {
         res.status(500).json({ error: error.message });
@@ -729,6 +758,22 @@ function handleChatConnection(ws, userData) {
                     ...data.options,
                     userUuid,
                 }, writer);
+
+                // Associate uploaded images with the session after query completes
+                if (data.options?.uploadBatchId) {
+                    const sessionId = writer.getSessionId();
+                    if (sessionId) {
+                        try {
+                            imageDb.associateBatch(
+                                data.options.uploadBatchId,
+                                sessionId,
+                                data.command?.substring(0, 500) || ''
+                            );
+                        } catch (err) {
+                            console.error('[WARN] Failed to associate image batch:', err.message);
+                        }
+                    }
+                }
             } else if (data.type === 'abort-session') {
                 console.log('[DEBUG] Abort session request:', data.sessionId);
                 // Use Claude Agents SDK
@@ -1749,6 +1794,40 @@ Agent instructions:`;
     }
 });
 
+// Serve persistent chat images
+app.get('/api/images/:imageId', authenticateToken, (req, res) => {
+    try {
+        const imageId = parseInt(req.params.imageId, 10);
+        if (isNaN(imageId)) {
+            return res.status(400).json({ error: 'Invalid image ID' });
+        }
+
+        const image = imageDb.getImageById(imageId);
+        if (!image) {
+            return res.status(404).json({ error: 'Image not found' });
+        }
+
+        // Security: users can only access their own images
+        if (image.user_uuid !== req.user.uuid) {
+            return res.status(403).json({ error: 'Forbidden' });
+        }
+
+        const filePath = getImagePath(image.user_uuid, image.file_hash, image.file_ext);
+
+        // Check if file still exists on disk (may have been cleaned up)
+        if (!fs.existsSync(filePath)) {
+            return res.status(410).json({ error: 'Image expired' });
+        }
+
+        res.setHeader('Content-Type', image.mime_type);
+        res.setHeader('Cache-Control', 'private, max-age=86400');
+        res.sendFile(filePath);
+    } catch (error) {
+        console.error('Error serving image:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
 // Image upload endpoint
 app.post('/api/projects/:projectName/upload-images', authenticateToken, async (req, res) => {
     try {
@@ -1800,6 +1879,11 @@ app.post('/api/projects/:projectName/upload-images', authenticateToken, async (r
             }
 
             try {
+                // Generate a batch ID for this upload group
+                const { randomUUID } = await import('crypto');
+                const uploadBatchId = randomUUID();
+                const userUuid = req.user.uuid;
+
                 // Process uploaded images
                 const processedImages = await Promise.all(
                     req.files.map(async (file) => {
@@ -1811,7 +1895,23 @@ app.post('/api/projects/:projectName/upload-images', authenticateToken, async (r
                         // Clean up temp file immediately
                         await fs.unlink(file.path);
 
+                        // Persist image to file system (hash-deduplicated)
+                        const ext = file.originalname.split('.').pop()?.toLowerCase() || 'bin';
+                        const { fileHash } = await saveImage(userUuid, buffer, ext);
+
+                        // Insert DB record (session_id=NULL, will be associated later)
+                        const imageId = imageDb.insertImage({
+                            upload_batch_id: uploadBatchId,
+                            user_uuid: userUuid,
+                            original_name: file.originalname,
+                            file_hash: fileHash,
+                            file_ext: ext,
+                            file_size: file.size,
+                            mime_type: mimeType,
+                        });
+
                         return {
+                            id: Number(imageId),
                             name: file.originalname,
                             data: `data:${mimeType};base64,${base64}`,
                             size: file.size,
@@ -1820,7 +1920,7 @@ app.post('/api/projects/:projectName/upload-images', authenticateToken, async (r
                     })
                 );
 
-                res.json({ images: processedImages });
+                res.json({ images: processedImages, uploadBatchId });
             } catch (error) {
                 console.error('Error processing images:', error);
                 // Clean up any remaining files
@@ -2251,6 +2351,9 @@ async function startServer() {
             // Start usage scanner service
             startUsageScanner();
 
+            // Start image cleanup service (30-day expiry)
+            startImageCleanup();
+
             // Start Feishu integration service (if configured)
             if (process.env.FEISHU_APP_ID && process.env.FEISHU_APP_SECRET) {
                 startFeishuService().catch(err =>

package/server/services/image-cleanup.js

@@ -0,0 +1,79 @@
+/**
+ * image-cleanup.js — 定时清理过期图片
+ *
+ * - 每小时运行一次
+ * - 删除 30 天以上的图片记录和文件
+ * - 删除 24 小时以上未关联 session 的孤儿图片
+ * - 删文件前检查同 hash 是否还有其他引用（去重安全）
+ */
+
+import { imageDb } from '../database/db.js';
+import { deleteImageFile } from './image-storage.js';
+
+const CLEANUP_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
+const RETENTION_DAYS = 30;
+const ORPHAN_HOURS = 24;
+
+let cleanupInterval = null;
+
+export function startImageCleanup() {
+  console.log('[ImageCleanup] Starting image cleanup service');
+
+  // Initial cleanup after 30s
+  setTimeout(() => runCleanup(), 30000);
+
+  // Schedule periodic cleanup
+  cleanupInterval = setInterval(() => runCleanup(), CLEANUP_INTERVAL_MS);
+  console.log(`[ImageCleanup] Scheduled to run every ${CLEANUP_INTERVAL_MS / 1000 / 60} minutes`);
+}
+
+export function stopImageCleanup() {
+  if (cleanupInterval) {
+    clearInterval(cleanupInterval);
+    cleanupInterval = null;
+  }
+}
+
+async function runCleanup() {
+  try {
+    let deletedFiles = 0;
+    let deletedRecords = 0;
+
+    // 1. Clean expired images (>30 days)
+    const expiredImages = imageDb.getExpiredImages(RETENTION_DAYS);
+    if (expiredImages.length > 0) {
+      const expiredIds = expiredImages.map(img => img.id);
+
+      // Delete files only when no other records reference the same hash
+      for (const img of expiredImages) {
+        const otherRefs = imageDb.countByHash(img.user_uuid, img.file_hash, expiredIds);
+        if (otherRefs === 0) {
+          await deleteImageFile(img.user_uuid, img.file_hash, img.file_ext);
+          deletedFiles++;
+        }
+      }
+
+      imageDb.deleteImagesByIds(expiredIds);
+      deletedRecords += expiredIds.length;
+    }
+
+    // 2. Clean orphaned uploads (session_id IS NULL, >24h)
+    const orphaned = imageDb.deleteOrphanedImages(ORPHAN_HOURS);
+    if (orphaned.length > 0) {
+      for (const img of orphaned) {
+        const otherRefs = imageDb.countByHash(img.user_uuid, img.file_hash, [img.id]);
+        if (otherRefs === 0) {
+          await deleteImageFile(img.user_uuid, img.file_hash, img.file_ext);
+          deletedFiles++;
+        }
+      }
+      deletedRecords += orphaned.length;
+    }
+
+    if (deletedRecords > 0) {
+      console.log(`[ImageCleanup] Cleaned up ${deletedRecords} records, ${deletedFiles} files`);
+    }
+  } catch (error) {
+    console.error('[ImageCleanup] Error during cleanup:', error);
+  }
+}

package/server/services/image-storage.js

@@ -0,0 +1,78 @@
+/**
+ * image-storage.js — 图片文件系统持久化存储
+ *
+ * 存储路径: data/images/{userUuid}/{hash前2字符}/{sha256hash}.{ext}
+ * 按内容 hash 去重：同一用户同内容图片只存一份文件。
+ */
+
+import crypto from 'crypto';
+import { promises as fs } from 'fs';
+import path from 'path';
+
+const DATA_DIR = process.env.DATA_DIR || path.join(process.cwd(), 'data');
+const IMAGES_DIR = path.join(DATA_DIR, 'images');
+
+/**
+ * 计算 buffer 的 SHA-256 hex
+ */
+function computeHash(buffer) {
+  return crypto.createHash('sha256').update(buffer).digest('hex');
+}
+
+/**
+ * 构建图片文件的绝对路径
+ */
+function buildImagePath(userUuid, fileHash, fileExt) {
+  const prefix = fileHash.substring(0, 2);
+  return path.join(IMAGES_DIR, userUuid, prefix, `${fileHash}.${fileExt}`);
+}
+
+/**
+ * 保存图片到文件系统（按内容 hash 去重）
+ * @param {string} userUuid
+ * @param {Buffer} buffer - 图片原始二进制
+ * @param {string} ext - 扩展名（不含点，如 'png'）
+ * @returns {Promise<{fileHash: string, alreadyExisted: boolean}>}
+ */
+async function saveImage(userUuid, buffer, ext) {
+  const fileHash = computeHash(buffer);
+  const filePath = buildImagePath(userUuid, fileHash, ext);
+
+  try {
+    await fs.access(filePath);
+    return { fileHash, alreadyExisted: true };
+  } catch {
+    // 文件不存在，写入
+  }
+
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, buffer);
+  return { fileHash, alreadyExisted: false };
+}
+
+/**
+ * 获取图片文件的绝对路径
+ */
+function getImagePath(userUuid, fileHash, fileExt) {
+  return buildImagePath(userUuid, fileHash, fileExt);
+}
+
+/**
+ * 删除图片文件（忽略不存在的情况）
+ */
+async function deleteImageFile(userUuid, fileHash, fileExt) {
+  const filePath = buildImagePath(userUuid, fileHash, fileExt);
+  try {
+    await fs.unlink(filePath);
+  } catch (err) {
+    if (err.code !== 'ENOENT') throw err;
+  }
+}
+
+export {
+  IMAGES_DIR,
+  computeHash,
+  saveImage,
+  getImagePath,
+  deleteImageFile,
+};