Upgrade workspace, AI, profile, and execution flow

Author: liambrooks-lab

apps/api/src/controllers/assistantController.ts

@@ -6,136 +6,166 @@ type ChatMessage = {
 };
 
 type AssistantContext = {
+  activeFileName?: string;
+  activeFilePath?: string;
   currentLanguage?: string;
   fileCount?: number;
+  folderCount?: number;
   lastOutput?: string;
-  roomId?: string;
+  lastStatus?: string;
+  profileName?: string;
+};
+
+const delay = (value: number) => new Promise((resolve) => setTimeout(resolve, value));
+
+const emitEvent = (res: Response, type: string, payload: unknown) => {
+  res.write(`event: ${type}\n`);
+  res.write(`data: ${JSON.stringify(payload)}\n\n`);
 };
 
 const buildReply = (message: string, context: AssistantContext) => {
   const normalized = message.toLowerCase();
-  const languageHint = context.currentLanguage
-    ? ` for your current ${context.currentLanguage} workspace`
+  const name = context.profileName ?? "builder";
+  const fileHint = context.activeFileName
+    ? ` The active file is ${context.activeFileName}${context.activeFilePath ? ` at ${context.activeFilePath}` : ""}.`
     : "";
+  const workspaceHint = ` Your workspace currently has ${context.fileCount ?? 0} files and ${context.folderCount ?? 0} folders.`;
 
   if (!message.trim()) {
     return {
       reply:
-        "Ask me anything about using VoidLAB, fixing code execution, collaborating in a room, or finding the right workflow for your current project.",
+        `I’m the VoidLAB basic assistant for ${name}. Ask me about running code, fixing compile issues, using stdin, AI workflow, folders, or workspace commands.${workspaceHint}`,
       suggestions: [
         "How do I run code with input?",
-        "How do collaboration rooms work?",
-        "Give me keyboard shortcuts",
+        "How do workspace commands work?",
+        "How do I organize files and folders?",
       ],
     };
   }
 
-  if (normalized.includes("input") || normalized.includes("stdin")) {
+  if (normalized.includes("python")) {
     return {
-      reply: `To run input/output programs${languageHint}, open the terminal input box, type the input exactly as the program expects it, and then press Run. Multi-line input is supported, so each new line will be passed to the runtime the same way it would in a local terminal.`,
+      reply:
+        `Python works well in VoidLAB. Choose the Python language for the active file, write your script, put stdin in the input panel if your code uses input(), and run it. If the result is wrong, compare stdout, stderr, and compile status separately because VoidLAB now shows each section distinctly.${fileHint}`,
       suggestions: [
-        "Show me an example input format",
-        "Why is my program waiting for input?",
-        "How do I preview HTML output?",
+        "Show a Python input example",
+        "How do I debug Python stderr?",
+        "Can I create multiple Python files?",
       ],
     };
   }
 
-  if (
-    normalized.includes("run") ||
-    normalized.includes("compile") ||
-    normalized.includes("error")
-  ) {
-    const outputHint = context.lastOutput
-      ? ` The latest terminal response I know about is: "${context.lastOutput.slice(0, 120)}".`
-      : "";
-
+  if (normalized.includes("input") || normalized.includes("stdin")) {
     return {
-      reply: `Start by confirming the selected language matches the active file extension, then run the file again. If the terminal shows an error, read the first error line before changing the code because it usually points to the exact syntax or input issue.${outputHint}`,
+      reply:
+        `For precise stdin handling, paste the input exactly line by line in the Program input box and then run the active file. VoidLAB forwards the raw text to the runtime without rewriting it, so spaces, new lines, and multi-line cases stay intact.`,
       suggestions: [
-        "Help me debug this output",
-        "What languages are runnable right now?",
-        "How do I use stdin in VoidLAB?",
+        "Why is my program waiting for input?",
+        "How is stdout different from stderr?",
+        "How do I test multiple input cases?",
       ],
     };
   }
 
   if (
-    normalized.includes("collab") ||
-    normalized.includes("team") ||
-    normalized.includes("share") ||
-    normalized.includes("room")
+    normalized.includes("error") ||
+    normalized.includes("compile") ||
+    normalized.includes("output") ||
+    normalized.includes("wrong answer")
   ) {
-    const roomHint = context.roomId
-      ? ` You are currently connected to room ${context.roomId}.`
-      : " Create a room, share the room code, and then use Push workspace to sync your current files into the shared session.";
+    const statusHint = context.lastStatus ? ` The latest status was ${context.lastStatus}.` : "";
+    const outputHint = context.lastOutput
+      ? ` The latest terminal output starts with: "${context.lastOutput.slice(0, 160)}".`
+      : "";
 
     return {
-      reply: `VoidLAB collaboration rooms let teammates join the same workspace, exchange messages, and sync the latest file set into a shared room state.${roomHint}`,
+      reply:
+        `Start with the execution status, then check compile output, then stderr, then stdout. Compile output means the code did not build. Stderr means the program ran and failed. Stdout is the actual program result.${statusHint}${outputHint}${fileHint}`,
       suggestions: [
-        "How do I create a room?",
-        "How do I pull the latest shared workspace?",
-        "How do I invite teammates?",
+        "Explain my latest output",
+        "How do I fix runtime errors?",
+        "What if stdout is empty?",
       ],
     };
   }
 
-  if (
-    normalized.includes("manual") ||
-    normalized.includes("shortcut") ||
-    normalized.includes("how to")
-  ) {
+  if (normalized.includes("command") || normalized.includes("terminal") || normalized.includes("folder")) {
     return {
       reply:
-        "The fastest way to learn VoidLAB is to use the feature pages from the editor toolbar. Manual explains the product, GitHub shows publish commands, Collaboration manages shared rooms, and AI Guide helps with workflows and troubleshooting.",
+        `VoidLAB workspace commands manage your virtual project tree. Use mkdir to create folders, touch to create files, ls or tree to inspect the workspace, open to jump to a file, and rm to remove entries. These commands operate on your workspace data directly, so they are fast and safe for browser use.${workspaceHint}`,
       suggestions: [
-        "List the shortcuts",
-        "What is the best workflow for a beginner?",
-        "How do I deploy my project?",
+        "List useful workspace commands",
+        "How do I import a folder?",
+        "Can I open a file from the terminal?",
       ],
     };
   }
 
-  if (
-    normalized.includes("html") ||
-    normalized.includes("css") ||
-    normalized.includes("preview")
-  ) {
+  if (normalized.includes("profile") || normalized.includes("bio") || normalized.includes("social")) {
     return {
       reply:
-        "For web-style files, VoidLAB can open a live preview in a new tab instead of sending the code to the compiler. If your workspace has HTML and CSS files together, the preview combines them so you can see the page instantly.",
+        `Your profile page is where VoidLAB surfaces identity, bio, social links, and recent activities such as runs, saves, AI chats, and workspace changes. Keeping those details updated makes the product feel much more personal and portfolio-ready.`,
       suggestions: [
-        "How do I preview HTML and CSS together?",
-        "Can JavaScript be included in preview mode?",
-        "Why does preview open in a new tab?",
+        "What appears on the profile page?",
+        "How are activities tracked?",
+        "Can I update my social links later?",
       ],
     };
   }
 
   return {
     reply:
-      "VoidLAB AI Guide is here to help with product usage, execution issues, workflow choices, collaboration, and deployment steps. Ask me about your current file, how to use a feature, or how to debug what just happened in the terminal.",
+      `VoidLAB basic assistant is best for product usage, execution troubleshooting, workspace organization, and fast guidance while you code.${workspaceHint}${fileHint} Ask me about the current file, terminal output, or the next workflow step you want to take.`,
     suggestions: [
-      "How do I use collaboration?",
-      "Help me debug a failing run",
-      "What can I do from the GitHub page?",
+      "Help me debug my active file",
+      "How do I use folders in VoidLAB?",
+      "How do I run input-output programs correctly?",
     ],
   };
 };
 
+const getAssistantResponse = (context: AssistantContext | undefined, messages: ChatMessage[] | undefined) => {
+  const lastUserMessage = messages?.filter((item) => item.role === "user").at(-1)?.content ?? "";
+  return buildReply(lastUserMessage, context ?? {});
+};
+
 export const chatWithAssistant = async (req: Request, res: Response) => {
   const { context, messages } = (req.body ?? {}) as {
     context?: AssistantContext;
     messages?: ChatMessage[];
   };
 
-  const lastUserMessage =
-    messages?.filter((item) => item.role === "user").at(-1)?.content ?? "";
-
-  const response = buildReply(lastUserMessage, context ?? {});
+  const response = getAssistantResponse(context, messages);
 
   return res.status(200).json({
     ok: true,
     ...response,
   });
 };
+
+export const streamAssistantChat = async (req: Request, res: Response) => {
+  const { context, messages } = (req.body ?? {}) as {
+    context?: AssistantContext;
+    messages?: ChatMessage[];
+  };
+
+  const response = getAssistantResponse(context, messages);
+  const chunks = response.reply.match(/.{1,32}(\s|$)|.{1,32}/g) ?? [response.reply];
+
+  res.setHeader("Cache-Control", "no-cache, no-transform");
+  res.setHeader("Connection", "keep-alive");
+  res.setHeader("Content-Type", "text/event-stream");
+  res.flushHeaders?.();
+
+  emitEvent(res, "meta", { ok: true, mode: "basic-realtime" });
+
+  for (const chunk of chunks) {
+    emitEvent(res, "chunk", { value: chunk });
+    await delay(18);
+  }
+
+  emitEvent(res, "done", {
+    suggestions: response.suggestions,
+  });
+  res.end();
+};

apps/api/src/controllers/authControllers.ts

@@ -68,7 +68,7 @@ const sendWelcomeEmail = async ({
 };
 
 export const createSession = async (req: Request, res: Response) => {
-  const { email, name, phone, region } = req.body ?? {};
+  const { bio, email, name, phone, region, socials } = req.body ?? {};
 
   if (!email || !name || !phone || !region) {
     return res.status(400).json({
@@ -97,6 +97,21 @@ export const createSession = async (req: Request, res: Response) => {
   return res.status(200).json({
     ok: true,
     mail: emailStatus,
-    profile: { email, name, phone, region },
+    profile: {
+      bio: typeof bio === "string" ? bio : "",
+      email,
+      name,
+      phone,
+      region,
+      socials:
+        socials && typeof socials === "object"
+          ? socials
+          : {
+              github: "",
+              instagram: "",
+              linkedin: "",
+              x: "",
+            },
+    },
   });
 };

apps/api/src/controllers/collaborationController.ts

@@ -11,11 +11,13 @@ type RoomFile = {
   id: string;
   languageId: string;
   name: string;
+  path: string;
 };
 
 type WorkspaceSnapshot = {
   activeFileId: string;
   files: RoomFile[];
+  folders: string[];
   updatedAt: string;
   updatedBy: string;
 };
@@ -203,9 +205,10 @@ export const updateWorkspace = async (req: Request, res: Response) => {
 
   if (!room) return;
 
-  const { activeFileId, files, participantId } = (req.body ?? {}) as {
+  const { activeFileId, files, folders, participantId } = (req.body ?? {}) as {
     activeFileId?: string;
     files?: RoomFile[];
+    folders?: string[];
     participantId?: string;
   };
 
@@ -227,6 +230,7 @@ export const updateWorkspace = async (req: Request, res: Response) => {
   room.workspace = {
     activeFileId,
     files,
+    folders: Array.isArray(folders) ? folders : [],
     updatedAt: new Date().toISOString(),
     updatedBy: author.name,
   };

apps/api/src/controllers/execute.ts

@@ -1,43 +1,84 @@
 import axios from "axios";
 import { Request, Response } from "express";
 
-const judge0ApiUrl =
-  process.env.JUDGE0_API_URL ?? "https://ce.judge0.com";
+const judge0ApiUrl = process.env.JUDGE0_API_URL ?? "https://ce.judge0.com";
+
+const encode = (value: string) => Buffer.from(value, "utf8").toString("base64");
+
+const decode = (value?: string | null) => {
+  if (!value) return "";
+
+  try {
+    return Buffer.from(value, "base64").toString("utf8");
+  } catch {
+    return value;
+  }
+};
 
 export const executeCode = async (req: Request, res: Response) => {
   const { code, languageId, stdin } = req.body ?? {};
 
-  if (!code || !languageId) {
+  if (typeof code !== "string" || !code.trim() || !languageId) {
     return res.status(400).json({
       error: "Language id and code are required.",
     });
   }
 
   try {
     const response = await axios.post(
-      `${judge0ApiUrl}/submissions/?base64_encoded=false&wait=true`,
+      `${judge0ApiUrl}/submissions/?base64_encoded=true&wait=true`,
       {
         cpu_time_limit: 5,
-        language_id: languageId,
+        language_id: Number(languageId),
         memory_limit: 262144,
-        source_code: code,
-        stdin: typeof stdin === "string" ? stdin : "",
+        source_code: encode(code),
+        stdin: encode(typeof stdin === "string" ? stdin : ""),
         wall_time_limit: 12,
       },
       {
         headers: {
           "Content-Type": "application/json",
           "User-Agent": "VoidLAB/1.0",
         },
-        timeout: 20000,
+        timeout: 25000,
       },
     );
 
-    return res.status(200).json(response.data);
+    const data = response.data ?? {};
+    const stdout = decode(data.stdout);
+    const stderr = decode(data.stderr);
+    const compileOutput = decode(data.compile_output);
+    const message = decode(data.message);
+    const status = {
+      description: data.status?.description ?? "Unknown",
+      id: Number(data.status?.id ?? 0),
+      successful: Number(data.status?.id ?? 0) === 3,
+    };
+
+    return res.status(200).json({
+      ok: true,
+      execution: {
+        compileOutput,
+        memory: data.memory ?? null,
+        message,
+        output:
+          [compileOutput, stderr, stdout, message]
+            .filter((item) => typeof item === "string" && item.length > 0)
+            .join("\n\n")
+            .trim() || "Code executed with no output.",
+        status,
+        stderr,
+        stdout,
+        time: data.time ?? null,
+        token: data.token ?? null,
+      },
+    });
   } catch (error) {
     const message =
       axios.isAxiosError(error) && error.response?.data
-        ? JSON.stringify(error.response.data)
+        ? typeof error.response.data === "string"
+          ? error.response.data
+          : JSON.stringify(error.response.data)
         : "Compilation failed at the VoidLAB execution gateway.";
 
     return res.status(500).json({ error: message });

apps/api/src/routes/assistant.routes.ts

@@ -1,8 +1,9 @@
 import { Router } from "express";
-import { chatWithAssistant } from "../controllers/assistantController";
+import { chatWithAssistant, streamAssistantChat } from "../controllers/assistantController";
 
 const router = Router();
 
 router.post("/chat", chatWithAssistant);
+router.post("/stream", streamAssistantChat);
 
 export default router;