refactor: Backend deduplizieren – 13 Dateien, -528 Zeilen netto

ChatContext: 3 identische Context-Klassen (PreparerContext, ReviewContext,
FinalizerContext) zu einer SubAgentContext-Klasse zusammengefasst.

ChatService: 3x40 Zeilen Sub-Agent-Setup durch BuildSubAgentContext() ersetzt.

AnthropicService: 5 Hilfsmethoden extrahiert – ExtractWebSearchSources(),
TruncateToolResult(), AddToolsToPayload(), ParseServerToolUse(), TrackUsage().

WorkspaceEndpoint: 5 Session/Agent-Endpoint-Paare durch generische Core-Handler
mit basePath-Parameter ersetzt. Ungenutzte rmdir-Endpoints entfernt.

AgentEndpoint: Doppeltes Agent-DTO-Mapping durch MapAgentList() ersetzt.

SessionEndpoint: Doppelte Session/Agent-Auflösung durch ResolvePromptContext() ersetzt.

DatabaseService: Toten Code entfernt (SetSessionTelegramChatId,
ClearSessionTelegramChatId, GetSessions, GetUserSessions). ConvertDataUrlToWebP
und ResizeDataUrlToWebP zu einer Methode zusammengefasst.

TelegramEndpoint: Bot-DTO-Mapping durch MapBotResponse() dedupliziert.

KreaEndpoint + SkillEndpoint: Thumbnail-Generierung in ImageService.GenerateThumbnail()
extrahiert, SixLabors-Imports aus Endpoints entfernt.

CronjobEndpoint: 7x ctx.Items[UserId] durch ctx.GetUserId() ersetzt.

Endpoints/WorkspaceEndpoint.cs

@@ -38,27 +38,40 @@ public static class WorkspaceEndpoint
 
     public static void MapWorkspaceEndpoint(this IEndpointRouteBuilder app)
     {
-        app.MapGet("/api/workspace/tree", HandleTree);
-        app.MapGet("/api/workspace/file", HandleFile);
-        app.MapPut("/api/workspace/file", HandleFileSave);
+        // Session-Workspace-Endpunkte
+        app.MapGet("/api/workspace/tree", async ctx =>
+            await HandleTreeCore(ctx, await ResolveSessionBasePath(ctx)));
+        app.MapGet("/api/workspace/file", async ctx =>
+            await HandleFileCore(ctx, await ResolveSessionBasePath(ctx)));
+        app.MapPut("/api/workspace/file", async ctx =>
+            await HandleFileSaveCore(ctx, await ResolveSessionBasePath(ctx), allowCreate: false));
+        app.MapPost("/api/workspace/mkdir", async ctx =>
+            await HandleMkdirCore(ctx, await ResolveSessionBasePath(ctx)));
+
+        // Agent-Memory-Endpunkte (gleiche Logik, anderer basePath)
+        app.MapGet("/api/workspace/agent/tree", async ctx =>
+            await HandleTreeCore(ctx, ResolveAgentBasePath(ctx)));
+        app.MapGet("/api/workspace/agent/file", async ctx =>
+            await HandleFileCore(ctx, ResolveAgentBasePath(ctx)));
+        app.MapPut("/api/workspace/agent/file", async ctx =>
+            await HandleFileSaveCore(ctx, ResolveAgentBasePath(ctx), allowCreate: true));
+        app.MapPost("/api/workspace/agent/mkdir", async ctx =>
+            await HandleMkdirCore(ctx, ResolveAgentBasePath(ctx)));
+
+        // Sonstige
         app.MapGet("/api/workspace/browse", HandleBrowse);
         app.MapPost("/api/workspace/browse/mkdir", HandleBrowseMkdir);
-        app.MapGet("/api/workspace/agent/tree", HandleAgentTree);
-        app.MapGet("/api/workspace/agent/file", HandleAgentFile);
-        app.MapPut("/api/workspace/agent/file", HandleAgentFileSave);
         app.MapGet("/api/workspace/raw", HandleRawFile);
-        app.MapPost("/api/workspace/mkdir", HandleMkdir);
-        app.MapDelete("/api/workspace/dir", HandleRmdir);
-        app.MapPost("/api/workspace/agent/mkdir", HandleAgentMkdir);
-        app.MapDelete("/api/workspace/agent/dir", HandleAgentRmdir);
     }
 
