create-interview-cockpit 0.17.3 → 0.19.0

package/template/server/src/index.ts

@@ -36,6 +36,7 @@ import {
   runInfraAction,
   streamInfraCommand,
 } from "./infra-runner.js";
+import { streamGhaCommand, listGhaRuns, getGhaRun } from "./gha-runner.js";
 
 const app = express();
 app.use(cors());
@@ -348,13 +349,63 @@ app.post("/api/workspaces/:id/sync", async (req, res) => {
     // that reset the in-memory _activeWorkspaceId).
     storage.setActiveWorkspaceId(req.params.id);
     const result = await googleDrive.syncWorkspace(req.params.id, extractText);
+    if (result.errors.some((error) => /\b403\b/.test(error))) {
+      return res.json({
+        ...result,
+        needsAuth: true,
+        authUrl: googleDrive.getExportAuthUrl(),
+      });
+    }
     res.json(result);
   } catch (err: any) {
+    if (err?.needsReauth || err?.message === "NEEDS_REAUTH") {
+      return res.json({
+        needsAuth: true,
+        authUrl: googleDrive.getExportAuthUrl(),
+        topicsUpserted: 0,
+        filesImported: 0,
+        filesSkipped: 0,
+        errors: ["Google Drive authorization is required to pull this folder."],
+      });
+    }
     console.error("[sync]", err);
     res.status(500).json({ error: err?.message || "Sync failed" });
   }
 });
 
