fix ai asistance and make it per user friendly isolated enviroment

.agent/memory/session.json

@@ -1,7 +1,7 @@
 {
   "version": "1.0.0",
-  "session_id": "50325c3e",
-  "started_at": "2026-03-25T19:43:17.315877+05:30",
+  "session_id": "f5a7d65f",
+  "started_at": "2026-03-25T20:17:36.335488+05:30",
   "workspace": "D:\\Code\\codeverse",
   "active_task_id": null,
   "active_agent": null,

app/api/agent/route.ts

@@ -1,16 +1,89 @@
-import { streamText, generateObject, LanguageModel } from "ai";
+import { 
+    streamText, 
+    generateObject, 
+    LanguageModel, 
+    AssistantModelMessage, 
+    UserModelMessage, 
+    SystemModelMessage, 
+    ToolModelMessage 
+} from "ai";
 import { z } from "zod";
 import { getModel } from "@/lib/agents/registry";
-import { coreTools } from "@/lib/mcp/tools";
-import { NextRequest } from "next/server";
+import { createTools } from "@/lib/mcp/tools";
+import { auth } from "@/auth";
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import { randomUUID } from "crypto";
+
+// Define a strict union type for core messages to avoid 'any'
+type CoreChatMessage = 
+    | UserModelMessage 
+    | AssistantModelMessage 
+    | SystemModelMessage 
+    | ToolModelMessage;
 
 export async function POST(req: NextRequest) {
+    const session = await auth();
+    if (!session?.user?.id) return new Response("Unauthorized", { status: 401 });
+    const userId = session.user.id;
+
     try {
-        const { messages, modelId, mode = "execute", systemPrompt } = await req.json();
-        const model: LanguageModel = getModel(modelId, req);
+        const { messages, modelId, workspaceName, mode = "execute" } = await req.json() as {
+            messages: CoreChatMessage[];
+            modelId?: string;
+            workspaceName: string;
+            mode?: "plan" | "execute";
+        };
+        
+        if (!workspaceName) return new Response("Missing workspaceName", { status: 400 });
+
+        // Resolve workspaceId
+        const wsRes = await db.execute({
+            sql: "SELECT id FROM workspaces WHERE user_id = ? AND project_name = ?",
+            args: [userId, workspaceName]
+        });
+
+        if (wsRes.rows.length === 0) {
+            return new Response("Workspace not found", { status: 404 });
+        }
+        const workspaceId = wsRes.rows[0].id as string;
+
+        const model: LanguageModel = getModel(modelId as string, req);
+        const tools = createTools(userId, workspaceName);
+
+        const systemPrompt = `You are CodeVerse AI, a world-class autonomous coding agent. 
+You are embedded in a premium "AI Studio" environment. 
+Current Workspace: ${workspaceName} (Path: workspaces/${userId}/${workspaceName}/)
+
+CORE PRINCIPLES:
+1. PLAN BEFORE ACTION: Always explain high-level strategy before using tools.
+2. PRECISION: Read files before editing. Ensure syntax is correct.
+3. CONTEXT AWARENESS: You are part of an IDE. Help with refactoring, debugging, and feature development.
+4. SAFETY: You have shell access but should remain within the workspace. Never attempt to escape the sandbox.
+
+You have access to:
+- read_file: View content.
+- write_file: Create/edit files (overwrite mode).
+- terminal_command: Run builds, tests, or scripts.
+- search_code: Find patterns.
+- list_files: Explore structure.
+
+Respond in professional Markdown. Use code blocks for all technical output.`;
+
+        // Save incoming user message to history
+        const latestMessage = messages[messages.length - 1];
+        if (latestMessage && latestMessage.role === "user") {
+            const content = Array.isArray(latestMessage.content) 
+                ? latestMessage.content.map(p => ('text' in p ? p.text : '')).join('')
+                : latestMessage.content;
+                
+            await db.execute({
+                sql: "INSERT INTO chat_history (id, user_id, workspace_id, role, content) VALUES (?, ?, ?, ?, ?)",
+                args: [randomUUID(), userId as string, workspaceId as string, latestMessage.role, content]
+            });
+        }
 
         if (mode === "plan") {
-            // In plan mode, we don't stream immediately. We generate a structured JSON plan first.
             const result = await generateObject({
                 model,
                 system: systemPrompt,
@@ -27,22 +100,75 @@ export async function POST(req: NextRequest) {
                 }),
             });
 
-            return new Response(JSON.stringify(result.object), {
-                headers: { "Content-Type": "application/json" }
-            });
+            return NextResponse.json(result.object);
         }
 
-        // Execute mode: Standard stream-text with workspace tool calls enabled
         const result = streamText({
             model,
             system: systemPrompt,
             messages,
-            tools: coreTools,
+            tools, // Assuming createTools returns compatible types now
+            onFinish: async (completion) => {
+                // Save assistant response to DB
+                try {
+                    await db.execute({
+                        sql: "INSERT INTO chat_history (id, user_id, workspace_id, role, content, tool_invocations) VALUES (?, ?, ?, ?, ?, ?)",
+                        args: [
+                            randomUUID(), 
+                            userId as string, 
+                            workspaceId as string, 
+                            "assistant", 
+                            completion.text, 
+                            JSON.stringify(completion.toolCalls || [])
+                        ]
+                    });
+                } catch (dbErr) {
+                    console.error("Failed to save assistant response to history:", dbErr);
+                }
+            }
         });
 
         return result.toTextStreamResponse();
     } catch (e: unknown) {
+        console.error("[AGENT_ROUTE_ERROR]", e);
         const error = e instanceof Error ? e : new Error(String(e));
         return new Response(JSON.stringify({ error: error.message }), { status: 500 });
     }
 }
+
+export async function GET(req: NextRequest) {
+    const session = await auth();
+    if (!session?.user?.id) return new Response("Unauthorized", { status: 401 });
+    const userId = session.user.id;
+
+    const { searchParams } = new URL(req.url);
+    const workspaceName = searchParams.get("workspaceName");
+    if (!workspaceName) return new Response("Missing workspaceName", { status: 400 });
+
+    try {
+        const wsRes = await db.execute({
+            sql: "SELECT id FROM workspaces WHERE user_id = ? AND project_name = ?",
+            args: [userId, workspaceName]
+        });
+
+        if (wsRes.rows.length === 0) return NextResponse.json({ messages: [] });
+        const workspaceId = wsRes.rows[0].id as string;
+
+        const res = await db.execute({
+            sql: "SELECT role, content, tool_invocations as toolInvocations, created_at FROM chat_history WHERE user_id = ? AND workspace_id = ? ORDER BY created_at ASC",
+            args: [userId, workspaceId]
+        });
+
+        const messages = res.rows.map(row => ({
+            id: randomUUID(),
+            role: row.role as string,
+            content: row.content as string,
+            toolInvocations: row.toolInvocations ? JSON.parse(row.toolInvocations as string) : undefined
+        }));
+
+        return NextResponse.json({ messages });
+    } catch (e) {
+        console.error("[FETCH_HISTORY_ERROR]", e);
+        return NextResponse.json({ messages: [] });
+    }
+}

app/api/fs/route.ts

@@ -1,50 +1,62 @@
 import { NextRequest, NextResponse } from "next/server";
 import { readDir, readFile, writeFile, deletePath } from "@/lib/fs";
+import { auth } from "@/auth";
+import { resolveSafePath } from "@/lib/fs/isolation";
 
 export async function GET(req: NextRequest) {
+    const session = await auth();
+    if (!session?.user?.id) return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+
     const { searchParams } = new URL(req.url);
-    const path = searchParams.get("path") || "";
+    const subPath = searchParams.get("path") || "";
     const action = searchParams.get("action") || "list";
 
     try {
+        const fullPath = await resolveSafePath(session.user.id, subPath);
+
         if (action === "list") {
-            const nodes = await readDir(path);
+            const nodes = await readDir(fullPath);
             return NextResponse.json(nodes);
         }
         if (action === "read") {
-            const content = await readFile(path);
+            const content = await readFile(fullPath);
             return NextResponse.json({ content });
         }
         return NextResponse.json({ error: "Invalid action" }, { status: 400 });
     } catch (e: unknown) {
-        const error = e instanceof Error ? e : new Error(String(e));
-        return NextResponse.json({ error: error.message }, { status: 500 });
+        return NextResponse.json({ error: (e as Error).message }, { status: 500 });
     }
 }
 
 export async function POST(req: NextRequest) {
+    const session = await auth();
+    if (!session?.user?.id) return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+
     try {
-        const { path, content } = await req.json();
-        if (!path) return NextResponse.json({ error: "Path required" }, { status: 400 });
+        const { path: subPath, content } = await req.json();
+        if (!subPath) return NextResponse.json({ error: "Path required" }, { status: 400 });
 
-        await writeFile(path, content);
+        const fullPath = await resolveSafePath(session.user.id, subPath);
+        await writeFile(fullPath, content);
         return NextResponse.json({ success: true });
     } catch (e: unknown) {
-        const error = e instanceof Error ? e : new Error(String(e));
-        return NextResponse.json({ error: error.message }, { status: 500 });
+        return NextResponse.json({ error: (e as Error).message }, { status: 500 });
     }
 }
 
 export async function DELETE(req: NextRequest) {
+    const session = await auth();
+    if (!session?.user?.id) return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+
     const { searchParams } = new URL(req.url);
-    const path = searchParams.get("path");
+    const subPath = searchParams.get("path");
 
     try {
-        if (!path) return NextResponse.json({ error: "Path required" }, { status: 400 });
-        await deletePath(path);
+        if (!subPath) return NextResponse.json({ error: "Path required" }, { status: 400 });
+        const fullPath = await resolveSafePath(session.user.id, subPath);
+        await deletePath(fullPath);
         return NextResponse.json({ success: true });
     } catch (e: unknown) {
-        const error = e instanceof Error ? e : new Error(String(e));
-        return NextResponse.json({ error: error.message }, { status: 500 });
+        return NextResponse.json({ error: (e as Error).message }, { status: 500 });
     }
 }

