@cloudcli-ai/cloudcli 1.36.0 → 1.36.2

package/server/claude-sdk.js

@@ -19,6 +19,7 @@ import path from 'path';
 
 import { query } from '@anthropic-ai/claude-agent-sdk';
 
+import { buildClaudeUserContent, normalizeImageDescriptors } from './shared/image-attachments.js';
 import { CLAUDE_FALLBACK_MODELS } from './modules/providers/list/claude/claude-models.provider.js';
 import { providerModelsService } from './modules/providers/services/provider-models.service.js';
 import { resolveClaudeCodeExecutablePath } from './shared/claude-cli-path.js';
@@ -236,16 +237,13 @@ function mapCliOptionsToSDK(options = {}) {
  * Adds a session to the active sessions map
  * @param {string} sessionId - Session identifier
  * @param {Object} queryInstance - SDK query instance
- * @param {Array<string>} tempImagePaths - Temp image file paths for cleanup
- * @param {string} tempDir - Temp directory for cleanup
+ * @param {Object} writer - WebSocket writer for reconnect support
  */
-function addSession(sessionId, queryInstance, tempImagePaths = [], tempDir = null, writer = null) {
+function addSession(sessionId, queryInstance, writer = null) {
   activeSessions.set(sessionId, {
     instance: queryInstance,
     startTime: Date.now(),
     status: 'active',
-    tempImagePaths,
-    tempDir,
     writer
   });
 }
@@ -364,90 +362,35 @@ function extractTokenBudget(sdkMessage) {
 }
 
 /**
- * Handles image processing for SDK queries
- * Saves base64 images to temporary files and returns modified prompt with file paths
- * @param {string} command - Original user prompt
- * @param {Array} images - Array of image objects with base64 data
- * @param {string} cwd - Working directory for temp file creation
- * @returns {Promise<Object>} {modifiedCommand, tempImagePaths, tempDir}
- */
-async function handleImages(command, images, cwd) {
-  const tempImagePaths = [];
-  let tempDir = null;
-
-  if (!images || images.length === 0) {
-    return { modifiedCommand: command, tempImagePaths, tempDir };
-  }
-
-  try {
-    // Create temp directory in the project directory
-    const workingDir = cwd || process.cwd();
-    tempDir = path.join(workingDir, '.tmp', 'images', Date.now().toString());
-    await fs.mkdir(tempDir, { recursive: true });
-
-    // Save each image to a temp file
-    for (const [index, image] of images.entries()) {
-      // Extract base64 data and mime type
-      const matches = image.data.match(/^data:([^;]+);base64,(.+)$/);
-      if (!matches) {
-        console.error('Invalid image data format');
-        continue;
-      }
-
-      const [, mimeType, base64Data] = matches;
-      const extension = mimeType.split('/')[1] || 'png';
-      const filename = `image_${index}.${extension}`;
-      const filepath = path.join(tempDir, filename);
-
-      // Write base64 data to file
-      await fs.writeFile(filepath, Buffer.from(base64Data, 'base64'));
-      tempImagePaths.push(filepath);
-    }
-
-    // Include the full image paths in the prompt
-    let modifiedCommand = command;
-    if (tempImagePaths.length > 0 && command && command.trim()) {
-      const imageNote = `\n\n[Images provided at the following paths:]\n${tempImagePaths.map((p, i) => `${i + 1}. ${p}`).join('\n')}`;
-      modifiedCommand = command + imageNote;
-    }
-
-    // Images processed
-    return { modifiedCommand, tempImagePaths, tempDir };
-  } catch (error) {
-    console.error('Error processing images for SDK:', error);
-    return { modifiedCommand: command, tempImagePaths, tempDir };
-  }
-}
-
-/**
- * Cleans up temporary image files
- * @param {Array<string>} tempImagePaths - Array of temp file paths to delete
- * @param {string} tempDir - Temp directory to remove
+ * Builds the SDK `prompt` payload for one turn.
+ *
+ * Plain text turns pass the string through unchanged. Turns with image
+ * attachments use the SDK's streaming-input mode: a single SDKUserMessage
+ * whose content carries the prompt text plus one base64 `image` block per
+ * attachment (read from the global `~/.cloudcli/assets` folder).
+ *
+ * @param {string} command - User prompt
+ * @param {Array} images - Image descriptors ({ path, name?, mimeType? })
+ * @param {string} cwd - Project working directory image paths resolve against
+ * @returns {Promise<string|AsyncIterable>} SDK prompt payload
  */
-async function cleanupTempFiles(tempImagePaths, tempDir) {
-  if (!tempImagePaths || tempImagePaths.length === 0) {
-    return;
+async function buildPromptPayload(command, images, cwd) {
+  if (normalizeImageDescriptors(images).length === 0) {
+    return command;
   }
 
-  try {
-    // Delete individual temp files
-    for (const imagePath of tempImagePaths) {
-      await fs.unlink(imagePath).catch(err =>
-        console.error(`Failed to delete temp image ${imagePath}:`, err)
-      );
-    }
-
-    // Delete temp directory
-    if (tempDir) {
-      await fs.rm(tempDir, { recursive: true, force: true }).catch(err =>
-        console.error(`Failed to delete temp directory ${tempDir}:`, err)
-      );
-    }
-
-    // Temp files cleaned
-  } catch (error) {
-    console.error('Error during temp file cleanup:', error);
-  }
+  const content = await buildClaudeUserContent(command, images, cwd);
+  return (async function* () {
+    yield {
+      type: 'user',
+      message: {
+        role: 'user',
+        content
+      },
+      parent_tool_use_id: null,
+      timestamp: new Date().toISOString()
+    };
+  })();
 }
 
 /**
@@ -518,8 +461,6 @@ async function queryClaudeSDK(command, options = {}, ws) {
   const { sessionId, sessionSummary } = options;
   let capturedSessionId = sessionId;
   let sessionCreatedSent = false;
-  let tempImagePaths = [];
-  let tempDir = null;
 
   const emitNotification = (event) => {
     notifyUserIfEnabled({
@@ -553,10 +494,10 @@ async function queryClaudeSDK(command, options = {}, ws) {
       sdkOptions.mcpServers = mcpServers;
     }
 
-    const imageResult = await handleImages(command, options.images, options.cwd);
-    const finalCommand = imageResult.modifiedCommand;
-    tempImagePaths = imageResult.tempImagePaths;
-    tempDir = imageResult.tempDir;
+    // Turns with image attachments switch to streaming input so the images
+    // ride along as real content blocks. Built per query attempt because an
+    // async generator cannot be replayed once consumed.
+    const createPrompt = () => buildPromptPayload(command, options.images, options.cwd);
 
     sdkOptions.hooks = {
       Notification: [{
@@ -663,7 +604,7 @@ async function queryClaudeSDK(command, options = {}, ws) {
     let queryInstance;
     try {
       queryInstance = query({
-        prompt: finalCommand,
+        prompt: await createPrompt(),
         options: sdkOptions
       });
     } catch (hookError) {
@@ -672,7 +613,7 @@ async function queryClaudeSDK(command, options = {}, ws) {
       console.warn('Failed to initialize Claude query with hooks, retrying without hooks:', hookError?.message || hookError);
       delete sdkOptions.hooks;
       queryInstance = query({
-        prompt: finalCommand,
+        prompt: await createPrompt(),
         options: sdkOptions
       });
     }
@@ -686,7 +627,7 @@ async function queryClaudeSDK(command, options = {}, ws) {
 
     // Track the query instance for abort capability
     if (capturedSessionId) {
-      addSession(capturedSessionId, queryInstance, tempImagePaths, tempDir, ws);
+      addSession(capturedSessionId, queryInstance, ws);
     }
 
     // Process streaming messages
@@ -696,7 +637,7 @@ async function queryClaudeSDK(command, options = {}, ws) {
       if (message.session_id && !capturedSessionId) {
 
         capturedSessionId = message.session_id;
-        addSession(capturedSessionId, queryInstance, tempImagePaths, tempDir, ws);
+        addSession(capturedSessionId, queryInstance, ws);
 
         // Set session ID on writer
         if (ws.setSessionId && typeof ws.setSessionId === 'function') {
@@ -738,9 +679,6 @@ async function queryClaudeSDK(command, options = {}, ws) {
       removeSession(capturedSessionId);
     }
 
-    // Clean up temporary image files
-    await cleanupTempFiles(tempImagePaths, tempDir);
-
     // Send the terminal completion event — skipped for aborted runs, whose
     // terminal `complete` (aborted: true) was already sent by abort-session.
     const wasAborted = capturedSessionId ? abortedSessionIds.delete(capturedSessionId) : false;
@@ -764,9 +702,6 @@ async function queryClaudeSDK(command, options = {}, ws) {
       removeSession(capturedSessionId);
     }
 
-    // Clean up temporary image files on error
-    await cleanupTempFiles(tempImagePaths, tempDir);
-
     const wasAborted = capturedSessionId ? abortedSessionIds.delete(capturedSessionId) : false;
     if (wasAborted) {
       // The abort already produced the terminal complete; a generator throw
@@ -819,9 +754,6 @@ async function abortClaudeSDKSession(sessionId) {
     // Update session status
     session.status = 'aborted';
 
-    // Clean up temporary image files
-    await cleanupTempFiles(session.tempImagePaths, session.tempDir);
-
     // Clean up session
     removeSession(sessionId);
 

package/server/cli.js

@@ -256,13 +256,11 @@ async function updatePackage() {
 const SANDBOX_TEMPLATES = {
     claude: 'docker.io/cloudcliai/sandbox:claude-code',
     codex: 'docker.io/cloudcliai/sandbox:codex',
-    gemini: 'docker.io/cloudcliai/sandbox:gemini',
 };
 
 const SANDBOX_SECRETS = {
     claude: 'anthropic',
     codex: 'openai',
-    gemini: 'google',
 };
 
 function parseSandboxArgs(args) {
@@ -338,7 +336,7 @@ Subcommands:
   ${c.bright('help')}         Show this help
 
 Options:
-  -a, --agent <agent>       Agent to use: claude, codex, gemini (default: claude)
+  -a, --agent <agent>       Agent to use: claude, codex (default: claude)
   -n, --name <name>         Sandbox name (default: derived from workspace folder)
   -t, --template <image>    Custom template image
   -e, --env <KEY=VALUE>     Set environment variable (repeatable)
@@ -359,7 +357,6 @@ Prerequisites:
        sbx login
        sbx secret set -g anthropic   # for Claude
        sbx secret set -g openai      # for Codex
-       sbx secret set -g google      # for Gemini
 
 Advanced usage:
   For branch mode, multiple workspaces, memory limits, network policies,

package/server/cursor-cli.js

@@ -1,13 +1,15 @@
-import { spawn } from 'child_process';
 import crossSpawn from 'cross-spawn';
+
+import { appendImagesInputTag } from './shared/image-attachments.js';
 import { notifyRunFailed, notifyRunStopped } from './services/notification-orchestrator.js';
 import { sessionsService } from './modules/providers/services/sessions.service.js';
 import { providerAuthService } from './modules/providers/services/provider-auth.service.js';
 import { providerModelsService } from './modules/providers/services/provider-models.service.js';
-import { createCompleteMessage, createNormalizedMessage } from './shared/utils.js';
+import { createCompleteMessage, createNormalizedMessage, flattenPromptForWindowsShell } from './shared/utils.js';
 
-// Use cross-spawn on Windows for better command execution
-const spawnFunction = process.platform === 'win32' ? crossSpawn : spawn;
+// cross-spawn resolves .cmd shims/PATHEXT on Windows and delegates to
+// child_process.spawn everywhere else.
+const spawnFunction = crossSpawn;
 
 let activeCursorProcesses = new Map(); // Track active processes by session ID
 
@@ -28,7 +30,7 @@ function isWorkspaceTrustPrompt(text = '') {
 
 async function spawnCursor(command, options = {}, ws) {
   return new Promise(async (resolve, reject) => {
-    const { sessionId, projectPath, cwd, resume, toolsSettings, skipPermissions, model, sessionSummary } = options;
+    const { sessionId, projectPath, cwd, toolsSettings, skipPermissions, model, sessionSummary, images } = options;
     const resolvedModel = await providerModelsService.resolveResumeModel('cursor', sessionId, model);
     let capturedSessionId = sessionId; // Track session ID throughout the process
     let sessionCreatedSent = false; // Track if we've already sent session-created event
@@ -55,8 +57,12 @@ async function spawnCursor(command, options = {}, ws) {
     }
 
     if (command && command.trim()) {
-      // Provide a prompt (works for both new and resumed sessions)
-      baseArgs.push('-p', command);
+      // Provide a prompt (works for both new and resumed sessions). Image
+      // attachments ride along as an <images_input> path list appended to the
+      // prompt; the session history reader strips the tag back out for display.
+      // cursor-agent is a .cmd shim on Windows, so the whole argument must be
+      // newline-free or cmd.exe silently truncates it at the first newline.
+      baseArgs.push('-p', flattenPromptForWindowsShell(appendImagesInputTag(command, images)));
 
       // Model overrides are applied to both new and resumed sessions so a
       // session-scoped change request can take effect on the next turn.
@@ -71,7 +77,6 @@ async function spawnCursor(command, options = {}, ws) {
     // Add skip permissions flag if enabled
     if (skipPermissions || settings.skipPermissions) {
       baseArgs.push('-f');
-      console.log('Using -f flag (skip permissions)');
     }
 
     // Use cwd (actual project directory) instead of projectPath
@@ -126,10 +131,6 @@ async function spawnCursor(command, options = {}, ws) {
         console.log('Retrying Cursor CLI with --trust after workspace trust prompt');
       }
 
-      console.log('Spawning Cursor CLI:', 'cursor-agent', args.join(' '));
-      console.log('Working directory:', workingDir);
-      console.log('Session info - Input sessionId:', sessionId, 'Resume:', resume);
-
       const cursorProcess = spawnFunction('cursor-agent', args, {
         cwd: workingDir,
         stdio: ['pipe', 'pipe', 'pipe'],

package/server/index.js

@@ -5,8 +5,10 @@ import fs, { promises as fsPromises } from 'fs';
 import path from 'path';
 import os from 'os';
 import http from 'http';
-import { spawn } from 'child_process';
 
+// cross-spawn is a drop-in for child_process.spawn that resolves .cmd
+// shims/PATHEXT on Windows and delegates to the native spawn elsewhere.
+import spawn from 'cross-spawn';
 import express from 'express';
 import cors from 'cors';
 import mime from 'mime-types';
@@ -33,15 +35,10 @@ import {
     queryCodex,
     abortCodexSession,
 } from './openai-codex.js';
-import {
-    spawnGemini,
-    abortGeminiSession,
-} from './gemini-cli.js';
 import {
     spawnOpenCode,
     abortOpenCodeSession,
 } from './opencode-cli.js';
-import sessionManager from './sessionManager.js';
 import {
     stripAnsiSequences,
     normalizeDetectedUrl,
@@ -59,11 +56,11 @@ import agentRoutes from './routes/agent.js';
 import projectModuleRoutes from './modules/projects/projects.routes.js';
 import notificationRoutes from './modules/notifications/notifications.routes.js';
 import userRoutes from './routes/user.js';
-import geminiRoutes from './routes/gemini.js';
 import pluginsRoutes from './routes/plugins.js';
 import providerRoutes from './modules/providers/provider.routes.js';
 import voiceRoutes from './voice-proxy.js';
 import browserUseRoutes from './modules/browser-use/browser-use.routes.js';
+import { assetsRoutes } from './modules/assets/index.js';
 import browserUseMcpRoutes from './modules/browser-use/browser-use-mcp.routes.js';
 import { browserUseService } from './modules/browser-use/browser-use.service.js';
 import { startEnabledPluginServers, stopAllPlugins, getPluginPort } from './utils/plugin-process-manager.js';
@@ -116,14 +113,12 @@ const wss = createWebSocketServer(server, {
             claude: queryClaudeSDK,
             cursor: spawnCursor,
             codex: queryCodex,
-            gemini: spawnGemini,
             opencode: spawnOpenCode,
         },
         abortFns: {
             claude: abortClaudeSDKSession,
             cursor: abortCursorSession,
             codex: abortCodexSession,
-            gemini: abortGeminiSession,
             opencode: abortOpenCodeSession,
         },
         resolveToolApproval,
@@ -132,14 +127,11 @@ const wss = createWebSocketServer(server, {
     shell: {
         resolveProviderSessionId: (sessionId, provider) => {
             const dbSession = sessionsDb.getSessionById(sessionId);
-            const legacyGeminiSession =
-                provider === 'gemini' ? sessionManager.getSession(sessionId) : null;
-
             if (dbSession) {
-                return dbSession.provider_session_id ?? legacyGeminiSession?.cliSessionId ?? null;
+                return dbSession.provider_session_id ?? null;
             }
 
-            return legacyGeminiSession?.cliSessionId;
+            return null;
         },
         stripAnsiSequences,
         normalizeDetectedUrl,
@@ -185,6 +177,9 @@ app.use('/api/auth', authRoutes);
 // Projects API Routes (protected)
 app.use('/api/projects', authenticateToken, projectModuleRoutes);
 
+// Chat image asset upload/serving (global ~/.cloudcli/assets store, protected)
+app.use('/api/assets', authenticateToken, assetsRoutes);
+
 // Git API Routes (protected)
 app.use('/api/git', authenticateToken, gitRoutes);
 
@@ -208,9 +203,6 @@ app.use('/api/notifications', authenticateToken, notificationRoutes);
 // User API Routes (protected)
 app.use('/api/user', authenticateToken, userRoutes);
 
-// Gemini API Routes (protected)
-app.use('/api/gemini', authenticateToken, geminiRoutes);
-
 // Plugins API Routes (protected)
 app.use('/api/plugins', authenticateToken, pluginsRoutes);
 
@@ -1072,92 +1064,8 @@ const uploadFilesHandler = async (req, res) => {
 
 app.post('/api/projects/:projectId/files/upload', authenticateToken, uploadFilesHandler);
 
-// Image upload endpoint. Accepts the DB-assigned `projectId` (not a folder name)
-// but the current implementation doesn't need to touch the project directory,
-// so we just leave the param rename for consistency with the rest of the API.
-app.post('/api/projects/:projectId/upload-images', authenticateToken, async (req, res) => {
-    try {
-        const multer = (await import('multer')).default;
-        const path = (await import('path')).default;
-        const fs = (await import('fs')).promises;
-        const os = (await import('os')).default;
-
-        // Configure multer for image uploads
-        const storage = multer.diskStorage({
-            destination: async (req, file, cb) => {
-                const uploadDir = path.join(os.tmpdir(), 'claude-ui-uploads', String(req.user.id));
-                await fs.mkdir(uploadDir, { recursive: true });
-                cb(null, uploadDir);
-            },
-            filename: (req, file, cb) => {
-                const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
-                const sanitizedName = file.originalname.replace(/[^a-zA-Z0-9.-]/g, '_');
-                cb(null, uniqueSuffix + '-' + sanitizedName);
-            }
-        });
-
-        const fileFilter = (req, file, cb) => {
-            const allowedMimes = ['image/jpeg', 'image/png', 'image/gif', 'image/webp', 'image/svg+xml'];
-            if (allowedMimes.includes(file.mimetype)) {
-                cb(null, true);
-            } else {
-                cb(new Error('Invalid file type. Only JPEG, PNG, GIF, WebP, and SVG are allowed.'));
-            }
-        };
-
-        const upload = multer({
-            storage,
-            fileFilter,
-            limits: {
-                fileSize: 5 * 1024 * 1024, // 5MB
-                files: 5
-            }
-        });
-
-        // Handle multipart form data
-        upload.array('images', 5)(req, res, async (err) => {
-            if (err) {
-                return res.status(400).json({ error: err.message });
-            }
-
-            if (!req.files || req.files.length === 0) {
-                return res.status(400).json({ error: 'No image files provided' });
-            }
-
-            try {
-                // Process uploaded images
-                const processedImages = await Promise.all(
-                    req.files.map(async (file) => {
-                        // Read file and convert to base64
-                        const buffer = await fs.readFile(file.path);
-                        const base64 = buffer.toString('base64');
-                        const mimeType = file.mimetype;
-
-                        // Clean up temp file immediately
-                        await fs.unlink(file.path);
-
-                        return {
-                            name: file.originalname,
-                            data: `data:${mimeType};base64,${base64}`,
-                            size: file.size,
-                            mimeType: mimeType
-                        };
-                    })
-                );
-
-                res.json({ images: processedImages });
-            } catch (error) {
-                console.error('Error processing images:', error);
-                // Clean up any remaining files
-                await Promise.all(req.files.map(f => fs.unlink(f.path).catch(() => { })));
-                res.status(500).json({ error: 'Failed to process images' });
-            }
-        });
-    } catch (error) {
-        console.error('Error in image upload endpoint:', error);
-        res.status(500).json({ error: 'Internal server error' });
-    }
-});
+// Chat image uploads moved to POST /api/assets/images (server/modules/assets),
+// which stores them in the global ~/.cloudcli/assets folder.
 
 // Get token usage for a specific session. `projectId` is the DB primary key;
 // the Claude branch below resolves it to an absolute path via the DB.
@@ -1197,62 +1105,6 @@ app.get('/api/projects/:projectId/sessions/:sessionId/token-usage', authenticate
             });
         }
 
-        if (provider === 'gemini') {
-            const session = sessionsDb.getSessionById(safeSessionId);
-            const sessionFilePath = session?.jsonl_path;
-            if (!sessionFilePath) {
-                return res.json({
-                    used: 0,
-                    inputTokens: 0,
-                    outputTokens: 0,
-                    breakdown: { input: 0, output: 0 },
-                    unsupported: true,
-                    message: 'Token usage tracking not available for this Gemini session'
-                });
-            }
-
-            let fileContent;
-            try {
-                fileContent = await fsPromises.readFile(sessionFilePath, 'utf8');
-            } catch (error) {
-                if (error.code === 'ENOENT') {
-                    return res.status(404).json({ error: 'Session file not found', path: sessionFilePath });
-                }
-                throw error;
-            }
-
-            const lines = fileContent.trim().split('\n');
-            let inputTokens = 0;
-            let outputTokens = 0;
-            let totalTokens = 0;
-
-            for (let i = lines.length - 1; i >= 0; i--) {
-                try {
-                    const entry = JSON.parse(lines[i]);
-                    if (!entry.tokens || typeof entry.tokens !== 'object') {
-                        continue;
-                    }
-
-                    inputTokens = Number(entry.tokens.input || 0);
-                    outputTokens = Number(entry.tokens.output || 0);
-                    totalTokens = Number(entry.tokens.total || inputTokens + outputTokens || 0);
-                    break;
-                } catch {
-                    continue;
-                }
-            }
-
-            return res.json({
-                used: totalTokens,
-                inputTokens,
-                outputTokens,
-                breakdown: {
-                    input: inputTokens,
-                    output: outputTokens
-                }
-            });
-        }
-
         if (provider === 'opencode') {
             const dbPath = getOpenCodeDatabasePath();
             if (!fs.existsSync(dbPath)) {

package/server/modules/assets/assets.routes.ts

@@ -0,0 +1,103 @@
+import fsSync, { promises as fs } from 'node:fs';
+
+import express from 'express';
+import mime from 'mime-types';
+import multer from 'multer';
+
+import {
+  buildStoredImageRecords,
+  ensureImageAssetsDir,
+  isAllowedImageMimeType,
+  resolveImageAssetFile,
+} from '@/modules/assets/services/image-assets.service.js';
+
+const router = express.Router();
+
+// Multer writes uploads straight into the global assets folder; the service
+// owns the folder location and the response record shape.
+const storage = multer.diskStorage({
+  destination: (req, file, cb) => {
+    ensureImageAssetsDir()
+      .then((assetsDir) => cb(null, assetsDir))
+      .catch((error) => cb(error as Error, ''));
+  },
+  filename: (req, file, cb) => {
+    const uniqueSuffix = `${Date.now()}-${Math.round(Math.random() * 1e9)}`;
+    const sanitizedName = file.originalname.replace(/[^a-zA-Z0-9.-]/g, '_');
+    cb(null, `${uniqueSuffix}-${sanitizedName}`);
+  },
+});
+
+const upload = multer({
+  storage,
+  fileFilter: (req, file, cb) => {
+    if (isAllowedImageMimeType(file.mimetype)) {
+      cb(null, true);
+    } else {
+      cb(new Error('Invalid file type. Only JPEG, PNG, GIF, WebP, and SVG are allowed.'));
+    }
+  },
+  limits: {
+    fileSize: 5 * 1024 * 1024, // 5MB
+    files: 5,
+  },
+});
+
+/**
+ * Stores chat image attachments in the global `~/.cloudcli/assets` folder and
+ * returns their absolute paths for use in provider prompts and chat history.
+ */
+router.post('/images', (req, res) => {
+  upload.array('images', 5)(req, res, (err: unknown) => {
+    if (err) {
+      const message = err instanceof Error ? err.message : 'Upload failed';
+      return res.status(400).json({ error: message });
+    }
+
+    const files = Array.isArray(req.files) ? req.files : [];
+    if (files.length === 0) {
+      return res.status(400).json({ error: 'No image files provided' });
+    }
+
+    res.json({ images: buildStoredImageRecords(files) });
+  });
+});
+
+/**
+ * Serves one stored image asset by filename. Only files directly inside the
+ * global assets folder are reachable; traversal attempts resolve to null.
+ */
+router.get('/images/:filename', async (req, res) => {
+  const resolved = resolveImageAssetFile(req.params.filename);
+  if (!resolved) {
+    return res.status(400).json({ error: 'Invalid asset filename' });
+  }
+
+  try {
+    await fs.access(resolved);
+  } catch {
+    return res.status(404).json({ error: 'Asset not found' });
+  }
+
+  const contentType = mime.lookup(resolved) || 'application/octet-stream';
+  res.setHeader('Content-Type', contentType);
+  // Stored-XSS hardening: never let the browser sniff a different type, and
+  // force SVGs (which can carry scripts when rendered as a document) to
+  // download instead of rendering inline. The chat UI is unaffected — it
+  // fetches assets as blobs and shows them through <img>, where SVG scripts
+  // never execute.
+  res.setHeader('X-Content-Type-Options', 'nosniff');
+  if (contentType === 'image/svg+xml') {
+    res.setHeader('Content-Disposition', 'attachment');
+  }
+  const fileStream = fsSync.createReadStream(resolved);
+  fileStream.pipe(res);
+  fileStream.on('error', (error) => {
+    console.error('Error streaming image asset:', error);
+    if (!res.headersSent) {
+      res.status(500).json({ error: 'Error reading asset' });
+    }
+  });
+});
+
+export default router;