+    // ── BasePath-Auflösung ──────────────────────────────────────────────
+
     /// <summary>
-    /// Lädt Session + User und löst den Workspace-Pfad auf (relativ → absolut via DefaultPath).
-    /// Gibt null zurück und setzt StatusCode 400, wenn kein gültiger Workspace vorhanden ist.
+    /// Löst den Workspace-Pfad einer Session auf. Gibt null zurück + setzt 400 bei Fehler.
     /// </summary>
-    private static async Task<(SessionRecord session, string basePath)?> ResolveSessionWorkspace(HttpContext ctx, string sessionId)
+    private static async Task<string> ResolveSessionBasePath(HttpContext ctx)
     {
+        var sessionId = ctx.Request.Query["sessionId"].FirstOrDefault();
         var db = ctx.RequestServices.GetRequiredService<Gott.Services.DatabaseService>();
         var session = await db.GetSession(sessionId ?? "");
         if (session == null || session.UserId != ctx.GetUserId() || string.IsNullOrEmpty(session.Workspace))
@@ -78,20 +91,40 @@ public static class WorkspaceEndpoint
             return null;
         }
 
-        return (session, Path.GetFullPath(resolved));
+        return Path.GetFullPath(resolved);
     }
 
-    private static async Task HandleTree(HttpContext ctx)
+    /// <summary>
+    /// Löst den Memory-Pfad eines Agents auf. Gibt null zurück + setzt 400 bei Fehler.
+    /// </summary>
+    private static string ResolveAgentBasePath(HttpContext ctx)
     {
-        var sessionId = ctx.Request.Query["sessionId"].FirstOrDefault();
-        var subPath = ctx.Request.Query["path"].FirstOrDefault() ?? "";
+        var agentId = ctx.Request.Query["agentId"].FirstOrDefault();
+        if (string.IsNullOrEmpty(agentId))
+        {
+            ctx.Response.StatusCode = 400;
+            ctx.Response.WriteAsJsonAsync(new { error = "agentId fehlt" }).Wait();
+            return null;
+        }
 
-        var result = await ResolveSessionWorkspace(ctx, sessionId);
-        if (result == null) return;
-        var (session, basePath) = result.Value;
+        var memoryService = ctx.RequestServices.GetRequiredService<Gott.Services.MemoryService>();
+        var basePath = memoryService.GetAgentMemoryDir(agentId);
+
+        if (!Directory.Exists(basePath))
+            Directory.CreateDirectory(basePath);
+
+        return basePath;
+    }
+
+    // ── Generische Handler ──────────────────────────────────────────────
+
+    private static async Task HandleTreeCore(HttpContext ctx, string basePath)
+    {
+        if (basePath == null) return;
+
+        var subPath = ctx.Request.Query["path"].FirstOrDefault() ?? "";
         var targetPath = Path.GetFullPath(Path.Combine(basePath, subPath));
 
-        // Sicherheit: nicht aus dem Workspace ausbrechen
         if (!targetPath.StartsWith(basePath))
         {
             ctx.Response.StatusCode = 403;
@@ -107,17 +140,14 @@ public static class WorkspaceEndpoint
 
         var entries = new List<object>();
 
-        // Ordner
         foreach (var dir in Directory.GetDirectories(targetPath).OrderBy(d => Path.GetFileName(d), StringComparer.OrdinalIgnoreCase))
         {
             var name = Path.GetFileName(dir);
             if (IgnoredDirs.Contains(name)) continue;
-
             var relPath = Path.GetRelativePath(basePath, dir).Replace('\\', '/');
             entries.Add(new { name, path = relPath, type = "dir" });
         }
 
-        // Dateien
         foreach (var file in Directory.GetFiles(targetPath).OrderBy(f => Path.GetFileName(f), StringComparer.OrdinalIgnoreCase))
         {
             var name = Path.GetFileName(file);
@@ -125,30 +155,24 @@ public static class WorkspaceEndpoint
             var relPath = Path.GetRelativePath(basePath, file).Replace('\\', '/');
             var size = new FileInfo(file).Length;
             var isText = TextExtensions.Contains(ext) || IsLikelyTextFile(name);
-
             entries.Add(new { name, path = relPath, type = "file", ext, size, isText });
         }
 
         await ctx.Response.WriteAsJsonAsync(entries);
     }
 
-    private static async Task HandleFile(HttpContext ctx)
+    private static async Task HandleFileCore(HttpContext ctx, string basePath)
     {
-        var sessionId = ctx.Request.Query["sessionId"].FirstOrDefault();
-        var filePath = ctx.Request.Query["path"].FirstOrDefault();
+        if (basePath == null) return;
 
+        var filePath = ctx.Request.Query["path"].FirstOrDefault();
         if (string.IsNullOrEmpty(filePath))
         {
             ctx.Response.StatusCode = 400;
             return;
         }
 
-        var result = await ResolveSessionWorkspace(ctx, sessionId);
-        if (result == null) return;
-        var (session, basePath) = result.Value;
-
         var targetPath = Path.GetFullPath(Path.Combine(basePath, filePath));
-
         if (!targetPath.StartsWith(basePath))
         {
             ctx.Response.StatusCode = 403;
@@ -162,8 +186,6 @@ public static class WorkspaceEndpoint
         }
 
         var info = new FileInfo(targetPath);
-
-        // Max 2MB für Textdateien
         if (info.Length > 2 * 1024 * 1024)
         {
             ctx.Response.StatusCode = 413;
@@ -184,33 +206,39 @@ public static class WorkspaceEndpoint
         });
     }
 
