@cloudcli-ai/cloudcli 1.36.3 → 1.37.1

package/server/modules/database/schema.ts

@@ -109,6 +109,11 @@ CREATE TABLE IF NOT EXISTS sessions (
     custom_name TEXT,
     project_path TEXT,
     jsonl_path TEXT,
+    -- Model and reasoning effort this session runs with. Written when the user
+    -- changes either selection and on every send, so reopening a session
+    -- restores its exact runtime configuration instead of provider defaults.
+    model TEXT,
+    effort TEXT,
     isArchived BOOLEAN DEFAULT 0,
     created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
     updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
@@ -134,6 +139,27 @@ CREATE TABLE IF NOT EXISTS app_config (
 );
 `;
 
+/**
+ * Persistent custom-model library used by the Providers module.
+ *
+ * Only user-created models are stored here. Predefined models remain source-
+ * controlled in each provider's `-models.provider.ts` adapter so they can be
+ * updated without migrating application data. `model_id` is unique only within
+ * a provider because different CLIs can accept the same identifier.
+ */
+export const PROVIDER_MODELS_TABLE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS provider_models (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    provider TEXT NOT NULL CHECK (provider IN ('claude', 'cursor', 'codex', 'opencode')),
+    model_id TEXT NOT NULL,
+    model_name TEXT NOT NULL,
+    sort_order INTEGER NOT NULL DEFAULT 0,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE(provider, model_id)
+);
+`;
+
 export const INIT_SCHEMA_SQL = `
 -- Initialize authentication database
 PRAGMA foreign_keys = ON;
@@ -177,4 +203,8 @@ CREATE INDEX IF NOT EXISTS idx_session_ids_lookup ON sessions(session_id);
 ${LAST_SCANNED_AT_SQL}
 
 ${APP_CONFIG_TABLE_SCHEMA_SQL}
+
+${PROVIDER_MODELS_TABLE_SCHEMA_SQL}
+CREATE INDEX IF NOT EXISTS idx_provider_models_provider_order
+ON provider_models(provider, sort_order, id);
 `;

package/server/modules/database/tests/provider-models.db.integration.test.ts

@@ -0,0 +1,125 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import {
+  closeConnection,
+  getConnection,
+  initializeDatabase,
+  providerModelsDb,
+  sessionsDb,
+} from '@/modules/database/index.js';
+import { runMigrations } from '@/modules/database/migrations.js';
+
+test('provider model repository stores custom rows only and maintains session references', async () => {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const tempDirectory = await mkdtemp(path.join(os.tmpdir(), 'provider-model-db-'));
+  const databasePath = path.join(tempDirectory, 'auth.db');
+
+  closeConnection();
+  process.env.DATABASE_PATH = databasePath;
+  await writeFile(databasePath, '');
+  await initializeDatabase();
+
+  try {
+    const columns = getConnection().prepare('PRAGMA table_info(provider_models)').all() as Array<{
+      name: string;
+    }>;
+    assert.deepEqual(columns.map((column) => column.name), [
+      'id',
+      'provider',
+      'model_id',
+      'model_name',
+      'sort_order',
+      'created_at',
+      'updated_at',
+    ]);
+    assert.deepEqual(providerModelsDb.listCustomProviderModels('codex'), []);
+
+    const custom = providerModelsDb.createCustomProviderModel('codex', {
+      model: 'Private Gateway Model',
+      id: 'gateway/model-v1',
+    });
+    assert.equal(custom.modelId, 'gateway/model-v1');
+    assert.equal(
+      providerModelsDb.findCustomProviderModelByModelId('codex', 'gateway/model-v1')?.recordId,
+      custom.recordId,
+    );
+
+    const db = getConnection();
+    db.prepare(`
+      INSERT INTO projects (project_id, project_path)
+      VALUES ('project-1', '/tmp/project-1')
+    `).run();
+    db.prepare(`
+      INSERT INTO sessions (session_id, provider, project_path, model, effort)
+      VALUES ('session-1', 'codex', '/tmp/project-1', 'gateway/model-v1', 'high')
+    `).run();
+
+    const updated = providerModelsDb.updateCustomProviderModel('codex', custom.recordId, {
+      model: 'Private Gateway Model 2',
+      id: 'gateway/model-v2',
+    });
+    assert.equal(updated?.modelId, 'gateway/model-v2');
+    assert.equal(sessionsDb.getSessionById('session-1')?.model, 'gateway/model-v2');
+    // A rename keeps the same underlying model, so its effort stays applicable.
+    assert.equal(sessionsDb.getSessionById('session-1')?.effort, 'high');
+
+    const removed = providerModelsDb.deleteCustomProviderModel(
+      'codex',
+      custom.recordId,
+      'gpt-default',
+    );
+    assert.equal(removed?.modelId, 'gateway/model-v2');
+    assert.equal(sessionsDb.getSessionById('session-1')?.model, 'gpt-default');
+    // The effort belonged to the deleted model and must not survive onto the
+    // fallback, which has its own default.
+    assert.equal(sessionsDb.getSessionById('session-1')?.effort, null);
+    assert.equal(providerModelsDb.getCustomProviderModel('codex', custom.recordId), null);
+  } finally {
+    closeConnection();
+    if (previousDatabasePath === undefined) {
+      delete process.env.DATABASE_PATH;
+    } else {
+      process.env.DATABASE_PATH = previousDatabasePath;
+    }
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+});
+
+test('migrations create the provider model index on an install that lacks it', async () => {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const tempDirectory = await mkdtemp(path.join(os.tmpdir(), 'provider-model-index-'));
+  const databasePath = path.join(tempDirectory, 'auth.db');
+
+  closeConnection();
+  process.env.DATABASE_PATH = databasePath;
+  await writeFile(databasePath, '');
+  await initializeDatabase();
+
+  try {
+    const db = getConnection();
+    // Upgraded installs reach runMigrations with provider_models present but no
+    // index, so the CREATE INDEX statement is compiled against the real table
+    // instead of short-circuiting on the existing index name.
+    db.exec('DROP INDEX IF EXISTS idx_provider_models_provider_order');
+
+    runMigrations(db);
+
+    const indexedColumns = (db
+      .prepare('PRAGMA index_info(idx_provider_models_provider_order)')
+      .all() as Array<{ name: string }>)
+      .map((column) => column.name);
+    assert.deepEqual(indexedColumns, ['provider', 'sort_order', 'id']);
+  } finally {
+    closeConnection();
+    if (previousDatabasePath === undefined) {
+      delete process.env.DATABASE_PATH;
+    } else {
+      process.env.DATABASE_PATH = previousDatabasePath;
+    }
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+});

package/server/modules/database/tests/sessions-provider-mapping.test.ts

@@ -45,7 +45,7 @@ test('disk-discovered sessions are keyed by the provider id for both columns', a
 
 test('app sessions get the provider id assigned without creating a duplicate row', async () => {
   await withIsolatedDatabase(() => {
-    sessionsDb.createAppSession('app-id-1', 'claude', '/workspace/demo');
+    sessionsDb.createAppSession('app-id-1', 'claude', '/workspace/demo', 'Initial CloudCLI message');
     sessionsDb.assignProviderSessionId('app-id-1', 'provider-xyz');
 
     // A later synchronizer pass that discovers the transcript on disk must
@@ -66,6 +66,7 @@ test('app sessions get the provider id assigned without creating a duplicate row
     const row = sessionsDb.getSessionById('app-id-1');
     assert.equal(row?.provider_session_id, 'provider-xyz');
     assert.equal(row?.jsonl_path, '/fake/path/provider-xyz.jsonl');
+    assert.equal(row?.custom_name, 'Initial CloudCLI message');
   });
 });
 

package/server/modules/database/tests/sessions.db.integration.test.ts

@@ -6,6 +6,7 @@ import test from 'node:test';
 
 import { closeConnection } from '@/modules/database/connection.js';
 import { initializeDatabase } from '@/modules/database/init-db.js';
+import { projectsDb } from '@/modules/database/repositories/projects.db.js';
 import { sessionsDb } from '@/modules/database/repositories/sessions.db.js';
 
 async function withIsolatedDatabase(runTest: () => void | Promise<void>): Promise<void> {
@@ -82,3 +83,34 @@ test('repository reads normalize SQLite UTC timestamps to ISO strings', async ()
     assert.match(row?.updated_at ?? '', /^\d{4}-\d{2}-\d{2}T/);
   });
 });
+
+test('recent sessions are globally ordered, paginated, and limited to visible conversations', async () => {
+  await withIsolatedDatabase(() => {
+    const fixtures: Array<Parameters<typeof sessionsDb.createSession>> = [
+      ['session-oldest', 'claude', '/workspace/project-a', 'Oldest', '2026-07-18T09:00:00.000Z', '2026-07-18T10:00:00.000Z'],
+      ['session-newest', 'codex', '/workspace/project-b', 'Newest', '2026-07-18T11:00:00.000Z', '2026-07-18T12:00:00.900Z'],
+      ['session-same-second', 'claude', '/workspace/project-a', 'Same second, slightly older', '2026-07-18T12:00:00.000Z', '2026-07-18T12:00:00.100Z'],
+      ['session-middle', 'claude', '/workspace/project-a', 'Middle', '2026-07-18T10:00:00.000Z', '2026-07-18T11:00:00.000Z'],
+      ['session-archived', 'claude', '/workspace/project-a', 'Archived session', '2026-07-18T13:00:00.000Z', '2026-07-18T13:00:00.000Z'],
+      ['session-hidden-project', 'claude', '/workspace/project-hidden', 'Archived project session', '2026-07-18T14:00:00.000Z', '2026-07-18T14:00:00.000Z'],
+    ];
+    fixtures.forEach((fixture) => sessionsDb.createSession(...fixture));
+
+    sessionsDb.updateSessionIsArchived('session-archived', true);
+    projectsDb.updateProjectIsArchived('/workspace/project-hidden', true);
+
+    const firstPage = sessionsDb.getRecentSessionsPage(2, 0);
+    const secondPage = sessionsDb.getRecentSessionsPage(2, 2);
+
+    assert.equal(firstPage.total, 4);
+    assert.deepEqual(
+      firstPage.sessions.map((session) => session.session_id),
+      ['session-newest', 'session-same-second'],
+    );
+    assert.equal(secondPage.total, 4);
+    assert.deepEqual(
+      secondPage.sessions.map((session) => session.session_id),
+      ['session-middle', 'session-oldest'],
+    );
+  });
+});

package/server/modules/file-tree/file-tree.module.ts

@@ -0,0 +1,116 @@
+import { randomUUID } from 'node:crypto';
+import fs, { promises as fsPromises } from 'node:fs';
+import os from 'node:os';
+
+import mime from 'mime-types';
+import multer from 'multer';
+
+import { projectsDb } from '@/modules/database/index.js';
+import { createFileTreeRouter } from '@/modules/file-tree/file-tree.routes.js';
+import { createFileTreeService } from '@/modules/file-tree/file-tree.service.js';
+import type {
+  FileTreeFileSystem,
+  FileTreeLogger,
+  FileTreeProjectGateway,
+  FileTreeWorkspaceGateway,
+} from '@/shared/types.js';
+import { WORKSPACES_ROOT, validateWorkspacePath } from '@/shared/utils.js';
+
+const MAXIMUM_UPLOAD_SIZE_MEGABYTES = 200;
+const MAXIMUM_UPLOAD_SIZE_BYTES = MAXIMUM_UPLOAD_SIZE_MEGABYTES * 1024 * 1024;
+const MAXIMUM_UPLOAD_FILE_COUNT = 20;
+
+function readFileSystemConcurrency(): number {
+  const configuredConcurrency = Number.parseInt(process.env.FS_CONCURRENCY ?? '', 10);
+  return Number.isFinite(configuredConcurrency) && configuredConcurrency > 0
+    ? configuredConcurrency
+    : 64;
+}
+
+/**
+ * Production filesystem adapter owned by the File Tree composition root.
+ * Application services receive this complete capability explicitly and never
+ * import Node's mutable filesystem APIs themselves.
+ */
+const fileTreeFileSystem: FileTreeFileSystem = {
+  access: (candidatePath) => fsPromises.access(candidatePath),
+  stat: (candidatePath) => fsPromises.stat(candidatePath),
+  lstat: (candidatePath) => fsPromises.lstat(candidatePath),
+  // `opendir` streams entries in batches and the handle is closed by the
+  // iterator protocol, including when the caller stops early at the entry cap.
+  openDirectory: async function* (directoryPath) {
+    yield* await fsPromises.opendir(directoryPath);
+  },
+  realpath: (candidatePath) => fsPromises.realpath(candidatePath),
+  readTextFile: (filePath) => fsPromises.readFile(filePath, 'utf8'),
+  writeTextFile: (filePath, content) => fsPromises.writeFile(filePath, content, 'utf8'),
+  async makeDirectory(directoryPath, recursive) {
+    await fsPromises.mkdir(directoryPath, { recursive });
+  },
+  rename: (oldPath, newPath) => fsPromises.rename(oldPath, newPath),
+  async removeDirectory(directoryPath) {
+    await fsPromises.rm(directoryPath, { recursive: true, force: true });
+  },
+  unlink: (filePath) => fsPromises.unlink(filePath),
+  copyFile: (sourcePath, destinationPath) => fsPromises.copyFile(sourcePath, destinationPath),
+  createReadStream: (filePath) => fs.createReadStream(filePath),
+};
+
+/**
+ * Database boundary used only by File Tree production composition.
+ * The Database module is consumed through its barrel; services and routes see
+ * only the narrow project-path lookup contract.
+ */
+const fileTreeProjects: FileTreeProjectGateway = {
+  getProjectPathById: (projectId) => projectsDb.getProjectPathById(projectId),
+};
+
+/**
+ * Workspace-policy boundary used only by File Tree production composition.
+ * Keeping both the configured root and symlink-aware validator together makes
+ * the path policy explicit for every service instance.
+ */
+const fileTreeWorkspace: FileTreeWorkspaceGateway = {
+  rootPath: WORKSPACES_ROOT,
+  validatePath: (candidatePath) => validateWorkspacePath(candidatePath),
+};
+
+const fileTreeLogger: FileTreeLogger = {
+  error: (message, error) => console.error(message, error),
+};
+
+const fileTreeServices = createFileTreeService({
+  fileSystem: fileTreeFileSystem,
+  projects: fileTreeProjects,
+  workspace: fileTreeWorkspace,
+  resolveMimeType: (filePath) => mime.lookup(filePath) || 'application/octet-stream',
+  fileSystemConcurrency: readFileSystemConcurrency(),
+  logger: fileTreeLogger,
+});
+
+const fileUploadMiddleware = multer({
+  storage: multer.diskStorage({
+    destination: os.tmpdir(),
+    filename: (_request, _file, callback) => {
+      callback(null, `cloudcli-file-upload-${randomUUID()}`);
+    },
+  }),
+  limits: {
+    fileSize: MAXIMUM_UPLOAD_SIZE_BYTES,
+    files: MAXIMUM_UPLOAD_FILE_COUNT,
+  },
+}).array('files', MAXIMUM_UPLOAD_FILE_COUNT);
+
+/**
+ * File Tree router used by the server entrypoint to mount the authenticated
+ * browsing, editing, file-management, and upload API under `/api/file-tree`.
+ */
+export const fileTreeRoutes = createFileTreeRouter(
+  fileTreeServices,
+  fileUploadMiddleware,
+  {
+    maximumFileSizeMegabytes: MAXIMUM_UPLOAD_SIZE_MEGABYTES,
+    maximumFileCount: MAXIMUM_UPLOAD_FILE_COUNT,
+  },
+  fileTreeLogger,
+);

package/server/modules/file-tree/file-tree.routes.ts

@@ -0,0 +1,258 @@
+import express from 'express';
+import type { NextFunction, Request, RequestHandler, Response } from 'express';
+
+import type {
+  FileTreeLogger,
+  FileTreeServices,
+  FileTreeUploadedFile,
+} from '@/shared/types.js';
+import { AppError } from '@/shared/utils.js';
+
+type FileTreeUploadLimits = {
+  maximumFileSizeMegabytes: number;
+  maximumFileCount: number;
+};
+
+type UploadedRequest = Request & {
+  files?: Express.Multer.File[];
+};
+
+function readBody(request: Request): Record<string, unknown> {
+  return typeof request.body === 'object' && request.body !== null
+    ? request.body as Record<string, unknown>
+    : {};
+}
+
+function readRequiredString(value: unknown, fieldName: string, message?: string): string {
+  if (typeof value !== 'string' || !value.trim()) {
+    throw new AppError(message ?? `${fieldName} is required`, {
+      code: 'INVALID_FILE_TREE_REQUEST',
+      statusCode: 400,
+    });
+  }
+  return value;
+}
+
+function readOptionalString(value: unknown): string | null {
+  return typeof value === 'string' ? value : null;
+}
+
+function readProjectId(request: Request): string {
+  return readRequiredString(request.params.projectId, 'projectId');
+}
+
+function readEntryType(value: unknown): 'file' | 'directory' {
+  if (value !== 'file' && value !== 'directory') {
+    throw new AppError('Type must be "file" or "directory"', {
+      code: 'INVALID_FILE_TREE_ENTRY_TYPE',
+      statusCode: 400,
+    });
+  }
+  return value;
+}
+
+function readRelativePaths(value: unknown): string[] {
+  if (typeof value !== 'string' || !value) {
+    return [];
+  }
+
+  try {
+    const parsed = JSON.parse(value) as unknown;
+    return Array.isArray(parsed)
+      ? parsed.filter((entry): entry is string => typeof entry === 'string')
+      : [];
+  } catch {
+    return [];
+  }
+}
+
+function readRequestedFileCount(value: unknown, fallbackCount: number): number {
+  const parsedCount = typeof value === 'string' ? Number.parseInt(value, 10) : Number.NaN;
+  return Number.isFinite(parsedCount) && parsedCount > 0 ? parsedCount : fallbackCount;
+}
+
+function normalizeUploadedFiles(request: UploadedRequest): FileTreeUploadedFile[] {
+  return Array.isArray(request.files)
+    ? request.files.map((file) => ({
+        originalName: file.originalname,
+        temporaryPath: file.path,
+        size: file.size,
+        mimeType: file.mimetype,
+      }))
+    : [];
+}
+
+function createRouteHandler(
+  operation: (request: Request, response: Response) => void | Promise<void>,
+  logger: FileTreeLogger,
+): RequestHandler {
+  return async (request, response) => {
+    try {
+      await operation(request, response);
+    } catch (error) {
+      if (error instanceof AppError) {
+        response.status(error.statusCode).json({ error: error.message });
+        return;
+      }
+
+      const message = error instanceof Error ? error.message : String(error);
+      logger.error('File Tree API error', error);
+      response.status(500).json({ error: message });
+    }
+  };
+}
+
+/**
+ * Builds the File Tree HTTP router for the server composition root and route tests.
+ * Paths are relative to the module's `/api/file-tree` mount point so the
+ * complete HTTP surface has one feature-owned namespace.
+ */
+export function createFileTreeRouter(
+  services: FileTreeServices,
+  uploadFilesMiddleware: RequestHandler,
+  uploadLimits: FileTreeUploadLimits,
+  logger: FileTreeLogger,
+): express.Router {
+  const router = express.Router();
+
+  router.get('/browse-filesystem', createRouteHandler(async (request, response) => {
+    response.json(await services.browseWorkspace(readOptionalString(request.query.path)));
+  }, logger));
+
+  router.post('/create-folder', createRouteHandler(async (request, response) => {
+    const body = readBody(request);
+    const folderPath = readRequiredString(body.path, 'path', 'Path is required');
+    response.json(await services.createWorkspaceFolder(folderPath));
+  }, logger));
+
+  router.get('/projects/:projectId/file', createRouteHandler(async (request, response) => {
+    const filePath = readRequiredString(request.query.filePath, 'filePath', 'Invalid file path');
+    response.json(await services.readTextFile(readProjectId(request), filePath));
+  }, logger));
+
+  router.get('/projects/:projectId/files/content', createRouteHandler(async (request, response) => {
+    const filePath = readRequiredString(request.query.path, 'path', 'Invalid file path');
+    const file = await services.openFile(readProjectId(request), filePath);
+    response.setHeader('Content-Type', file.contentType);
+    file.stream.pipe(response);
+    file.stream.on('error', (error) => {
+      logger.error('Error streaming File Tree content', error);
+      if (!response.headersSent) {
+        response.status(500).json({ error: 'Error reading file' });
+      }
+    });
+  }, logger));
+
+  router.put('/projects/:projectId/file', createRouteHandler(async (request, response) => {
+    const body = readBody(request);
+    const filePath = readRequiredString(body.filePath, 'filePath', 'Invalid file path');
+    if (body.content === undefined) {
+      throw new AppError('Content is required', {
+        code: 'FILE_CONTENT_REQUIRED',
+        statusCode: 400,
+      });
+    }
+    if (typeof body.content !== 'string') {
+      throw new AppError('Content must be a string', {
+        code: 'INVALID_FILE_CONTENT',
+        statusCode: 400,
+      });
+    }
+    response.json(await services.saveTextFile(readProjectId(request), filePath, body.content));
+  }, logger));
+
+  router.get('/projects/:projectId/files', createRouteHandler(async (request, response) => {
+    response.json(await services.listProjectFiles(readProjectId(request), {
+      respectGitignore: request.query.respectGitignore === 'true',
+    }));
+  }, logger));
+
+  router.post('/projects/:projectId/files/create', createRouteHandler(async (request, response) => {
+    const body = readBody(request);
+    if (!body.name || !body.type) {
+      throw new AppError('Name and type are required', {
+        code: 'FILE_TREE_ENTRY_FIELDS_REQUIRED',
+        statusCode: 400,
+      });
+    }
+    const name = readRequiredString(body.name, 'name');
+    const type = readEntryType(body.type);
+    const parentPath = readOptionalString(body.path) ?? '';
+    response.json(await services.createEntry({
+      projectId: readProjectId(request),
+      parentPath,
+      type,
+      name,
+    }));
+  }, logger));
+
+  router.put('/projects/:projectId/files/rename', createRouteHandler(async (request, response) => {
+    const body = readBody(request);
+    if (!body.oldPath || !body.newName) {
+      throw new AppError('oldPath and newName are required', {
+        code: 'FILE_TREE_RENAME_FIELDS_REQUIRED',
+        statusCode: 400,
+      });
+    }
+    response.json(await services.renameEntry({
+      projectId: readProjectId(request),
+      oldPath: readRequiredString(body.oldPath, 'oldPath'),
+      newName: readRequiredString(body.newName, 'newName'),
+    }));
+  }, logger));
+
+  router.delete('/projects/:projectId/files', createRouteHandler(async (request, response) => {
+    const body = readBody(request);
+    const targetPath = readRequiredString(body.path, 'path', 'Path is required');
+    response.json(await services.deleteEntry({
+      projectId: readProjectId(request),
+      targetPath,
+    }));
+  }, logger));
+
+  const uploadHandler = createRouteHandler(async (request, response) => {
+    const uploadedRequest = request as UploadedRequest;
+    const body = readBody(request);
+    const files = normalizeUploadedFiles(uploadedRequest);
+    response.json(await services.storeUploadedFiles({
+      projectId: readProjectId(request),
+      targetPath: readOptionalString(body.targetPath) ?? '',
+      relativePaths: readRelativePaths(body.relativePaths),
+      requestedFileCount: readRequestedFileCount(body.requestedFileCount, files.length),
+      files,
+    }));
+  }, logger);
+
+  router.post(
+    '/projects/:projectId/files/upload',
+    (request: Request, response: Response, next: NextFunction) => {
+      uploadFilesMiddleware(request, response, (error?: unknown) => {
+        if (!error) {
+          void uploadHandler(request, response, next);
+          return;
+        }
+
+        const errorCode = typeof error === 'object' && error !== null && 'code' in error
+          ? String(error.code)
+          : null;
+        if (errorCode === 'LIMIT_FILE_SIZE') {
+          response.status(400).json({
+            error: `File too large. Maximum size is ${uploadLimits.maximumFileSizeMegabytes}MB.`,
+          });
+          return;
+        }
+        if (errorCode === 'LIMIT_FILE_COUNT') {
+          response.status(400).json({
+            error: `Too many files. Maximum is ${uploadLimits.maximumFileCount} files.`,
+          });
+          return;
+        }
+
+        const message = error instanceof Error ? error.message : String(error);
+        response.status(500).json({ error: message });
+      });
+    },
+  );
+
+  return router;
+}