create-interview-cockpit 0.6.0 → 0.7.0

package/template/server/src/index.ts

@@ -690,7 +690,14 @@ app.post("/api/questions/:questionId/save-code-snippet", async (req, res) => {
     code: string;
     language: string;
     label: string;
-    origin: "user" | "ai" | "sandbox" | "infra" | "react" | "nextjs";
+    origin:
+      | "user"
+      | "ai"
+      | "sandbox"
+      | "infra"
+      | "react"
+      | "nextjs"
+      | "module-federation";
   };
   if (typeof code !== "string" || !code.trim()) {
     return res.status(400).json({ error: "code is required" });
@@ -701,11 +708,12 @@ app.post("/api/questions/:questionId/save-code-snippet", async (req, res) => {
     origin !== "sandbox" &&
     origin !== "infra" &&
     origin !== "react" &&
-    origin !== "nextjs"
+    origin !== "nextjs" &&
+    origin !== "module-federation"
   ) {
     return res.status(400).json({
       error:
-        "origin must be 'user', 'ai', 'sandbox', 'infra', 'react', or 'nextjs'",
+        "origin must be 'user', 'ai', 'sandbox', 'infra', 'react', 'nextjs', or 'module-federation'",
     });
   }
   try {
@@ -994,7 +1002,7 @@ app.post("/api/frontend-lab/ask", async (req, res) => {
   const { messages, workspace, labType, questionId } = req.body as {
     messages?: Array<{ role: "user" | "assistant"; content: string }>;
     workspace?: Record<string, string>;
-    labType?: "react" | "nextjs";
+    labType?: "react" | "nextjs" | "module-federation";
     questionId?: string;
   };
 
@@ -1008,7 +1016,11 @@ app.post("/api/frontend-lab/ask", async (req, res) => {
   const aiSettings = await storage.getAiSettings();
 
   const typeLabel =
-    labType === "nextjs" ? "Next.js App Router" : "React + TypeScript";
+    labType === "nextjs"
+      ? "Next.js App Router"
+      : labType === "module-federation"
+        ? "Webpack Module Federation"
+        : "React + TypeScript";
 
   let workspaceBlock = "";
   if (workspace && typeof workspace === "object") {
@@ -2280,6 +2292,91 @@ const NEXT_MODULES_DIR = path.join(NEXT_NPX_DIR, "node_modules");
 // walking up the directory tree — no symlinks needed, no Turbopack restrictions.
 const NEXT_SANDBOX_BASE = path.join(NEXT_NPX_DIR, ".sandboxes");
 
+interface ModuleFederationSandboxEntry {
+  child: ReturnType<typeof spawn>;
+  dir: string;
+  hostUrl: string;
+  appUrls: Record<string, string>;
+  workspaceFiles: Set<string>;
+  logs: string[];
+  ready: boolean;
+}
+
+const moduleFederationSandboxes = new Map<
+  string,
+  ModuleFederationSandboxEntry
+>();
+const MODULE_FEDERATION_SANDBOX_BASE = path.join(
+  os.tmpdir(),
+  "interview-cockpit-module-federation",
+);
+
+function appendSandboxLog(logs: string[], text: string): string {
+  const clean = text.replace(/\x1b\[[0-9;]*[A-Za-z]/g, "");
+  logs.push(clean);
+  if (logs.length > 400) {
+    logs.splice(0, logs.length - 400);
+  }
+  return clean;
+}
+
+function npmCommand(): string {
+  return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+
+async function writeModuleFederationSandboxFiles(
+  dir: string,
+  files: Record<string, string>,
+) {
+  for (const [filePath, content] of Object.entries(files)) {
+    const fullPath = path.join(dir, filePath);
+    await fs.mkdir(path.dirname(fullPath), { recursive: true });
+    await fs.writeFile(fullPath, content, "utf8");
+  }
+}
+
+async function runLoggedCommand(
+  command: string,
+  args: string[],
+  options: { cwd: string; env?: NodeJS.ProcessEnv },
+  logs: string[],
+): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+    });
+
+    child.stdout.on("data", (chunk: Buffer) => {
+      appendSandboxLog(logs, chunk.toString());
+    });
+    child.stderr.on("data", (chunk: Buffer) => {
+      appendSandboxLog(logs, chunk.toString());
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(
+        new Error(
+          logs.join("").trim() ||
+            `${command} ${args.join(" ")} exited with code ${String(code)}`,
+        ),
+      );
+    });
+  });
+}
+
+async function getDistinctPorts(count: number): Promise<number[]> {
+  const ports = new Set<number>();
+  while (ports.size < count) {
+    ports.add(await getFreePort());
+  }
+  return Array.from(ports);
+}
+
 /** Write all user files and necessary config into a sandbox directory. */
 async function writeNextSandboxFiles(
   dir: string,
@@ -2480,6 +2577,170 @@ app.delete("/api/nextjs/:id", async (req, res) => {
   res.json({ ok: true });
 });
 
+app.post("/api/module-federation/start", async (req, res) => {
+  const { files } = req.body as { files?: Record<string, string> };
+  if (!files || typeof files !== "object") {
+    return res.status(400).json({ error: "files is required" });
+  }
+  if (typeof files["package.json"] !== "string") {
+    return res.status(400).json({ error: "package.json is required" });
+  }
+
+  const id = randomUUID();
+  const dir = path.join(MODULE_FEDERATION_SANDBOX_BASE, id);
+  const logs: string[] = [];
+
+  try {
+    await fs.mkdir(dir, { recursive: true });
+    await writeModuleFederationSandboxFiles(dir, files);
+
+    await runLoggedCommand(
+      npmCommand(),
+      ["install", "--no-audit", "--no-fund", "--prefer-offline"],
+      {
+        cwd: dir,
+        env: {
+          ...process.env,
+          npm_config_update_notifier: "false",
+        },
+      },
+      logs,
+    );
+
+    const [hostPort, profilePort, checkoutPort] = await getDistinctPorts(3);
+    const appUrls = {
+      host: `http://localhost:${hostPort}`,
+      profile: `http://localhost:${profilePort}`,
+      checkout: `http://localhost:${checkoutPort}`,
+    };
+    const readyPorts = new Set<string>();
+
+    const child = spawn(npmCommand(), ["run", "dev"], {
+      cwd: dir,
+      env: {
+        ...process.env,
+        HOST_PORT: String(hostPort),
+        PROFILE_PORT: String(profilePort),
+        CHECKOUT_PORT: String(checkoutPort),
+        npm_config_update_notifier: "false",
+      },
+    });
+
+    const entry: ModuleFederationSandboxEntry = {
+      child,
+      dir,
+      hostUrl: appUrls.host,
+      appUrls,
+      workspaceFiles: new Set(Object.keys(files)),
+      logs,
+      ready: false,
+    };
+
+    const markReady = (text: string) => {
+      if (text.includes(`localhost:${hostPort}`)) readyPorts.add("host");
+      if (text.includes(`localhost:${profilePort}`)) readyPorts.add("profile");
+      if (text.includes(`localhost:${checkoutPort}`))
+        readyPorts.add("checkout");
+      if (readyPorts.size === 3) {
+        entry.ready = true;
+      }
+    };
+
+    child.stdout.on("data", (chunk: Buffer) => {
+      markReady(appendSandboxLog(logs, chunk.toString()));
+    });
+    child.stderr.on("data", (chunk: Buffer) => {
+      markReady(appendSandboxLog(logs, chunk.toString()));
+    });
+    child.on("exit", () => {
+      moduleFederationSandboxes.delete(id);
+      fs.rm(dir, { recursive: true, force: true }).catch(() => {});
+    });
+
+    moduleFederationSandboxes.set(id, entry);
+
+    const deadline = Date.now() + 90_000;
+    while (!entry.ready && Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, 500));
+      if (!moduleFederationSandboxes.has(id)) {
+        return res.status(500).json({
+          error: logs.join("").trim() || "Webpack module federation lab exited",
+        });
+      }
+    }
+
+    if (!entry.ready) {
+      return res.status(504).json({
+        error: "Webpack module federation lab did not start in time",
+        logs,
+      });
+    }
+
+    res.json({
+      id,
+      hostUrl: entry.hostUrl,
+      appUrls: entry.appUrls,
+    });
+  } catch (error: any) {
+    await fs.rm(dir, { recursive: true, force: true }).catch(() => {});
+    res.status(500).json({
+      error:
+        logs.join("").trim() ||
+        error?.message ||
+        "Failed to start webpack module federation lab",
+    });
+  }
+});
+
+app.post("/api/module-federation/:id/update-files", async (req, res) => {
+  const sandbox = moduleFederationSandboxes.get(req.params.id);
+  if (!sandbox) return res.status(404).json({ error: "Sandbox not found" });
+
+  const { files } = req.body as { files?: Record<string, string> };
+  if (!files || typeof files !== "object") {
+    return res.status(400).json({ error: "files is required" });
+  }
+
+  const nextFiles = new Set(Object.keys(files));
+  await Promise.all(
+    Array.from(sandbox.workspaceFiles)
+      .filter((filePath) => !nextFiles.has(filePath))
+      .map((filePath) =>
+        fs
+          .rm(path.join(sandbox.dir, filePath), { force: true })
+          .catch(() => {}),
+      ),
+  );
+  await writeModuleFederationSandboxFiles(sandbox.dir, files);
+  sandbox.workspaceFiles = nextFiles;
+  res.json({ ok: true });
+});
+
+app.get("/api/module-federation/:id/status", (req, res) => {
+  const sandbox = moduleFederationSandboxes.get(req.params.id);
+  if (!sandbox) {
+    return res.json({ running: false });
+  }
+
+  res.json({
+    running: true,
+    ready: sandbox.ready,
+    hostUrl: sandbox.hostUrl,
+    appUrls: sandbox.appUrls,
+    logs: sandbox.logs.slice(-80),
+  });
+});
+
+app.delete("/api/module-federation/:id", async (req, res) => {
+  const sandbox = moduleFederationSandboxes.get(req.params.id);
+  if (sandbox) {
+    sandbox.child.kill("SIGTERM");
+    moduleFederationSandboxes.delete(req.params.id);
+    await fs.rm(sandbox.dir, { recursive: true, force: true }).catch(() => {});
+  }
+  res.json({ ok: true });
+});
+
 async function getFreePort(): Promise<number> {
   return new Promise((resolve, reject) => {
     const srv = net.createServer();

package/template/server/src/storage.ts

@@ -61,8 +61,17 @@ export interface ContextFile {
    *  'sandbox' = paired server+client sandbox saved as JSON,
    *  'infra' = Terraform-style infra lab workspace saved as JSON,
    *  'react' = React + TypeScript lab workspace,
-   *  'nextjs' = Next.js App Router lab workspace. */
-  origin?: "user" | "ai" | "upload" | "sandbox" | "infra" | "react" | "nextjs";
+   *  'nextjs' = Next.js App Router lab workspace,
+   *  'module-federation' = Webpack Module Federation lab workspace. */
+  origin?:
+    | "user"
+    | "ai"
+    | "upload"
+    | "sandbox"
+    | "infra"
+    | "react"
+    | "nextjs"
+    | "module-federation";
   /** Language hint for code snippets (e.g. 'typescript', 'javascript'). */
   language?: string;
   /** Short display label for code snippets. */