-    private static async Task HandleFileSave(HttpContext ctx)
+    private static async Task HandleFileSaveCore(HttpContext ctx, string basePath, bool allowCreate)
     {
-        var sessionId = ctx.Request.Query["sessionId"].FirstOrDefault();
-        var filePath = ctx.Request.Query["path"].FirstOrDefault();
+        if (basePath == null) return;
 
+        var filePath = ctx.Request.Query["path"].FirstOrDefault();
         if (string.IsNullOrEmpty(filePath))
         {
             ctx.Response.StatusCode = 400;
             return;
         }
 
-        var result = await ResolveSessionWorkspace(ctx, sessionId);
-        if (result == null) return;
-        var (session, basePath) = result.Value;
-
         var targetPath = Path.GetFullPath(Path.Combine(basePath, filePath));
-
         if (!targetPath.StartsWith(basePath))
         {
             ctx.Response.StatusCode = 403;
             return;
         }
 
-        if (!File.Exists(targetPath))
+        if (allowCreate)
         {
-            ctx.Response.StatusCode = 404;
-            return;
+            // Agent-Memory: Verzeichnis erstellen falls nötig
+            var dir = Path.GetDirectoryName(targetPath);
+            if (!string.IsNullOrEmpty(dir) && !Directory.Exists(dir))
+                Directory.CreateDirectory(dir);
+        }
+        else
+        {
+            // Session-Workspace: Datei muss existieren
+            if (!File.Exists(targetPath))
+            {
+                ctx.Response.StatusCode = 404;
+                return;
+            }
         }
 
         using var reader = new StreamReader(ctx.Request.Body);
@@ -230,6 +258,42 @@ public static class WorkspaceEndpoint
         });
     }
 