app/api/git/route.ts

@@ -7,29 +7,41 @@ import {
     pushBranch,
     pullBranch,
     checkoutBranch,
-    git
+    getGit
 } from "@/lib/git";
+import { auth } from "@/auth";
+import { resolveSafePath } from "@/lib/fs/isolation";
 
 export async function GET(req: NextRequest) {
+    const session = await auth();
+    if (!session?.user?.id) return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+
     const { searchParams } = new URL(req.url);
     const action = searchParams.get("action");
+    const workspaceName = searchParams.get("workspaceName"); 
+
+    if (!workspaceName) return NextResponse.json({ error: "workspaceName required" }, { status: 400 });
 
     try {
+        const userId = session.user.id;
+        const baseDir = await resolveSafePath(userId, workspaceName);
+
         switch (action) {
             case "status":
-                return NextResponse.json(await getGitStatus());
+                return NextResponse.json(await getGitStatus(baseDir));
             case "branches":
-                return NextResponse.json(await getBranchList());
+                return NextResponse.json(await getBranchList(baseDir));
             case "diff":
                 const file = searchParams.get("file");
                 if (!file) return NextResponse.json({ error: "File required" }, { status: 400 });
-                return NextResponse.json({ diff: await getFileDiff(file) });
+                return NextResponse.json({ diff: await getFileDiff(file, baseDir) });
             case "log":
-                const log = await git.log({ maxCount: 50 });
+                const log = await getGit(baseDir).log({ maxCount: 50 });
                 return NextResponse.json(log.all);
             case "checkConfig":
-                const name = await git.getConfig("user.name", "local");
-                const email = await git.getConfig("user.email", "local");
+                const instance = getGit(baseDir);
+                const name = await instance.getConfig("user.name", "local");
+                const email = await instance.getConfig("user.email", "local");
                 return NextResponse.json({
                     configured: !!(name.value && email.value),
                     name: name.value,
@@ -39,46 +51,51 @@ export async function GET(req: NextRequest) {
                 return NextResponse.json({ error: "Invalid action" }, { status: 400 });
         }
     } catch (e: unknown) {
-        const error = e instanceof Error ? e : new Error(String(e));
-        return NextResponse.json({ error: error.message }, { status: 500 });
+        return NextResponse.json({ error: (e as Error).message }, { status: 500 });
     }
 }
 
 export async function POST(req: NextRequest) {
+    const session = await auth();
+    if (!session?.user?.id) return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+
     try {
         const body = await req.json();
-        const { action } = body;
+        const { action, workspaceName } = body;
+        if (!workspaceName) return NextResponse.json({ error: "Workspace required" }, { status: 400 });
+
+        const baseDir = await resolveSafePath(session.user.id, workspaceName);
 
         switch (action) {
             case "commit":
                 if (!body.message) return NextResponse.json({ error: "Message required" }, { status: 400 });
-                const res = await commitFiles(body.message, body.files);
+                const res = await commitFiles(body.message, body.files, baseDir);
                 return NextResponse.json({ success: true, commit: res.commit });
 
             case "push":
-                await pushBranch();
+                await pushBranch(baseDir);
                 return NextResponse.json({ success: true });
 
             case "pull":
-                await pullBranch();
+                await pullBranch(baseDir);
                 return NextResponse.json({ success: true });
 
             case "checkout":
                 if (!body.branch) return NextResponse.json({ error: "Branch required" }, { status: 400 });
-                await checkoutBranch(body.branch, body.create);
+                await checkoutBranch(body.branch, body.create, baseDir);
                 return NextResponse.json({ success: true });
 
             case "setConfig":
                 if (!body.name || !body.email) return NextResponse.json({ error: "Name and email required" }, { status: 400 });
-                await git.addConfig("user.name", body.name, false, "local");
-                await git.addConfig("user.email", body.email, false, "local");
+                const instance = getGit(baseDir);
+                await instance.addConfig("user.name", body.name, false, "local");
+                await instance.addConfig("user.email", body.email, false, "local");
                 return NextResponse.json({ success: true });
 
             default:
                 return NextResponse.json({ error: "Invalid action" }, { status: 400 });
         }
     } catch (e: unknown) {
-        const error = e instanceof Error ? e : new Error(String(e));
-        return NextResponse.json({ error: error.message }, { status: 500 });
+        return NextResponse.json({ error: (e as Error).message }, { status: 500 });
     }
 }

app/api/lsp/route.ts

@@ -1,5 +1,7 @@
 import { NextRequest, NextResponse } from "next/server";
 import { spawn } from "child_process";
+import { auth } from "@/auth";
+import { resolveSafePath } from "@/lib/fs/isolation";
 
 // Language Server mapping: extension → command to start the language server
 const LSP_SERVERS: Record<string, { cmd: string; args: string[] }> = {
@@ -15,6 +17,10 @@ const LSP_SERVERS: Record<string, { cmd: string; args: string[] }> = {
 const activeServers = new Map<string, ReturnType<typeof spawn>>();
 
 export async function GET(req: NextRequest) {
+    const session = await auth();
+    if (!session?.user?.id) return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+    const userId = session.user.id;
+
     const { searchParams } = new URL(req.url);
     const lang = searchParams.get("lang");
 
@@ -22,7 +28,7 @@ export async function GET(req: NextRequest) {
         return NextResponse.json({
             available: Object.keys(LSP_SERVERS),
             status: Object.fromEntries(
-                Object.keys(LSP_SERVERS).map(l => [l, activeServers.has(l) ? "running" : "idle"])
+                Object.keys(LSP_SERVERS).map(l => [l, activeServers.has(`${userId}:${l}`) ? "running" : "idle"])
             )
         });
     }
@@ -40,49 +46,57 @@ export async function GET(req: NextRequest) {
 }
 
 export async function POST(req: NextRequest) {
+    const session = await auth();
+    if (!session?.user?.id) return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+    const userId = session.user.id;
+
     try {
-        const { action, lang } = await req.json();
+        const { action, lang, workspaceName } = await req.json();
 
         if (action === "start") {
             if (!lang) return NextResponse.json({ error: "lang required" }, { status: 400 });
+            if (!workspaceName) return NextResponse.json({ error: "workspaceName required" }, { status: 400 });
 
             const config = LSP_SERVERS[lang];
             if (!config) return NextResponse.json({ error: `No LSP for .${lang}` }, { status: 404 });
 
-            if (activeServers.has(lang)) {
+            const serverKey = `${userId}:${lang}`;
+            if (activeServers.has(serverKey)) {
                 return NextResponse.json({ status: "already_running" });
             }
 
             try {
+                const projectRoot = await resolveSafePath(userId, workspaceName);
                 const proc = spawn(config.cmd, config.args, {
-                    cwd: process.cwd(),
+                    cwd: projectRoot,
                     stdio: ["pipe", "pipe", "pipe"],
                     shell: process.platform === "win32"
                 });
 
-                activeServers.set(lang, proc);
+                activeServers.set(serverKey, proc);
 
-                proc.on("exit", () => activeServers.delete(lang));
+                proc.on("exit", () => activeServers.delete(serverKey));
                 proc.on("error", (err) => {
-                    console.warn(`LSP ${lang}: ${err.message} — install ${config.cmd} to enable`);
-                    activeServers.delete(lang);
+                    console.warn(`LSP ${lang} for ${userId}: ${err.message}`);
+                    activeServers.delete(serverKey);
                 });
 
                 return NextResponse.json({ status: "started", pid: proc.pid });
-            } catch {
+            } catch (e: unknown) {
                 return NextResponse.json({
                     status: "unavailable",
-                    message: `Install '${config.cmd}' to enable LSP for .${lang} files.`
+                    message: (e as Error).message
                 });
             }
         }
 
         if (action === "stop") {
             if (!lang) return NextResponse.json({ error: "lang required" }, { status: 400 });
-            const proc = activeServers.get(lang);
+            const serverKey = `${userId}:${lang}`;
+            const proc = activeServers.get(serverKey);
             if (proc) {
                 proc.kill();
-                activeServers.delete(lang);
+                activeServers.delete(serverKey);
             }
             return NextResponse.json({ status: "stopped" });
         }

app/api/projects/route.ts

@@ -1,5 +1,4 @@
 import { NextRequest, NextResponse } from "next/server";
-import path from "path";
 import fs from "fs/promises";
 import simpleGit from "simple-git";
 import { spawn } from "child_process";
@@ -8,11 +7,9 @@ import { auth } from "@/auth";
 import { db } from "@/lib/db";
 import { randomUUID } from "crypto";
 
-const WORKSPACE_ROOT = path.join(process.cwd(), "workspaces");
+import { resolveSafePath } from "@/lib/fs/isolation";
 
-async function ensureWorkspaceRoot() {
-    await fs.mkdir(WORKSPACE_ROOT, { recursive: true });
-}
+// Removed global WORKSPACE_ROOT
 
 // POST /api/projects
 export async function POST(req: NextRequest) {
@@ -37,7 +34,11 @@ export async function POST(req: NextRequest) {
 }
 
 export async function GET() {
-    return handleList();
+    const session = await auth();
+    if (!session?.user?.id) {
+        return NextResponse.json({ projects: [] });
+    }
+    return handleList(session.user.id);
 }
 
 export async function DELETE(req: NextRequest) {
@@ -65,13 +66,9 @@ export async function DELETE(req: NextRequest) {
         }
 
         const projectName = res.rows[0].project_name as string;
-        const safeName = projectName.replace(/[^a-zA-Z0-9-_]/g, "-").slice(0, 60);
-
-        // Remove from filesystem
-        const targetPath = path.join(WORKSPACE_ROOT, safeName);
-        if (targetPath.startsWith(WORKSPACE_ROOT)) {
-            await fs.rm(targetPath, { recursive: true, force: true });
-        }
+        const targetPath = await resolveSafePath(session.user.id, projectName.replace(/[^a-zA-Z0-9-_]/g, "-").slice(0, 60));
+        
+        await fs.rm(targetPath, { recursive: true, force: true });
 
         // Remove from database
         await db.execute({
@@ -88,30 +85,29 @@ export async function DELETE(req: NextRequest) {
     }
 }
 
-async function handleList() {
-    const session = await auth();
-    if (!session?.user?.id) {
-        return NextResponse.json({ projects: [] });
-    }
-
+async function handleList(userId: string) {
     try {
         const res = await db.execute({
             sql: "SELECT * FROM workspaces WHERE user_id = ?",
-            args: [session.user.id]
+            args: [userId]
         });
 
-        const projects = res.rows.map(row => ({
-            id: row.id,
-            name: row.project_name,
-            path: path.join(WORKSPACE_ROOT, (row.project_name as string).replace(/[^a-zA-Z0-9-_]/g, "-").slice(0, 60)),
-            containerStatus: row.status,
-            gitRemote: "", // We could fetch this on demand or ignore it for the DB view
-            hasPackageJson: true,
-            starred: false
+        const projects = await Promise.all(res.rows.map(async row => {
+            const safeName = (row.project_name as string).replace(/[^a-zA-Z0-9-_]/g, "-").slice(0, 60);
+            return {
+                id: row.id,
+                name: row.project_name,
+                path: await resolveSafePath(userId, safeName),
+                containerStatus: row.status,
+                gitRemote: "", 
+                hasPackageJson: true,
+                starred: false
+            };
         }));
 
         return NextResponse.json({ projects });
-    } catch {
+    } catch (e) {
+        console.error("[PROJECTS_LIST_ERROR]", e);
         return NextResponse.json({ projects: [] });
     }
 }
@@ -122,9 +118,8 @@ async function handleClone(req: NextRequest, userId: string) {
         return NextResponse.json({ error: "repoUrl and projectName are required" }, { status: 400 });
     }
 
-    await ensureWorkspaceRoot();
     const safeName = projectName.replace(/[^a-zA-Z0-9-_]/g, "-").slice(0, 60);
-    const dest = path.join(WORKSPACE_ROOT, safeName);
+    const dest = await resolveSafePath(userId, safeName);
 
     // Stream progress via SSE
     const encoder = new TextEncoder();
@@ -173,9 +168,8 @@ async function handleScaffold(req: NextRequest, userId: string) {
         return NextResponse.json({ error: "templateId and projectName are required" }, { status: 400 });
     }
 
-    await ensureWorkspaceRoot();
     const safeName = projectName.replace(/[^a-zA-Z0-9-_]/g, "-").slice(0, 60);
-    const dest = path.join(WORKSPACE_ROOT, safeName);
+    const dest = await resolveSafePath(userId, safeName);
     await fs.mkdir(dest, { recursive: true });
 
     // Template scaffold commands (IDs must exactly match TEMPLATE_REGISTRY ids in constants/extensions.ts)

app/api/workspace/route.ts

@@ -49,9 +49,9 @@ export async function POST(req: Request) {
             return NextResponse.json({ error: "Missing workspace id" }, { status: 400 });
         }
 
-        // Verify ownership
+        // Verify ownership and get project name
         const verifyObj = await db.execute({
-            sql: "SELECT id FROM workspaces WHERE id = ? AND user_id = ?",
+            sql: "SELECT id, project_name FROM workspaces WHERE id = ? AND user_id = ?",
             args: [id, session.user.id]
         });
 
@@ -59,9 +59,17 @@ export async function POST(req: Request) {
             return NextResponse.json({ error: "Workspace not found or unauthorized" }, { status: 404 });
         }
 
+        const projectName = verifyObj.rows[0].project_name as string;
+
         if (action === "start") {
             const { withAndroidEmulator } = body;
-            const result = await startWorkspaceContainer({ id, image, withAndroidEmulator });
+            const result = await startWorkspaceContainer({ 
+                id, 
+                userId: session.user.id, 
+                projectName,
+                image, 
+                withAndroidEmulator 
+            });
             if (result.success) {
                 await db.execute({
                     sql: "UPDATE workspaces SET status = 'running', container_id = ?, android_container_id = ?, android_port = ? WHERE id = ?",
@@ -84,7 +92,13 @@ export async function POST(req: Request) {
             await stopWorkspaceContainer(id, true);
 
             // 2. Recreate them (this will pick up codeverse.json changes)
-            const result = await startWorkspaceContainer({ id, image, withAndroidEmulator });
+            const result = await startWorkspaceContainer({ 
+                id, 
+                userId: session.user.id, 
+                projectName,
+                image, 
+                withAndroidEmulator 
+            });
 
             if (result.success) {
                 await db.execute({

app/api/workspace/stream/route.ts

@@ -1,9 +1,15 @@
 import { NextRequest } from 'next/server';
 import { startWorkspaceContainer } from '@/lib/docker/manager';
+import { auth } from '@/auth';
+import { db } from '@/lib/db';
 
 export const dynamic = 'force-dynamic';
 
 export async function GET(req: NextRequest) {
+    const session = await auth();
+    if (!session?.user?.id) return new Response('Unauthorized', { status: 401 });
+    const userId = session.user.id;
+
     const searchParams = req.nextUrl.searchParams;
     const id = searchParams.get('id');
     const withAndroid = searchParams.get('withAndroid') === 'true';
@@ -12,6 +18,18 @@ export async function GET(req: NextRequest) {
         return new Response('Missing workspace id', { status: 400 });
     }
 
+    // Verify ownership and get project name
+    const verifyObj = await db.execute({
+        sql: "SELECT project_name FROM workspaces WHERE id = ? AND user_id = ?",
+        args: [id, session.user.id]
+    });
+
+    if (verifyObj.rows.length === 0) {
+        return new Response('Workspace not found or unauthorized', { status: 404 });
+    }
+
+    const projectName = verifyObj.rows[0].project_name as string;
+
     const encoder = new TextEncoder();
 
     const stream = new ReadableStream({
@@ -24,9 +42,13 @@ export async function GET(req: NextRequest) {
 
             try {
                 // Initialize workspace and pipe logs directly from the Docker builder engine to SSE client
-                const result = await startWorkspaceContainer(
-                    { id, withAndroidEmulator: withAndroid, onLog: (msg) => sendEvent('log', msg) }
-                );
+                const result = await startWorkspaceContainer({ 
+                    id: id as string, 
+                    userId: userId,
+                    projectName: projectName,
+                    withAndroidEmulator: withAndroid, 
+                    onLog: (msg) => sendEvent('log', msg) 
+                });
                 
                 // Completed
                 sendEvent('ready', {

auth.ts

@@ -205,6 +205,7 @@ const TursoAdapter = {
 const authOptions = {
   adapter: TursoAdapter as unknown as Adapter,
   trustHost: true,
+  secret: process.env.AUTH_SECRET,
   providers: [
     GitHubProvider({
       clientId: process.env.GITHUB_ID ?? "",

components/dashboard/Dashboard.tsx

@@ -190,8 +190,8 @@ export default function Dashboard() {
                     <div className="h-4 w-px bg-(--border)" />
                     <div className="flex items-center gap-3 pl-1">
                         <div className="flex flex-col items-end">
-                            <span className="text-sm font-semibold text-(--text) leading-tight">{session?.user?.name || "Developer"}</span>
-                            <span className="text-[10px] text-(--text-muted) font-mono">{session?.user?.email || "studio@domain.com"}</span>
+                            <span className="text-sm font-semibold text-(--text) leading-tight">{session?.user?.name || "User"}</span>
+                            <span className="text-[10px] text-(--text-muted) font-mono">{session?.user?.email || "anonymous@codeverse.io"}</span>
                         </div>
                         {session?.user?.image ? (
                             <Image unoptimized src={session.user.image} alt="Profile" width={36} height={36} className="w-9 h-9 rounded-full ring-2 ring-(--border-subtle)" />
@@ -211,7 +211,7 @@ export default function Dashboard() {
                     {/* Greeting */}
                     <div>
                         <h1 className="text-2xl font-bold text-(--text)">
-                            Hello, <span className="text-(--accent)">Developer</span>
+                            Hello, <span className="text-(--accent)">{session?.user?.name?.split(" ")[0] || "User"}</span>
                         </h1>
                         <p className="text-(--text-2) text-sm mt-1">Welcome back to CodeVerse Studio</p>
                     </div>

components/workspace/AIAssistantSidebar.tsx

@@ -0,0 +1,385 @@
+"use client";
+
+import { useChat } from "@ai-sdk/react";
+import React, { useState, useRef, useEffect, useMemo, ChangeEvent, FormEvent } from "react";
+import { motion, AnimatePresence } from "framer-motion";
+import {
+  Bot,
+  User,
+  Send,
+  X,
+  Plus,
+  Wand2,
+  Trash2,
+  Terminal,
+  FileText,
+  Search as SearchIcon,
+  Check,
+  MessageSquare,
+} from "lucide-react";
+import ReactMarkdown from "react-markdown";
+import remarkGfm from "remark-gfm";
+import { Prism as SyntaxHighlighter } from "react-syntax-highlighter";
+import { vscDarkPlus } from "react-syntax-highlighter/dist/cjs/styles/prism";
+
+// Standard AI Studio message shape for strict typing
+export interface StudioMessage {
+    id: string;
+    role: "system" | "user" | "assistant" | "data" | "tool";
+    content: string;
+    toolInvocations?: StudioToolInvocation[];
+    createdAt?: Date;
+}
+
+export interface StudioToolInvocation {
+  state: "call" | "result";
+  toolCallId: string;
+  toolName: string;
+  args: Record<string, unknown>;
+  result?: unknown;
+}
+
+// Interface for the hook results to satisfy TSC without 'any'
+interface ChatHelpers {
+  messages: StudioMessage[];
+  input: string;
+  handleInputChange: (e: React.ChangeEvent<HTMLTextAreaElement | HTMLInputElement>) => void;
+  handleSubmit: (e: React.FormEvent<HTMLFormElement>) => void;
+  isLoading: boolean;
+  setMessages: (messages: StudioMessage[]) => void;
+}
+
+interface AIAssistantSidebarProps {
+  workspaceName: string;
+  isOpen: boolean;
+  onClose: () => void;
+}
+
+interface PlanStep {
+  id: string;
+  description: string;
+  filesData?: string[];
+}
+
+interface PlanContent {
+  goal: string;
+  steps: PlanStep[];
+}
+
+export function AIAssistantSidebar({ workspaceName, isOpen, onClose }: AIAssistantSidebarProps) {
+  const [isPlanMode, setIsPlanMode] = useState(false);
+  const scrollRef = useRef<HTMLDivElement>(null);
+
+  const welcomeMsg: StudioMessage = {
+    id: "welcome",
+    role: "assistant",
+    content: `Hi! I'm your CodeVerse AI Assistant. I can help you explore this project, write code, or run terminal commands. How can I help you with **${workspaceName}** today?`,
+  };
+
+  // Safe bridge to bypass AI SDK v3 type-brand mismatches while keeping internals strict
+  const chatOptions = {
+    api: "/api/agent",
+    body: {
+      workspaceName,
+      mode: isPlanMode ? "plan" : "execute",
+    },
+  };
+
+  // Casting the hook result to our strictly-typed internal interface
+  const chat = useChat(chatOptions as unknown as Parameters<typeof useChat>[0]) as unknown as ChatHelpers;
+
+  const { 
+    messages: chatMessages, 
+    input, 
+    handleInputChange, 
+    handleSubmit, 
+    isLoading, 
+    setMessages 
+  } = chat;
+
+  // Fetch history on mount
+  useEffect(() => {
+    const fetchHistory = async () => {
+      try {
+        const res = await fetch(`/api/agent?workspaceName=${workspaceName}`);
+        if (res.ok) {
+          const data = await res.json() as { messages: StudioMessage[] };
+          if (data.messages && data.messages.length > 0) {
+            setMessages(data.messages);
+          }
+        }
+      } catch (err) {
+        console.error("Failed to fetch chat history:", err);
+      }
+    };
+    fetchHistory();
+  }, [workspaceName, setMessages]);
+
+  const clearHistory = () => {
+    setMessages([]);
+  };
+
+  const messages = useMemo<StudioMessage[]>(
+    () => (chatMessages.length === 0 ? [welcomeMsg] : chatMessages),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [chatMessages, workspaceName]
+  );
+
+  useEffect(() => {
+    if (scrollRef.current) {
+      scrollRef.current.scrollTop = scrollRef.current.scrollHeight;
+    }
+  }, [messages]);
+
+  const renderToolInvocation = (tool: StudioToolInvocation) => {
+    const isDone = tool.state === "result";
+    const iconMap: Record<string, React.ReactNode> = {
+      read_file: <FileText size={14} />,
+      write_file: <Plus size={14} />,
+      terminal_command: <Terminal size={14} />,
+      search_code: <SearchIcon size={14} />,
+      list_files: <MessageSquare size={14} />,
+    };
+    const icon = iconMap[tool.toolName] || <Wand2 size={14} />;
+
+    return (
+      <div key={tool.toolCallId} className="flex flex-col gap-2 p-3 my-2 rounded-xl bg-(--bg-2) border border-(--border-subtle) overflow-hidden shadow-sm">
+        <div className="flex items-center justify-between">
+          <div className="flex items-center gap-2 text-[10px] font-bold text-(--text-2) uppercase tracking-wider">
+            <span className={isDone ? "text-(--success)" : "text-(--accent) animate-pulse"}>
+              {icon}
+            </span>
+            <span>{tool.toolName.replace(/_/g, " ")}</span>
+          </div>
+          {isDone && <Check size={12} className="text-(--success)" />}
+        </div>
+        
+        {!isDone && (
+          <div className="text-[10px] font-mono text-(--text-muted) truncate opacity-70 italic">
+            {JSON.stringify(tool.args)}
+          </div>
+        )}
+        
+        {isDone && !!tool.result && (
+          <div className="text-[10px] font-mono bg-(--bg-3) p-2 rounded border border-(--border) text-(--text-muted) max-h-32 overflow-y-auto custom-scrollbar whitespace-pre-wrap">
+            {typeof tool.result === "string" 
+               ? (tool.result.length > 500 ? tool.result.slice(0, 500) + "..." : tool.result)
+               : JSON.stringify(tool.result, null, 2).slice(0, 500) + (JSON.stringify(tool.result).length > 500 ? "..." : "")}
+          </div>
+        )}
+      </div>
+    );
+  };
+
+  return (
+    <AnimatePresence>
+      {isOpen && (
+        <motion.div
+          initial={{ x: "100%" }}
+          animate={{ x: 0 }}
+          exit={{ x: "100%" }}
+          transition={{ type: "spring", damping: 28, stiffness: 220 }}
+          className="fixed top-0 right-0 h-full w-[440px] bg-(--surface) border-l border-(--border) shadow-2xl z-50 flex flex-col glassmorphism overflow-hidden"
+        >
+          {/* Header */}
+          <div className="p-4 border-b border-(--border-subtle) flex items-center justify-between bg-(--bg-2) bg-opacity-70 backdrop-blur-md">
+            <div className="flex items-center gap-3">
+              <div className="w-9 h-9 rounded-xl bg-(--accent) bg-opacity-10 flex items-center justify-center text-(--accent) shadow-inner border border-(--accent) border-opacity-20">
+                <Bot size={22} />
+              </div>
+              <div className="flex flex-col">
+                <span className="text-sm font-black text-(--text) tracking-tight">AI STUDIO</span>
+                <span className="text-[10px] text-(--text-muted) flex items-center gap-1 uppercase font-bold tracking-tighter">
+                  <div className="w-1.5 h-1.5 rounded-full bg-(--success) animate-pulse shadow-[0_0_8px_var(--success)]" />
+                  Isolated • {workspaceName}
+                </span>
+              </div>
+            </div>
+            <div className="flex items-center gap-1.5">
+              <button
+                onClick={() => setIsPlanMode(!isPlanMode)}
+                className={`flex items-center gap-1.5 px-3 py-1.5 rounded-full text-[10px] font-black transition-all border shadow-sm ${
+                  isPlanMode 
+                    ? "bg-(--warning) bg-opacity-15 text-(--warning) border-(--warning) border-opacity-40" 
+                    : "bg-(--bg-3) text-(--text-muted) border-transparent hover:text-(--text) hover:bg-(--surface-hover)"
+                }`}
+              >
+                <Wand2 size={12} />
+                {isPlanMode ? "PLAN" : "DIRECT"}
+              </button>
+              <div className="w-px h-4 bg-(--border-subtle) mx-1" />
+              <button 
+                onClick={clearHistory} 
+                className="p-2 hover:bg-(--error) hover:bg-opacity-10 rounded-xl transition-all text-(--text-muted) hover:text-(--error)" 
+                title="Clear History"
+              >
+                <Trash2 size={18} />
+              </button>
+              <button 
+                onClick={onClose} 
+                className="p-2 hover:bg-(--surface-hover) rounded-xl transition-all text-(--text-muted) hover:text-(--text)"
+              >
+                <X size={22} />
+              </button>
+            </div>
+          </div>
+
+          {/* Messages Container */}
+          <div ref={scrollRef} className="flex-1 overflow-y-auto p-5 space-y-8 custom-scrollbar scroll-smooth">
+            {messages.map((m) => (
+              <div key={m.id} className={`flex gap-4 ${m.role === "user" ? "flex-row-reverse" : ""}`}>
+                <div className={`w-9 h-9 rounded-xl shrink-0 flex items-center justify-center shadow-sm border ${
+                  m.role === "user" 
+                    ? "bg-(--bg-3) text-(--text) border-(--border-subtle)" 
+                    : "bg-(--accent) bg-opacity-10 text-(--accent) border-(--accent) border-opacity-20"
+                }`}>
+                  {m.role === "user" ? <User size={18} /> : <Bot size={18} />}
+                </div>
+                
+                <div className={`flex flex-col gap-2 max-w-[85%] ${m.role === "user" ? "items-end" : ""}`}>
+                  <div className={`px-4 py-3.5 rounded-2xl text-sm leading-relaxed shadow-md border animate-in fade-in slide-in-from-bottom-2 duration-300 ${
+                    m.role === "user"
+                      ? "bg-(--accent) text-white rounded-tr-sm border-transparent"
+                      : "bg-(--bg-2) text-(--text) rounded-tl-sm border-(--border-subtle)"
+                  }`}>
+                    {m.role === "assistant" && m.content.startsWith("{") && m.content.includes("goal") ? (
+                      <div className="flex flex-col gap-4 py-1">
+                        <div className="flex items-center gap-2 text-(--accent) font-black uppercase tracking-[0.2em] text-[9px]">
+                          <Check size={12} className="stroke-[3px]" /> System Plan Generated
+                        </div>
+                        {(() => {
+                          try {
+                            const plan = JSON.parse(m.content) as PlanContent;
+                            return (
+                                <div className="space-y-4">
+                                  <div className="font-bold text-sm text-(--text) bg-(--bg-3) p-3 rounded-xl border border-(--border-subtle) shadow-inner">
+                                    {String(plan.goal)}
+                                  </div>
+                                  <div className="space-y-2.5">
+                                    {(plan.steps || []).map((s, i) => (
+                                      <div key={s.id || String(i)} className="flex gap-3 p-3 rounded-xl bg-(--surface) bg-opacity-50 hover:bg-(--bg-3) transition-all border border-(--border-subtle) group">
+                                        <span className="flex items-center justify-center w-6 h-6 rounded-lg bg-(--accent) bg-opacity-10 text-(--accent) text-[11px] font-black shrink-0 group-hover:scale-110 transition-transform">
+                                          {i+1}
+                                        </span>
+                                        <span className="text-xs text-(--text-2) font-medium leading-[1.6]">{String(s.description)}</span>
+                                      </div>
+                                    ))}
+                                  </div>
+                                </div>
+                            );
+                          } catch { return <ReactMarkdown remarkPlugins={[remarkGfm]}>{m.content}</ReactMarkdown>; }
+                        })()}
+                      </div>
+                    ) : (
+                      <div className="prose prose-sm prose-invert max-w-full">
+                        <ReactMarkdown
+                            remarkPlugins={[remarkGfm]}
+                            components={{
+                            code({ className, children, ...props }: React.ComponentPropsWithoutRef<'code'>) {
+                                const match = /language-(\w+)/.exec(className || "");
+                                const isInline = !match;
+                                return isInline ? (
+                                <code className="bg-(--bg-3) px-1.5 py-0.5 rounded-md text-(--accent) font-mono text-[0.9em]" {...props}>
+                                    {children}
+                                </code>
+                                ) : (
+                                <div className="my-4 rounded-xl overflow-hidden border border-(--border-subtle) shadow-lg">
+                                    <div className="bg-(--bg-3) px-4 py-1.5 border-b border-(--border-subtle) flex items-center justify-between">
+                                        <span className="text-[10px] font-black text-(--text-muted) uppercase tracking-widest">{match[1]}</span>
+                                    </div>
+                                    <SyntaxHighlighter
+                                        style={vscDarkPlus}
+                                        language={match[1]}
+                                        PreTag="div"
+                                        className="m-0! text-xs! bg-(--bg-2)!"
+                                    >
+                                        {String(children).replace(/\n$/, "")}
+                                    </SyntaxHighlighter>
+                                </div>
+                                );
+                            },
+                            }}
+                        >
+                            {m.content}
+                        </ReactMarkdown>
+                      </div>
+                    )}
+                  </div>
+                  
+                  {/* Tool Invocations */}
+                  {m.toolInvocations?.map((tool: StudioToolInvocation) => renderToolInvocation(tool))}
+                </div>
+              </div>
+            ))}
+
+            {isLoading && (
+              <div className="flex items-center gap-4 animate-in fade-in duration-500">
+                <div className="w-9 h-9 rounded-xl bg-(--accent) bg-opacity-10 flex items-center justify-center text-(--accent) border border-(--accent) border-opacity-10">
+                  <Bot size={18} className="animate-pulse" />
+                </div>
+                <div className="flex gap-1.5 p-3 px-4 bg-(--bg-2) rounded-2xl border border-(--border-subtle)">
+                  <span className="w-1.5 h-1.5 rounded-full bg-(--accent) animate-bounce [animation-delay:-0.3s]" />
+                  <span className="w-1.5 h-1.5 rounded-full bg-(--accent) animate-bounce [animation-delay:-0.15s]" />
+                  <span className="w-1.5 h-1.5 rounded-full bg-(--accent) animate-bounce" />
+                </div>
+              </div>
+            )}
+          </div>
+
+          {/* Input Area */}
+          <div className="p-5 bg-(--bg-2) bg-opacity-80 backdrop-blur-md border-t border-(--border-subtle)">
+            <form
+              onSubmit={(e: FormEvent<HTMLFormElement>) => {
+                e.preventDefault();
+                handleSubmit(e);
+              }}
+              className="relative group"
+            >
+              <textarea
+                value={input}
+                onChange={(e: ChangeEvent<HTMLTextAreaElement>) => handleInputChange(e)}
+                onKeyDown={(e) => {
+                  if (e.key === "Enter" && !e.shiftKey) {
+                    e.preventDefault();
+                    if (input.trim()) (e.currentTarget.form)?.requestSubmit();
+                  }
+                }}
+                placeholder={isPlanMode ? "Define an architecture or complex goal..." : "How can I help you today?"}
+                rows={1}
+                className="w-full bg-(--surface) text-(--text) text-sm rounded-2xl pl-11 pr-14 py-4 border border-(--border) focus:border-(--accent) focus:ring-4 focus:ring-(--accent) focus:ring-opacity-5 outline-none resize-none min-h-[56px] max-h-[240px] transition-all scrollbar-hide shadow-lg group-hover:border-(--border-subtle)"
+                style={{ height: "auto" }}
+                onInput={(e) => {
+                  const target = e.target as HTMLTextAreaElement;
+                  target.style.height = "auto";
+                  target.style.height = `${Math.min(target.scrollHeight, 240)}px`;
+                }}
+              />
+              <div className="absolute left-4 top-[17px] text-(--text-muted) transition-colors group-focus-within:text-(--accent)">
+                {isPlanMode ? <Wand2 size={20} className="text-(--warning)" /> : <MessageSquare size={20} />}
+              </div>
+              <button
+                type="submit"
+                disabled={isLoading || !input.trim()}
+                className="absolute right-2.5 top-2.5 w-[36px] h-[36px] rounded-xl bg-(--accent) text-white hover:scale-105 active:scale-95 disabled:opacity-20 disabled:grayscale disabled:cursor-not-allowed transition-all shadow-md flex items-center justify-center overflow-hidden"
+              >
+                {isLoading ? (
+                  <div className="w-4 h-4 border-2 border-white border-t-transparent rounded-full animate-spin" />
+                ) : (
+                  <Send size={18} className="translate-x-px -translate-y-px" />
+                )}
+              </button>
+            </form>
+            <div className="flex items-center justify-between px-1 mt-3.5">
+                <p className="text-[9px] text-(--text-muted) flex items-center gap-1.5 font-bold uppercase tracking-widest opacity-60">
+                    <Check size={10} className="text-(--success)" /> Context Captured
+                </p>
+                <p className="text-[9px] text-(--text-muted) flex items-center gap-1.5 font-bold uppercase tracking-widest opacity-60">
+                    Shift+Enter for multi-line
+                </p>
+            </div>
+          </div>
+        </motion.div>
+      )}
+    </AnimatePresence>
+  );
+}

components/workspace/IDEClient.tsx

@@ -5,6 +5,8 @@ import dynamic from "next/dynamic";
 import { useSearchParams } from "next/navigation";
 import { Toaster, toast } from "sonner";
 import { VSCodeFrame } from "@/components/workspace/VSCodeFrame";
+import { AIAssistantSidebar } from "@/components/workspace/AIAssistantSidebar";
+import { Sparkles } from "lucide-react";
 import Link from "next/link";
 import type { Session } from "next-auth";
 
@@ -14,15 +16,28 @@ const Dashboard = dynamic(() => import("@/components/dashboard/Dashboard"), { ss
 export default function IDEClient({ session }: { session: Session | null }) {
   const searchParams = useSearchParams();
   const workspaceParam = searchParams?.get("workspace");
+  const [isAiOpen, setIsAiOpen] = useState(false);
   const [theme, setTheme] = useState<"dark" | "light">("dark");
   const [refreshKey, setRefreshKey] = useState(0);
 
   // Apply theme globally
   useEffect(() => {
     document.documentElement.setAttribute("data-theme", theme);
-    return () => setTheme("dark");
+    // Cleanup if needed
   }, [theme]);
 
+  // Keyboard shortcut for AI
+  useEffect(() => {
+    const handleKeyDown = (e: KeyboardEvent) => {
+      if ((e.ctrlKey || e.metaKey) && e.key === "i") {
+        e.preventDefault();
+        setIsAiOpen(prev => !prev);
+      }
+    };
+    window.addEventListener("keydown", handleKeyDown);
+    return () => window.removeEventListener("keydown", handleKeyDown);
+  }, []);
+
   // If no specific workspace is requested, render the Firebase-style Dashboard Control Plane
   if (!workspaceParam) {
     return (
@@ -60,18 +75,19 @@ export default function IDEClient({ session }: { session: Session | null }) {
 
   // Otherwise, render the dedicated VS Code Server instance mapped to this workspace
   return (
-    <div data-theme={theme} className="h-dvh w-screen flex flex-col bg-(--bg) overflow-hidden">
-      <div className="h-10 flex items-center justify-between px-4 bg-(--activity-bar) border-b border-(--border-subtle) shrink-0">
+    <div data-theme={theme} className="h-dvh w-screen flex flex-col bg-(--bg) overflow-hidden relative">
+      <div className="h-10 flex items-center justify-between px-4 bg-(--activity-bar) border-b border-(--border-subtle) shrink-0 z-40">
         <div className="flex items-center gap-3">
-          <Link href="/" className="text-(--accent) font-bold text-sm tracking-wide hover:opacity-80 transition-opacity">
-            ⬡ CodeVerse
+          <Link href="/" className="text-(--accent) font-bold text-sm tracking-wide hover:opacity-80 transition-opacity flex items-center gap-1.5">
+            <div className="w-5 h-5 rounded bg-(--accent) flex items-center justify-center text-white text-[10px]">⬡</div>
+            CodeVerse
           </Link>
           <div className="h-4 w-px bg-(--border) mx-1" />
           <span className="text-xs text-(--text-muted) font-mono">Workspace: {workspaceParam}</span>
         </div>
         <div className="flex items-center gap-2">
           {session?.user && (
-            <div className="flex items-center gap-2 mr-2 px-2 py-0.5 bg-(--border) rounded-full border border-(--border-subtle)">
+            <div className="hidden md:flex items-center gap-2 mr-2 px-2 py-0.5 bg-(--border) rounded-full border border-(--border-subtle)">
               <div className="w-4 h-4 rounded-full bg-(--accent) flex items-center justify-center text-[10px] text-white font-bold">
                 {session.user.name?.[0] || session.user.email?.[0] || "?"}
               </div>
@@ -80,18 +96,41 @@ export default function IDEClient({ session }: { session: Session | null }) {
               </span>
             </div>
           )}
+          
+          <button
+            onClick={() => setIsAiOpen(!isAiOpen)}
+            className={`flex items-center gap-1.5 px-3 py-1 text-xs font-bold rounded-md transition-all border ${
+              isAiOpen 
+                ? "bg-(--accent) text-white border-(--accent) shadow-lg shadow-(--accent)/20" 
+                : "bg-(--border) hover:bg-(--border-subtle) text-(--text) border-(--border-subtle)"
+            }`}
+          >
+            <Sparkles className={`w-3.5 h-3.5 ${isAiOpen ? "animate-pulse" : ""}`} />
+            {isAiOpen ? "AI Active" : "AI Studio"}
+          </button>
+
+          <div className="w-px h-4 bg-(--border) mx-1" />
+
           <button
             onClick={handleRebuild}
             className="px-3 py-1 text-xs font-semibold bg-(--border) hover:bg-(--border-subtle) text-(--text) rounded-md transition-colors border border-(--border-subtle) shadow-sm"
             title="Apply codeverse.json changes and restart container"
           >
-            ↻ Rebuild Environment
+            ↻ Rebuild
           </button>
         </div>
       </div>
 
-      <div className="flex-1 relative w-full h-full">
-        <VSCodeFrame key={refreshKey} workspaceId={workspaceParam} />
+      <div className="flex-1 flex relative w-full h-full overflow-hidden">
+        <main className={`flex-1 relative transition-all duration-300 ${isAiOpen ? "mr-0 md:mr-80 lg:mr-96" : "mr-0"}`}>
+          <VSCodeFrame key={refreshKey} workspaceId={workspaceParam} />
+        </main>
+        
+        <AIAssistantSidebar 
+          workspaceName={workspaceParam} 
+          isOpen={isAiOpen} 
+          onClose={() => setIsAiOpen(false)} 
+        />
       </div>
 
       <Toaster position="bottom-right" theme={theme} richColors />

lib/db/schema.ts

@@ -78,6 +78,18 @@ CREATE TABLE IF NOT EXISTS user_settings (
   updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
   FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
 );
+
+CREATE TABLE IF NOT EXISTS chat_history (
+  id TEXT PRIMARY KEY,
+  user_id TEXT NOT NULL,
+  workspace_id TEXT NOT NULL,
+  role TEXT NOT NULL,
+  content TEXT NOT NULL,
+  tool_invocations TEXT,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
+  FOREIGN KEY (workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE
+);
 `;
 
 export async function initDb() {

lib/docker/manager.ts

@@ -7,7 +7,9 @@ const docker = new Docker({ socketPath: process.platform === 'win32' ? '//./pipe
 
 export interface WorkspaceConfig {
     id: string;
-    image?: string; // e.g., 'codercom/code-server:latest'
+    userId: string;
+    projectName: string;
+    image?: string; 
     withAndroidEmulator?: boolean;
     onLog?: (msg: string) => void;
 }
@@ -17,7 +19,7 @@ export interface WorkspaceConfig {
  * Optionally spins up a sidecar Android emulator container.
  */
 export async function startWorkspaceContainer(config: WorkspaceConfig) {
-    const { id, withAndroidEmulator = false, onLog = console.log } = config;
+    const { id, userId, projectName, withAndroidEmulator = false, onLog = console.log } = config;
     const containerName = `codeverse-workspace-${id}`;
     const androidContainerName = `codeverse-android-${id}`;
 
@@ -44,7 +46,8 @@ export async function startWorkspaceContainer(config: WorkspaceConfig) {
         }
 
         // Map the local host path to the workspace
-        const dataPath = process.env.DATA_PATH || path.resolve(process.cwd(), 'data/projects', id);
+        const safeName = projectName.replace(/[^a-zA-Z0-9-_]/g, "-").slice(0, 60);
+        const dataPath = process.env.DATA_PATH || path.resolve(process.cwd(), 'workspaces', userId, safeName);
 
         // --- WORKSPACE CONFIG LOGIC AND IMAGE BUILDING ---
         const { buildWorkspaceImage } = await import('./builder');
@@ -161,7 +164,8 @@ export async function startWorkspaceContainer(config: WorkspaceConfig) {
     if (!appetizeUrl) {
         try {
             const fs = await import('fs/promises');
-            const dataPath = process.env.DATA_PATH || path.resolve(process.cwd(), 'data/projects', id);
+            const safeName = projectName.replace(/[^a-zA-Z0-9-_]/g, "-").slice(0, 60);
+            const dataPath = process.env.DATA_PATH || path.resolve(process.cwd(), 'workspaces', userId, safeName);
             const configPath = path.join(dataPath, 'codeverse.json');
             const configContent = await fs.readFile(configPath, 'utf8');
             const customConfig = JSON.parse(configContent);

lib/fs/isolation.ts

@@ -0,0 +1,50 @@
+import path from "path";
+import fs from "fs/promises";
+
+const WORKSPACE_BASE = path.join(process.cwd(), "workspaces");
+
+/**
+ * Returns the root directory for a specific user's workspaces.
+ * e.g., /path/to/codeverse/workspaces/{userId}
+ */
+export async function getUserWorkspaceRoot(userId: string): Promise<string> {
+    const userRoot = path.join(WORKSPACE_BASE, userId);
+    await fs.mkdir(userRoot, { recursive: true });
+    return userRoot;
+}
+
+/**
+ * Resolves a safe, isolated path within a specific project in a user's workspace.
+ * Prevents project-level directory traversal.
+ */
+export async function resolveSafeProjectPath(userId: string, projectName: string, subPath: string = ""): Promise<string> {
+    const userRoot = await getUserWorkspaceRoot(userId);
+    const projectRoot = path.resolve(userRoot, projectName.replace(/[^a-zA-Z0-9-_]/g, "-").slice(0, 60));
+    
+    // Normalize and resolve the absolute path
+    const targetPath = path.resolve(projectRoot, subPath);
+
+    // Security Check: Ensure the resolved path is still within the project root
+    if (!targetPath.startsWith(projectRoot)) {
+        throw new Error("Security Violation: Path traversal detected.");
+    }
+
+    return targetPath;
+}
+
+/**
+ * Resolves a safe, isolated path directly within a user's root workspace (e.g. for listing project names).
+ */
+export async function resolveSafePath(userId: string, subPath: string): Promise<string> {
+    const userRoot = await getUserWorkspaceRoot(userId);
+    
+    // Normalize and resolve the absolute path
+    const targetPath = path.resolve(userRoot, subPath);
+
+    // Security Check: Ensure the resolved path is still within the user's root
+    if (!targetPath.startsWith(userRoot)) {
+        throw new Error("Security Violation: Path traversal detected.");
+    }
+
+    return targetPath;
+}

lib/git/index.ts

@@ -1,21 +1,21 @@
 import simpleGit, { SimpleGit, SimpleGitOptions } from 'simple-git';
 
-const WORKSPACE_ROOT = process.cwd();
-
 const options: Partial<SimpleGitOptions> = {
-    baseDir: WORKSPACE_ROOT,
     binary: 'git',
     maxConcurrentProcesses: 6,
     trimmed: false,
 };
 
-export const git: SimpleGit = simpleGit(options);
+export function getGit(baseDir: string = process.cwd()): SimpleGit {
+    return simpleGit({ ...options, baseDir });
+}
 
-export async function getGitStatus() {
-    const isRepo = await git.checkIsRepo();
+export async function getGitStatus(baseDir?: string) {
+    const instance = getGit(baseDir);
+    const isRepo = await instance.checkIsRepo();
     if (!isRepo) return null;
 
-    const status = await git.status();
+    const status = await instance.status();
     return {
         currentBranch: status.current,
         modified: status.modified,
@@ -28,38 +28,45 @@ export async function getGitStatus() {
     };
 }
 
-export async function getBranchList() {
-    const branches = await git.branch();
+export async function getBranchList(baseDir?: string) {
+    const instance = getGit(baseDir);
+    const branches = await instance.branch();
     return {
         all: branches.all,
         current: branches.current
     };
 }
 
-export async function commitFiles(message: string, files: string[] = []) {
+export async function commitFiles(message: string, files: string[] = [], baseDir?: string) {
+    const instance = getGit(baseDir);
     if (files.length > 0) {
-        await git.add(files);
+        await instance.add(files);
     } else {
-        await git.add('.');
+        await instance.add('.');
     }
-    return git.commit(message);
+    return instance.commit(message);
 }
 
-export async function getFileDiff(file: string) {
-    return git.diff([file]);
+export async function getFileDiff(file: string, baseDir?: string) {
+    return getGit(baseDir).diff([file]);
 }
 
-export async function pushBranch() {
-    return git.push();
+export async function pushBranch(baseDir?: string) {
+    return getGit(baseDir).push();
 }
 
-export async function pullBranch() {
-    return git.pull();
+export async function pullBranch(baseDir?: string) {
+    return getGit(baseDir).pull();
 }
 
-export async function checkoutBranch(branch: string, create: boolean = false) {
+export async function checkoutBranch(branch: string, create: boolean = false, baseDir?: string) {
+    const instance = getGit(baseDir);
     if (create) {
-        return git.checkoutLocalBranch(branch);
+        return instance.checkoutLocalBranch(branch);
     }
-    return git.checkout(branch);
+    return instance.checkout(branch);
 }
+
+
+// Export for legacy access if needed, but discouraged
+// export { git } from 'simple-git'; 

lib/mcp/tools.ts

@@ -1,89 +1,118 @@
- 
-import { tool } from "ai";
+import { zodSchema } from "ai";
+import type { ToolSet } from "ai";
 import { z } from "zod";
 import fs from "fs/promises";
 import path from "path";
 import { exec } from "child_process";
 import { promisify } from "util";
+import { resolveSafeProjectPath } from "../fs/isolation";
 
 const execAsync = promisify(exec);
-const cwd = process.cwd();
 
-export const coreTools = {
-    read_file: tool({
-        description: "Read the full content of a file",
-        parameters: z.object({ filePath: z.string().describe("Absolute or relative path to the file") }),
-        // @ts-expect-error - AI SDK generic limitation
-        execute: async (args: { filePath: string }): Promise<Record<string, unknown>> => {
-            const { filePath } = args;
-            try {
-                const fullPath = path.resolve(cwd, filePath);
-                const content = await fs.readFile(fullPath, "utf-8");
-                return { success: true, content };
-            } catch (e: unknown) {
-                return { success: false, error: (e as Error).message };
-            }
+/**
+ * Factory that creates user-isolated workspace tools for the AI agent.
+ * Each tool is sandboxed to workspaces/{userId}/{workspaceName}/
+ *
+ * Note: Tools are built as plain objects using `zodSchema()` for `inputSchema`
+ * instead of the `tool()` helper, because `tool()` in AI SDK v6 has broken
+ * TypeScript overloads when `execute` returns union types in strict mode.
+ */
+export function createTools(userId: string, workspaceName: string): ToolSet {
+    return {
+        read_file: {
+            description: "Read the full content of a file within the workspace",
+            inputSchema: zodSchema(z.object({
+                filePath: z.string().describe("Relative path from workspace root"),
+            })),
+            execute: async ({ filePath }: { filePath: string }) => {
+                try {
+                    const fullPath = await resolveSafeProjectPath(userId, workspaceName, filePath);
+                    const content = await fs.readFile(fullPath, "utf-8");
+                    return { success: true, content };
+                } catch (e) {
+                    return { success: false, error: (e as Error).message };
+                }
+            },
         },
-    }),
 
-    write_file: tool({
-        description: "Write content to a file (overwrites existing)",
-        parameters: z.object({
-            filePath: z.string(),
-            content: z.string().describe("The full replacement content"),
-        }),
-        // @ts-expect-error - AI SDK generic limitation
-        execute: async (args: { filePath: string, content: string }): Promise<Record<string, unknown>> => {
-            const { filePath, content } = args;
-            try {
-                const fullPath = path.resolve(cwd, filePath);
-                await fs.mkdir(path.dirname(fullPath), { recursive: true });
-                await fs.writeFile(fullPath, content, "utf-8");
-                return { success: true, path: fullPath };
-            } catch (e: unknown) {
-                return { success: false, error: (e as Error).message };
-            }
+        write_file: {
+            description: "Write/overwrite a file within the workspace",
+            inputSchema: zodSchema(z.object({
+                filePath: z.string().describe("Relative path to the file"),
+                content: z.string().describe("Full file content to write"),
+            })),
+            execute: async ({ filePath, content }: { filePath: string; content: string }) => {
+                try {
+                    const fullPath = await resolveSafeProjectPath(userId, workspaceName, filePath);
+                    await fs.mkdir(path.dirname(fullPath), { recursive: true });
+                    await fs.writeFile(fullPath, content, "utf-8");
+                    return { success: true, path: filePath };
+                } catch (e) {
+                    return { success: false, error: (e as Error).message };
+                }
+            },
         },
-    }),
 
-    terminal_command: tool({
-        description: "Execute a bash/shell command strictly in the workspace",
-        parameters: z.object({
-            command: z.string().describe("The command to run e.g. 'npm run build' or 'tsc --noEmit'"),
-            background: z.boolean().optional().describe("Run in background without waiting for finish"),
-        }),
-        // @ts-expect-error - AI SDK generic limitation
-        execute: async (args: { command: string, background?: boolean }): Promise<Record<string, unknown>> => {
-            const { command, background } = args;
-            try {
-                if (background) {
-                    exec(command, { cwd });
-                    return { success: true, output: "Command started in background" };
+        terminal_command: {
+            description: "Run a shell command inside the workspace directory",
+            inputSchema: zodSchema(z.object({
+                command: z.string().describe("Shell command to execute"),
+                background: z.boolean().optional().describe("Run async without capturing output"),
+            })),
+            execute: async ({ command, background }: { command: string; background?: boolean }) => {
+                try {
+                    const cwd = await resolveSafeProjectPath(userId, workspaceName);
+                    if (background) {
+                        exec(command, { cwd });
+                        return { success: true, output: "Started in background" };
+                    }
+                    const { stdout, stderr } = await execAsync(command, { cwd });
+                    return { success: true, stdout, stderr };
+                } catch (e) {
+                    return { success: false, error: (e as Error).message };
                 }
-                const { stdout, stderr } = await execAsync(command, { cwd });
-                return { success: true, stdout, stderr };
-            } catch (e: unknown) {
-                return { success: false, error: (e as Error).message, stderr: (e as { stderr?: string }).stderr };
-            }
+            },
         },
-    }),
 
-    search_code: tool({
-        description: "Search for a regex pattern across all workspace files",
-        parameters: z.object({
-            pattern: z.string().describe("Regex or strict string to search"),
-            glob: z.string().optional().describe("File restriction e.g. '*.ts'"),
-        }),
-        // @ts-expect-error - AI SDK generic limitation
-        execute: async (args: { pattern: string }): Promise<Record<string, unknown>> => {
-            const { pattern } = args;
-            try {
-                // Simple grep fallback 
-                const { stdout } = await execAsync(`git grep -n "${pattern}" || grep -rn "${pattern}" .`, { cwd });
-                return { success: true, matches: stdout.split("\n").filter(Boolean) };
-            } catch (e: unknown) {
-                return { success: false, error: (e as Error).message };
-            }
+        search_code: {
+            description: "Search for a text pattern across all workspace files",
+            inputSchema: zodSchema(z.object({
+                pattern: z.string().describe("Literal string or regex pattern"),
+            })),
+            execute: async ({ pattern }: { pattern: string }) => {
+                try {
+                    const cwd = await resolveSafeProjectPath(userId, workspaceName);
+                    const { stdout } = await execAsync(
+                        `git grep -n "${pattern}" 2>/dev/null || grep -rn "${pattern}" . 2>/dev/null || true`,
+                        { cwd }
+                    );
+                    return { success: true, matches: stdout.split("\n").filter(Boolean) };
+                } catch (e) {
+                    return { success: false, error: (e as Error).message };
+                }
+            },
         },
-    }),
-};
+
+        list_files: {
+            description: "List files in the project to understand its structure",
+            inputSchema: zodSchema(z.object({
+                recursive: z.boolean().optional().describe("Recursive listing (default: true)"),
+            })),
+            execute: async ({ recursive }: { recursive?: boolean }) => {
+                const isRecursive = recursive !== false;
+                try {
+                    const cwd = await resolveSafeProjectPath(userId, workspaceName);
+                    const cmd = isRecursive
+                        ? "find . -maxdepth 4 -not -path '*/\\.*' -not -path '*/node_modules/*' -not -path '*/.next/*'"
+                        : "ls -F";
+                    const { stdout } = await execAsync(cmd, { cwd });
+                    return { success: true, files: stdout.split("\n").filter(Boolean) };
+                } catch (e) {
+                    return { success: false, error: (e as Error).message };
+                }
+            },
+        },
+    } as ToolSet;
+}
+
+export type WorkspaceTools = ReturnType<typeof createTools>;

package-lock.json

@@ -45,6 +45,7 @@
         "react": "19.2.3",
         "react-dom": "19.2.3",
         "react-markdown": "^10.1.0",
+        "react-syntax-highlighter": "^16.1.1",
         "recharts": "^3.7.0",
         "remark-gfm": "^4.0.1",
         "simple-git": "^3.32.3",
@@ -67,6 +68,7 @@
         "@types/node": "^20",
         "@types/react": "^19",
         "@types/react-dom": "^19",
+        "@types/react-syntax-highlighter": "^15.5.13",
         "@types/tar-fs": "^2.0.4",
         "eslint": "^9",
         "eslint-config-next": "16.1.6",
@@ -437,6 +439,15 @@
         "node": ">=6.0.0"
       }
     },
+    "node_modules/@babel/runtime": {
+      "version": "7.29.2",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.2.tgz",
+      "integrity": "sha512-JiDShH45zKHWyGe4ZNVRrCjBz8Nh9TMmZG1kh4QTK8hCBTWBi8Da+i7s1fJw7/lYpM4ccepSNfqzZ/QvABBi5g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
     "node_modules/@babel/template": {
       "version": "7.28.6",
       "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz",
@@ -3726,6 +3737,12 @@
         "undici-types": "~6.21.0"
       }
     },
+    "node_modules/@types/prismjs": {
+      "version": "1.26.6",
+      "resolved": "https://registry.npmjs.org/@types/prismjs/-/prismjs-1.26.6.tgz",
+      "integrity": "sha512-vqlvI7qlMvcCBbVe0AKAb4f97//Hy0EBTaiW8AalRnG/xAN5zOiWWyrNqNXeq8+KAuvRewjCVY1+IPxk4RdNYw==",
+      "license": "MIT"
+    },
     "node_modules/@types/react": {
       "version": "19.2.14",
       "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.14.tgz",
@@ -3747,6 +3764,16 @@
         "@types/react": "^19.2.0"
       }
     },
+    "node_modules/@types/react-syntax-highlighter": {
+      "version": "15.5.13",
+      "resolved": "https://registry.npmjs.org/@types/react-syntax-highlighter/-/react-syntax-highlighter-15.5.13.tgz",
+      "integrity": "sha512-uLGJ87j6Sz8UaBAooU0T6lWJ0dBmjZgN1PZTrj05TNql2/XpC6+4HhMT5syIdFUUt+FASfCeLLv4kBygNU+8qA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/react": "*"
+      }
+    },
     "node_modules/@types/ssh2": {
       "version": "1.15.5",
       "resolved": "https://registry.npmjs.org/@types/ssh2/-/ssh2-1.15.5.tgz",
@@ -6933,6 +6960,19 @@
         "reusify": "^1.0.4"
       }
     },
+    "node_modules/fault": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/fault/-/fault-1.0.4.tgz",
+      "integrity": "sha512-CJ0HCB5tL5fYTEA7ToAq5+kTwd++Borf1/bifxd9iT70QcXr4MRrO3Llf8Ifs70q+SJcGHFtnIE/Nw6giCtECA==",
+      "license": "MIT",
+      "dependencies": {
+        "format": "^0.2.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/fetch-blob": {
       "version": "3.2.0",
       "resolved": "https://registry.npmjs.org/fetch-blob/-/fetch-blob-3.2.0.tgz",
@@ -7057,6 +7097,14 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/format": {
+      "version": "0.2.2",
+      "resolved": "https://registry.npmjs.org/format/-/format-0.2.2.tgz",
+      "integrity": "sha512-wzsgA6WOq+09wrU1tsJ09udeR/YZRaeArL9e1wPbFg3GG2yDnC2ldKpxs4xunpFF9DgqCqOIra3bc1HWrJ37Ww==",
+      "engines": {
+        "node": ">=0.4.x"
+      }
+    },
     "node_modules/formdata-polyfill": {
       "version": "4.0.10",
       "resolved": "https://registry.npmjs.org/formdata-polyfill/-/formdata-polyfill-4.0.10.tgz",
@@ -7434,6 +7482,19 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/hast-util-parse-selector": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-4.0.0.tgz",
+      "integrity": "sha512-wkQCkSYoOGCRKERFWcxMVMOcYE2K1AaNLU8DXS9arxnLOUEWbOXKXiJUNzEpqZ3JOKpnha3jkFrumEjVliDe7A==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
     "node_modules/hast-util-to-jsx-runtime": {
       "version": "2.3.6",
       "resolved": "https://registry.npmjs.org/hast-util-to-jsx-runtime/-/hast-util-to-jsx-runtime-2.3.6.tgz",
@@ -7474,6 +7535,23 @@
         "url": "https://opencollective.com/unified"
       }
     },
+    "node_modules/hastscript": {
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/hastscript/-/hastscript-9.0.1.tgz",
+      "integrity": "sha512-g7df9rMFX/SPi34tyGCyUBREQoKkapwdY/T04Qn9TDWfHhAYt4/I0gMVirzK5wEzeUqIjEB+LXC/ypb7Aqno5w==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "comma-separated-tokens": "^2.0.0",
+        "hast-util-parse-selector": "^4.0.0",
+        "property-information": "^7.0.0",
+        "space-separated-tokens": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
     "node_modules/hermes-estree": {
       "version": "0.25.1",
       "resolved": "https://registry.npmjs.org/hermes-estree/-/hermes-estree-0.25.1.tgz",
@@ -7491,6 +7569,21 @@
         "hermes-estree": "0.25.1"
       }
     },
+    "node_modules/highlight.js": {
+      "version": "10.7.3",
+      "resolved": "https://registry.npmjs.org/highlight.js/-/highlight.js-10.7.3.tgz",
+      "integrity": "sha512-tzcUFauisWKNHaRkN4Wjl/ZA07gENAjFl3J/c480dprkGTg5EQstgaNFqBfUqCq54kZRIEcreTsAgF/m2quD7A==",
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/highlightjs-vue": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/highlightjs-vue/-/highlightjs-vue-1.0.0.tgz",
+      "integrity": "sha512-PDEfEF102G23vHmPhLyPboFCD+BkMGu+GuJe2d9/eH4FsCwvgBpnc9n0pGE+ffKdph38s6foEZiEjdgHdzp+IA==",
+      "license": "CC0-1.0"
+    },
     "node_modules/hono": {
       "version": "4.12.3",
       "resolved": "https://registry.npmjs.org/hono/-/hono-4.12.3.tgz",
@@ -8749,6 +8842,20 @@
         "loose-envify": "cli.js"
       }
     },
+    "node_modules/lowlight": {
+      "version": "1.20.0",
+      "resolved": "https://registry.npmjs.org/lowlight/-/lowlight-1.20.0.tgz",
+      "integrity": "sha512-8Ktj+prEb1RoCPkEOrPMYUN/nCggB7qAWe3a7OpMjWQkh3l2RD5wKRQ+o8Q8YuI9RG/xs95waaI/E6ym/7NsTw==",
+      "license": "MIT",
+      "dependencies": {
+        "fault": "^1.0.0",
+        "highlight.js": "~10.7.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/lru-cache": {
       "version": "5.1.1",
       "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
@@ -10504,6 +10611,15 @@
         "node": ">= 0.8.0"
       }
     },
+    "node_modules/prismjs": {
+      "version": "1.30.0",
+      "resolved": "https://registry.npmjs.org/prismjs/-/prismjs-1.30.0.tgz",
+      "integrity": "sha512-DEvV2ZF2r2/63V+tK8hQvrR2ZGn10srHbXviTlcv7Kpzw8jWiNTqbVgjO3IY8RxrrOUF8VPMQQFysYYYv0YZxw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/promise-limit": {
       "version": "2.7.0",
       "resolved": "https://registry.npmjs.org/promise-limit/-/promise-limit-2.7.0.tgz",
@@ -10799,6 +10915,26 @@
         }
       }
     },
+    "node_modules/react-syntax-highlighter": {
+      "version": "16.1.1",
+      "resolved": "https://registry.npmjs.org/react-syntax-highlighter/-/react-syntax-highlighter-16.1.1.tgz",
+      "integrity": "sha512-PjVawBGy80C6YbC5DDZJeUjBmC7skaoEUdvfFQediQHgCL7aKyVHe57SaJGfQsloGDac+gCpTfRdtxzWWKmCXA==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/runtime": "^7.28.4",
+        "highlight.js": "^10.4.1",
+        "highlightjs-vue": "^1.0.0",
+        "lowlight": "^1.17.0",
+        "prismjs": "^1.30.0",
+        "refractor": "^5.0.0"
+      },
+      "engines": {
+        "node": ">= 16.20.2"
+      },
+      "peerDependencies": {
+        "react": ">= 0.14.0"
+      }
+    },
     "node_modules/readable-stream": {
       "version": "3.6.2",
       "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
@@ -10882,6 +11018,22 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/refractor": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/refractor/-/refractor-5.0.0.tgz",
+      "integrity": "sha512-QXOrHQF5jOpjjLfiNk5GFnWhRXvxjUVnlFxkeDmewR5sXkr3iM46Zo+CnRR8B+MDVqkULW4EcLVcRBNOPXHosw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "@types/prismjs": "^1.0.0",
+        "hastscript": "^9.0.0",
+        "parse-entities": "^4.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/regexp.prototype.flags": {
       "version": "1.5.4",
       "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.4.tgz",

package.json

@@ -46,6 +46,7 @@
     "react": "19.2.3",
     "react-dom": "19.2.3",
     "react-markdown": "^10.1.0",
+    "react-syntax-highlighter": "^16.1.1",
     "recharts": "^3.7.0",
     "remark-gfm": "^4.0.1",
     "simple-git": "^3.32.3",
@@ -68,6 +69,7 @@
     "@types/node": "^20",
     "@types/react": "^19",
     "@types/react-dom": "^19",
+    "@types/react-syntax-highlighter": "^15.5.13",
     "@types/tar-fs": "^2.0.4",
     "eslint": "^9",
     "eslint-config-next": "16.1.6",