+app.post("/api/workspaces/:id/topics/:topicId/sync", async (req, res) => {
+  try {
+    // Pull only this topic's Drive folder into the selected workspace.
+    storage.setActiveWorkspaceId(req.params.id);
+    const result = await googleDrive.syncTopic(
+      req.params.id,
+      req.params.topicId,
+      extractText,
+    );
+    if (result.errors.some((error) => /\b403\b/.test(error))) {
+      return res.json({
+        ...result,
+        needsAuth: true,
+        authUrl: googleDrive.getExportAuthUrl(),
+      });
+    }
+    res.json(result);
+  } catch (err: any) {
+    if (err?.needsReauth || err?.message === "NEEDS_REAUTH") {
+      return res.json({
+        needsAuth: true,
+        authUrl: googleDrive.getExportAuthUrl(),
+        topicsUpserted: 0,
+        filesImported: 0,
+        filesSkipped: 0,
+        errors: ["Google Drive authorization is required to pull this topic."],
+      });
+    }
+    console.error("[sync-topic]", err);
+    res.status(500).json({ error: err?.message || "Topic sync failed" });
+  }
+});
+
 app.get("/api/workspaces/:id/drive-subfolders", async (req, res) => {
   try {
     const folders = await googleDrive.listDriveSubfolders(req.params.id);
@@ -396,19 +447,23 @@ app.get("/api/drive/export-auth", (_req, res) => {
   res.redirect(googleDrive.getExportAuthUrl());
 });
 
-app.get("/api/drive/export-callback", async (req, res) => {
+const handleDriveExportCallback = async (req: any, res: any) => {
   const code = req.query.code as string | undefined;
   if (!code) return res.status(400).send("Missing code parameter");
   try {
     await googleDrive.handleExportCallback(code);
-    const clientUrl = process.env.CLIENT_URL ?? "http://localhost:5173";
+    const clientUrl =
+      process.env.CLIENT_URL ??
+      `http://localhost:${process.env.CLIENT_PORT || "5173"}`;
     res.redirect(`${clientUrl}/?export_authed=1`);
   } catch (err: any) {
     res
       .status(500)
       .send(`OAuth callback failed: ${err?.message || "unknown error"}`);
   }
-});
+};
+
+app.get("/api/drive/export-callback", handleDriveExportCallback);
 
 app.post("/api/workspaces/:id/export-drive", async (req, res) => {
   try {
@@ -430,6 +485,30 @@ app.post("/api/workspaces/:id/export-drive", async (req, res) => {
   }
 });
 
+app.post(
+  "/api/workspaces/:id/topics/:topicId/export-drive",
+  async (req, res) => {
+    try {
+      if (!(await googleDrive.isExportAuthed())) {
+        return res.json({
+          needsAuth: true,
+          authUrl: googleDrive.getExportAuthUrl(),
+        });
+      }
+      const { targetFolderId } = req.body as { targetFolderId?: string };
+      const result = await googleDrive.exportTopic(
+        req.params.id,
+        req.params.topicId,
+        targetFolderId,
+      );
+      res.json(result);
+    } catch (err: any) {
+      console.error("[export-topic-drive]", err);
+      res.status(500).json({ error: err?.message || "Topic export failed" });
+    }
+  },
+);
+
 app.post("/api/drive/repair-permissions", async (req, res) => {
   try {
     const { folderId } = req.body as { folderId: string };
@@ -678,6 +757,133 @@ app.post("/api/topics/:topicId/questions", async (req, res) => {
   res.json(question);
 });
 
+app.post("/api/questions/:id/copy", async (req, res) => {
+  const source = await storage.getQuestion(req.params.id);
+  if (!source) return res.status(404).json({ error: "Not found" });
+
+  const targetTopicId =
+    typeof req.body.targetTopicId === "string" && req.body.targetTopicId.trim()
+      ? req.body.targetTopicId.trim()
+      : source.topicId;
+  const topics = await storage.getTopics();
+  if (!topics.some((topic) => topic.id === targetTopicId)) {
+    return res
+      .status(400)
+      .json({ error: "Selected target topic was not found" });
+  }
+
+  const allInSourceTopic = await storage.getQuestionsByTopic(source.topicId);
+  const allInTargetTopic =
+    targetTopicId === source.topicId
+      ? allInSourceTopic
+      : await storage.getQuestionsByTopic(targetTopicId);
+  const requestedParentId =
+    req.body.parentQuestionId === undefined
+      ? targetTopicId === source.topicId
+        ? (source.parentQuestionId ?? null)
+        : null
+      : (req.body.parentQuestionId as string | null);
+
+  if (requestedParentId !== null && typeof requestedParentId !== "string") {
+    return res.status(400).json({ error: "Invalid parent question" });
+  }
+
+  if (
+    requestedParentId &&
+    !allInTargetTopic.some((candidate) => candidate.id === requestedParentId)
+  ) {
+    return res
+      .status(400)
+      .json({ error: "Selected parent question was not found" });
+  }
+
+  const collectSubtree = (parent: storage.Question): storage.Question[] => {
+    const children = allInSourceTopic.filter(
+      (candidate) => candidate.parentQuestionId === parent.id,
+    );
+    return [parent, ...children.flatMap((child) => collectSubtree(child))];
+  };
+
+  const cloneJson = <T>(value: T): T =>
+    value === undefined ? value : JSON.parse(JSON.stringify(value));
+
+  const copyContextFiles = async (
+    files: storage.ContextFile[] = [],
+  ): Promise<storage.ContextFile[]> => {
+    const dir = storage.getContextFilesDir();
+    const copies: storage.ContextFile[] = [];
+
+    for (const file of files) {
+      const nextId = randomUUID();
+      try {
+        const buffer = await fs.readFile(path.join(dir, file.id));
+        await fs.writeFile(path.join(dir, nextId), buffer);
+      } catch {
+        // Skip stale metadata entries whose backing blob no longer exists.
+        continue;
+      }
+
+      const {
+        id: _oldId,
+        createdAt: _oldCreatedAt,
+        driveFileId: _oldDriveFileId,
+        ...rest
+      } = cloneJson(file);
+
+      copies.push({
+        ...rest,
+        id: nextId,
+        createdAt: new Date().toISOString(),
+      });
+    }
+
+    return copies;
+  };
+
+  const subtree = collectSubtree(source);
+  const idMap = new Map(subtree.map((question) => [question.id, randomUUID()]));
+  const copied: storage.Question[] = [];
+
+  for (const question of subtree) {
+    const nextId = idMap.get(question.id)!;
+    const parentQuestionId =
+      question.id === source.id
+        ? (requestedParentId ?? undefined)
+        : idMap.get(question.parentQuestionId || "") || undefined;
+    const linkedConversationIds = (question.linkedConversationIds || [])
+      .map(
+        (linkedId) =>
+          idMap.get(linkedId) ||
+          (targetTopicId === source.topicId ? linkedId : null),
+      )
+      .filter((linkedId): linkedId is string => Boolean(linkedId));
+
+    const copy: storage.Question = {
+      ...cloneJson(question),
+      id: nextId,
+      topicId: targetTopicId,
+      parentQuestionId,
+      title:
+        question.id === source.id ? `${question.title} (copy)` : question.title,
+      contextFiles: await copyContextFiles(question.contextFiles || []),
+      messages: cloneJson(question.messages || []),
+      annotations: cloneJson(question.annotations || []),
+      codeAnnotations: cloneJson(question.codeAnnotations || {}),
+      codeContextFiles: [...(question.codeContextFiles || [])],
+      linkedConversationIds,
+      createdAt: new Date().toISOString(),
+    };
+
+    if (!copy.parentQuestionId) delete copy.parentQuestionId;
+    if (linkedConversationIds.length === 0) delete copy.linkedConversationIds;
+
+    await storage.saveQuestion(copy);
+    copied.push(copy);
+  }
+
+  res.json(copied);
+});
+
 app.get("/api/questions/:id", async (req, res) => {
   const q = await storage.getQuestion(req.params.id);
   if (!q) return res.status(404).json({ error: "Not found" });
@@ -868,7 +1074,9 @@ app.post("/api/questions/:questionId/save-code-snippet", async (req, res) => {
       | "infra"
       | "react"
       | "nextjs"
-      | "module-federation";
+      | "module-federation"
+      | "canvas"
+      | "github-actions";
   };
   if (typeof code !== "string" || !code.trim()) {
     return res.status(400).json({ error: "code is required" });
@@ -882,11 +1090,12 @@ app.post("/api/questions/:questionId/save-code-snippet", async (req, res) => {
     origin !== "react" &&
     origin !== "nextjs" &&
     origin !== "module-federation" &&
-    origin !== "canvas"
+    origin !== "canvas" &&
+    origin !== "github-actions"
   ) {
     return res.status(400).json({
       error:
-        "origin must be 'user', 'ai', 'sandbox', 'browser-security', 'infra', 'react', 'nextjs', 'module-federation', or 'canvas'",
+        "origin must be 'user', 'ai', 'sandbox', 'browser-security', 'infra', 'react', 'nextjs', 'module-federation', 'canvas', or 'github-actions'",
     });
   }
   try {
@@ -1073,6 +1282,18 @@ app.post("/api/infra/ask", async (req, res) => {
   const aiSettings = await storage.getAiSettings();
 
   // Build workspace context block
+  const languageForInfraFile = (name: string) => {
+    const lower = name.toLowerCase();
+    if (lower.endsWith(".tf") || lower.endsWith(".tfvars")) return "hcl";
+    if (lower.endsWith(".yaml") || lower.endsWith(".yml")) return "yaml";
+    if (lower.endsWith(".json")) return "json";
+    if (lower.endsWith(".js") || lower.endsWith(".mjs")) return "javascript";
+    if (lower.endsWith(".ts")) return "typescript";
+    if (lower.endsWith(".md")) return "markdown";
+    if (lower.split("/").pop() === "dockerfile") return "dockerfile";
+    return "text";
+  };
+
   let workspaceBlock = "";
   if (workspace && typeof workspace === "object") {
     const entries = Object.entries(workspace).filter(
@@ -1081,15 +1302,15 @@ app.post("/api/infra/ask", async (req, res) => {
     if (entries.length > 0) {
       workspaceBlock = "\n\n--- Workspace Files ---\n";
       for (const [name, content] of entries) {
-        workspaceBlock += `\n### ${name}\n\`\`\`hcl\n${content}\n\`\`\`\n`;
+        workspaceBlock += `\n### ${name}\n\`\`\`${languageForInfraFile(name)}\n${content}\n\`\`\`\n`;
       }
     }
   }
 
   const system =
-    `You are a senior infrastructure engineer and Terraform expert acting as a coding assistant inside an Infrastructure Lab.\n` +
-    `The user is editing a Terraform workspace. Answer questions about their code clearly and accurately.\n` +
-    `When suggesting edits, show the changed HCL as a fenced \`\`\`hcl code block.\n` +
+    `You are a senior infrastructure engineer and Terraform/Docker expert acting as a coding assistant inside an Infrastructure Lab.\n` +
+    `The user is editing an infrastructure workspace that may include Terraform, Docker, and local app files. Answer questions about their code and local Docker workflow clearly and accurately.\n` +
+    `When suggesting edits, use the appropriate fenced code language: hcl, dockerfile, yaml, javascript, json, or markdown.\n` +
     `Be concise unless the user asks for a deeper explanation.` +
     workspaceBlock;
 
@@ -1310,6 +1531,79 @@ app.get("/api/infra/runs/:runId", async (req, res) => {
   }
 });
 
+// ─── GitHub Actions Lab (act) ───────────────────────────────────────────
+app.post("/api/gha/run-stream", async (req, res) => {
+  const { questionId, fileId, label, command, workspace } = req.body as {
+    questionId?: string;
+    fileId?: string;
+    label?: string;
+    command?: string;
+    workspace?: unknown;
+  };
+
+  res.setHeader("Content-Type", "text/event-stream");
+  res.setHeader("Cache-Control", "no-cache");
+  res.setHeader("Connection", "keep-alive");
+  res.flushHeaders();
+
+  const send = (payload: unknown) => {
+    res.write(`data: ${JSON.stringify(payload)}\n\n`);
+  };
+
+  if (typeof command !== "string" || !command.trim()) {
+    send({ type: "error", error: "command is required" });
+    res.end();
+    return;
+  }
+
+  try {
+    await streamGhaCommand({
+      questionId,
+      fileId,
+      label,
+      command,
+      workspace,
+      onMessage: send,
+    });
+  } catch (err: any) {
+    send({
+      type: "error",
+      error: err?.message || "Failed to run act command",
+    });
+  }
+
+  res.end();
+});
+
+// List historical act runs, optionally scoped to a lab file or question.
+app.get("/api/gha/runs", async (req, res) => {
+  try {
+    const { questionId, fileId, limit } = req.query as {
+      questionId?: string;
+      fileId?: string;
+      limit?: string;
+    };
+    const parsedLimit = limit ? Number(limit) : undefined;
+    const runs = await listGhaRuns({
+      questionId,
+      fileId,
+      ...(Number.isFinite(parsedLimit) ? { limit: parsedLimit } : {}),
+    });
+    res.json(runs);
+  } catch (err: any) {
+    res.status(500).json({ error: err?.message || "Failed to list gha runs" });
+  }
+});
+
+app.get("/api/gha/runs/:runId", async (req, res) => {
+  try {
+    const run = await getGhaRun(req.params.runId);
+    res.json(run);
+  } catch {
+    res.status(404).json({ error: "GHA run not found" });
+  }
+});
+
 // Link an existing file to a topic without re-uploading
 app.post("/api/topics/:topicId/context-files/link", async (req, res) => {
   const { fileId, originalName } = req.body as {
@@ -3983,4 +4277,27 @@ app.delete("/api/react-lab/:id", async (req, res) => {
   app.listen(PORT, () => {
     console.log(`\n  ✈  Interview Cockpit server → http://localhost:${PORT}\n`);
   });
+
+  const callbackBridgePort = Number(
+    process.env.GOOGLE_EXPORT_REDIRECT_PORT || "3001",
+  );
+  const mainPort = Number(PORT);
+  if (
+    !process.env.GOOGLE_EXPORT_REDIRECT_URI &&
+    callbackBridgePort !== mainPort
+  ) {
+    const callbackApp = express();
+    callbackApp.get("/api/drive/export-callback", handleDriveExportCallback);
+    callbackApp
+      .listen(callbackBridgePort, () => {
+        console.log(
+          `  ↪  Google Drive OAuth callback bridge → http://localhost:${callbackBridgePort}/api/drive/export-callback\n`,
+        );
+      })
+      .on("error", (err: any) => {
+        console.warn(
+          `Google Drive OAuth callback bridge could not listen on ${callbackBridgePort}: ${err?.message || err}`,
+        );
+      });
+  }
 })();