+    private static async Task HandleMkdirCore(HttpContext ctx, string basePath)
+    {
+        if (basePath == null) return;
+
+        var dirPath = ctx.Request.Query["path"].FirstOrDefault();
+        if (string.IsNullOrEmpty(dirPath))
+        {
+            ctx.Response.StatusCode = 400;
+            await ctx.Response.WriteAsJsonAsync(new { error = "Pfad fehlt" });
+            return;
+        }
+
+        var targetPath = Path.GetFullPath(Path.Combine(basePath, dirPath));
+        if (!targetPath.StartsWith(basePath))
+        {
+            ctx.Response.StatusCode = 403;
+            return;
+        }
+
+        if (Directory.Exists(targetPath))
+        {
+            ctx.Response.StatusCode = 409;
+            await ctx.Response.WriteAsJsonAsync(new { error = "Ordner existiert bereits" });
+            return;
+        }
+
+        Directory.CreateDirectory(targetPath);
+        await ctx.Response.WriteAsJsonAsync(new
+        {
+            path = Path.GetRelativePath(basePath, targetPath).Replace('\\', '/'),
+            created = true
+        });
+    }
+
+    // ── Sonstige Endpunkte ──────────────────────────────────────────────
+
     private static async Task HandleBrowse(HttpContext ctx)
     {
         var path = ctx.Request.Query["path"].FirstOrDefault() ?? "/";
@@ -277,7 +341,6 @@ public static class WorkspaceEndpoint
             return;
         }
 
-        // Parent muss existieren
         var parent = Path.GetDirectoryName(targetPath);
         if (string.IsNullOrEmpty(parent) || !Directory.Exists(parent))
         {
@@ -290,345 +353,6 @@ public static class WorkspaceEndpoint
         await ctx.Response.WriteAsJsonAsync(new { path = targetPath.Replace('\\', '/'), created = true });
     }
 
-    private static bool IsLikelyTextFile(string name)
-    {
-        var lower = name.ToLowerInvariant();
-        return lower is "makefile" or "dockerfile" or "rakefile" or "gemfile"
-            or "procfile" or "vagrantfile" or "license" or "readme"
-            or "changelog" or "authors" or "contributors";
-    }
-
-    private static string GetAgentBasePath(HttpContext ctx, out string error)
-    {
-        error = null;
-        var agentId = ctx.Request.Query["agentId"].FirstOrDefault();
-        if (string.IsNullOrEmpty(agentId))
-        {
-            error = "agentId fehlt";
-            return null;
-        }
-
-        var memoryService = ctx.RequestServices.GetRequiredService<Gott.Services.MemoryService>();
-        var basePath = memoryService.GetAgentMemoryDir(agentId);
-
-        if (!Directory.Exists(basePath))
-            Directory.CreateDirectory(basePath);
-
-        return basePath;
-    }
-
-    private static async Task HandleAgentTree(HttpContext ctx)
-    {
-        var basePath = GetAgentBasePath(ctx, out var error);
-        if (basePath == null)
-        {
-            ctx.Response.StatusCode = 400;
-            await ctx.Response.WriteAsJsonAsync(new { error });
-            return;
-        }
-
-        var subPath = ctx.Request.Query["path"].FirstOrDefault() ?? "";
-        var targetPath = Path.GetFullPath(Path.Combine(basePath, subPath));
-
-        if (!targetPath.StartsWith(basePath))
-        {
-            ctx.Response.StatusCode = 403;
-            return;
-        }
-
-        if (!Directory.Exists(targetPath))
-        {
-            ctx.Response.StatusCode = 404;
-            await ctx.Response.WriteAsJsonAsync(new { error = "Verzeichnis nicht gefunden" });
-            return;
-        }
-
-        var entries = new List<object>();
-
-        foreach (var dir in Directory.GetDirectories(targetPath).OrderBy(d => Path.GetFileName(d), StringComparer.OrdinalIgnoreCase))
-        {
-            var name = Path.GetFileName(dir);
-            if (IgnoredDirs.Contains(name)) continue;
-            var relPath = Path.GetRelativePath(basePath, dir).Replace('\\', '/');
-            entries.Add(new { name, path = relPath, type = "dir" });
-        }
-
-        foreach (var file in Directory.GetFiles(targetPath).OrderBy(f => Path.GetFileName(f), StringComparer.OrdinalIgnoreCase))
-        {
-            var name = Path.GetFileName(file);
-            var ext = Path.GetExtension(file);
-            var relPath = Path.GetRelativePath(basePath, file).Replace('\\', '/');
-            var size = new FileInfo(file).Length;
-            var isText = TextExtensions.Contains(ext) || IsLikelyTextFile(name);
-            entries.Add(new { name, path = relPath, type = "file", ext, size, isText });
-        }
-
-        await ctx.Response.WriteAsJsonAsync(entries);
-    }
-
-    private static async Task HandleAgentFile(HttpContext ctx)
-    {
-        var basePath = GetAgentBasePath(ctx, out var error);
-        if (basePath == null)
-        {
-            ctx.Response.StatusCode = 400;
-            await ctx.Response.WriteAsJsonAsync(new { error });
-            return;
-        }
-
-        var filePath = ctx.Request.Query["path"].FirstOrDefault();
-        if (string.IsNullOrEmpty(filePath))
-        {
-            ctx.Response.StatusCode = 400;
-            return;
-        }
-
-        var targetPath = Path.GetFullPath(Path.Combine(basePath, filePath));
-        if (!targetPath.StartsWith(basePath))
-        {
-            ctx.Response.StatusCode = 403;
-            return;
-        }
-
-        if (!File.Exists(targetPath))
-        {
-            ctx.Response.StatusCode = 404;
-            return;
-        }
-
-        var info = new FileInfo(targetPath);
-        if (info.Length > 2 * 1024 * 1024)
-        {
-            ctx.Response.StatusCode = 413;
-            await ctx.Response.WriteAsJsonAsync(new { error = "Datei zu groß (max. 2MB)" });
-            return;
-        }
-
-        var content = await File.ReadAllTextAsync(targetPath);
-        var lineCount = content.Split('\n').Length;
-
-        await ctx.Response.WriteAsJsonAsync(new
-        {
-            path = filePath,
-            name = info.Name,
-            size = info.Length,
-            lineCount,
-            content
-        });
-    }
-
-    private static async Task HandleAgentFileSave(HttpContext ctx)
-    {
-        var basePath = GetAgentBasePath(ctx, out var error);
-        if (basePath == null)
-        {
-            ctx.Response.StatusCode = 400;
-            await ctx.Response.WriteAsJsonAsync(new { error });
-            return;
-        }
-
-        var filePath = ctx.Request.Query["path"].FirstOrDefault();
-        if (string.IsNullOrEmpty(filePath))
-        {
-            ctx.Response.StatusCode = 400;
-            return;
-        }
-
-        var targetPath = Path.GetFullPath(Path.Combine(basePath, filePath));
-        if (!targetPath.StartsWith(basePath))
-        {
-            ctx.Response.StatusCode = 403;
-            return;
-        }
-
-        // Verzeichnis erstellen falls nötig
-        var dir = Path.GetDirectoryName(targetPath);
-        if (!string.IsNullOrEmpty(dir) && !Directory.Exists(dir))
-            Directory.CreateDirectory(dir);
-
-        using var reader = new StreamReader(ctx.Request.Body);
-        var content = await reader.ReadToEndAsync();
-
-        await File.WriteAllTextAsync(targetPath, content);
-
-        var info = new FileInfo(targetPath);
-        var lineCount = content.Split('\n').Length;
-
-        await ctx.Response.WriteAsJsonAsync(new
-        {
-            path = filePath,
-            name = info.Name,
-            size = info.Length,
-            lineCount
-        });
-    }
-
-    private static async Task HandleMkdir(HttpContext ctx)
-    {
-        var sessionId = ctx.Request.Query["sessionId"].FirstOrDefault();
-        var dirPath = ctx.Request.Query["path"].FirstOrDefault();
-
-        if (string.IsNullOrEmpty(dirPath))
-        {
-            ctx.Response.StatusCode = 400;
-            await ctx.Response.WriteAsJsonAsync(new { error = "Pfad fehlt" });
-            return;
-        }
-
-        var result = await ResolveSessionWorkspace(ctx, sessionId);
-        if (result == null) return;
-        var (session, basePath) = result.Value;
-
-        var targetPath = Path.GetFullPath(Path.Combine(basePath, dirPath));
-
-        if (!targetPath.StartsWith(basePath))
-        {
-            ctx.Response.StatusCode = 403;
-            return;
-        }
-
-        if (Directory.Exists(targetPath))
-        {
-            ctx.Response.StatusCode = 409;
-            await ctx.Response.WriteAsJsonAsync(new { error = "Ordner existiert bereits" });
-            return;
-        }
-
-        Directory.CreateDirectory(targetPath);
-        await ctx.Response.WriteAsJsonAsync(new { path = dirPath, created = true });
-    }
-
-    private static async Task HandleRmdir(HttpContext ctx)
-    {
-        var sessionId = ctx.Request.Query["sessionId"].FirstOrDefault();
-        var dirPath = ctx.Request.Query["path"].FirstOrDefault();
-
-        if (string.IsNullOrEmpty(dirPath))
-        {
-            ctx.Response.StatusCode = 400;
-            await ctx.Response.WriteAsJsonAsync(new { error = "Pfad fehlt" });
-            return;
-        }
-
-        var result = await ResolveSessionWorkspace(ctx, sessionId);
-        if (result == null) return;
-        var (session, basePath) = result.Value;
-
-        var targetPath = Path.GetFullPath(Path.Combine(basePath, dirPath));
-
-        if (!targetPath.StartsWith(basePath) || targetPath == basePath)
-        {
-            ctx.Response.StatusCode = 403;
-            return;
-        }
-
-        if (!Directory.Exists(targetPath))
-        {
-            ctx.Response.StatusCode = 404;
-            await ctx.Response.WriteAsJsonAsync(new { error = "Ordner nicht gefunden" });
-            return;
-        }
-
-        if (Directory.GetFileSystemEntries(targetPath).Length > 0)
-        {
-            ctx.Response.StatusCode = 409;
-            await ctx.Response.WriteAsJsonAsync(new { error = "Ordner ist nicht leer" });
-            return;
-        }
-
-        Directory.Delete(targetPath);
-        await ctx.Response.WriteAsJsonAsync(new { path = dirPath, deleted = true });
-    }
-
-    private static async Task HandleAgentMkdir(HttpContext ctx)
-    {
-        var basePath = GetAgentBasePath(ctx, out var error);
-        if (basePath == null)
-        {
-            ctx.Response.StatusCode = 400;
-            await ctx.Response.WriteAsJsonAsync(new { error });
-            return;
-        }
-
-        var dirPath = ctx.Request.Query["path"].FirstOrDefault();
-        if (string.IsNullOrEmpty(dirPath))
-        {
-            ctx.Response.StatusCode = 400;
-            await ctx.Response.WriteAsJsonAsync(new { error = "Pfad fehlt" });
-            return;
-        }
-
-        var targetPath = Path.GetFullPath(Path.Combine(basePath, dirPath));
-        if (!targetPath.StartsWith(basePath))
-        {
-            ctx.Response.StatusCode = 403;
-            return;
-        }
-
-        if (Directory.Exists(targetPath))
-        {
-            ctx.Response.StatusCode = 409;
-            await ctx.Response.WriteAsJsonAsync(new { error = "Ordner existiert bereits" });
-            return;
-        }
-
-        Directory.CreateDirectory(targetPath);
-        await ctx.Response.WriteAsJsonAsync(new { path = dirPath, created = true });
-    }
-
-    private static async Task HandleAgentRmdir(HttpContext ctx)
-    {
-        var basePath = GetAgentBasePath(ctx, out var error);
-        if (basePath == null)
-        {
-            ctx.Response.StatusCode = 400;
-            await ctx.Response.WriteAsJsonAsync(new { error });
-            return;
-        }
-
-        var dirPath = ctx.Request.Query["path"].FirstOrDefault();
-        if (string.IsNullOrEmpty(dirPath))
-        {
-            ctx.Response.StatusCode = 400;
-            await ctx.Response.WriteAsJsonAsync(new { error = "Pfad fehlt" });
-            return;
-        }
-
-        var targetPath = Path.GetFullPath(Path.Combine(basePath, dirPath));
-        if (!targetPath.StartsWith(basePath) || targetPath == basePath)
-        {
-            ctx.Response.StatusCode = 403;
-            return;
-        }
-
-        if (!Directory.Exists(targetPath))
-        {
-            ctx.Response.StatusCode = 404;
-            await ctx.Response.WriteAsJsonAsync(new { error = "Ordner nicht gefunden" });
-            return;
-        }
-
-        if (Directory.GetFileSystemEntries(targetPath).Length > 0)
-        {
-            ctx.Response.StatusCode = 409;
-            await ctx.Response.WriteAsJsonAsync(new { error = "Ordner ist nicht leer" });
-            return;
-        }
-
-        Directory.Delete(targetPath);
-        await ctx.Response.WriteAsJsonAsync(new { path = dirPath, deleted = true });
-    }
-
-    private static readonly Dictionary<string, string> MimeTypes = new(StringComparer.OrdinalIgnoreCase)
-    {
-        { ".png", "image/png" }, { ".jpg", "image/jpeg" }, { ".jpeg", "image/jpeg" },
-        { ".gif", "image/gif" }, { ".webp", "image/webp" }, { ".svg", "image/svg+xml" },
-        { ".bmp", "image/bmp" }, { ".ico", "image/x-icon" },
-        { ".pdf", "application/pdf" },
-        { ".mp4", "video/mp4" }, { ".webm", "video/webm" },
-        { ".mp3", "audio/mpeg" }, { ".wav", "audio/wav" }, { ".ogg", "audio/ogg" },
-    };
-
     private static async Task HandleRawFile(HttpContext ctx)
     {
         var sessionId = ctx.Request.Query["sessionId"].FirstOrDefault();
@@ -640,12 +364,10 @@ public static class WorkspaceEndpoint
             return;
         }
 
-        var result = await ResolveSessionWorkspace(ctx, sessionId);
-        if (result == null) return;
-        var basePath = result.Value.basePath;
+        var basePath = await ResolveSessionBasePath(ctx);
+        if (basePath == null) return;
 
         var targetPath = Path.GetFullPath(Path.Combine(basePath, filePath));
-
         if (!targetPath.StartsWith(basePath))
         {
             ctx.Response.StatusCode = 403;
@@ -658,11 +380,30 @@ public static class WorkspaceEndpoint
             return;
         }
 
-        var ext = Path.GetExtension(targetPath);
-        var contentType = MimeTypes.GetValueOrDefault(ext, "application/octet-stream");
+        var ext = Path.GetExtension(targetPath).ToLowerInvariant();
+        ctx.Response.ContentType = ext switch
+        {
+            ".png" => "image/png",
+            ".jpg" or ".jpeg" => "image/jpeg",
+            ".gif" => "image/gif",
+            ".webp" => "image/webp",
+            ".svg" => "image/svg+xml",
+            ".pdf" => "application/pdf",
+            ".mp4" => "video/mp4",
+            ".webm" => "video/webm",
+            ".mp3" => "audio/mpeg",
+            ".wav" => "audio/wav",
+            _ => "application/octet-stream"
+        };
 
-        ctx.Response.ContentType = contentType;
-        ctx.Response.Headers["Cache-Control"] = "private, max-age=3600";
         await ctx.Response.SendFileAsync(targetPath);
     }
+
+    private static bool IsLikelyTextFile(string name)
+    {
+        var lower = name.ToLowerInvariant();
+        return lower is "makefile" or "dockerfile" or "rakefile" or "gemfile"
+            or "procfile" or "vagrantfile" or "license" or "readme"
+            or "changelog" or "authors" or "contributors";
+    }
 }