create-interview-cockpit 0.4.0 → 0.6.0

package/template/server/src/google-drive.ts

@@ -313,6 +313,14 @@ export async function syncWorkspace(
   const questions = pending.filter((p) => !p.isContextFile);
   const contextFiles = pending.filter((p) => p.isContextFile);
 
+  // Collect parent-title links to re-apply after all questions are saved
+  // (IDs are regenerated on import, so we must link by title within a topic)
+  const parentLinks: Array<{
+    questionId: string;
+    topicId: string;
+    parentTitle: string;
+  }> = [];
+
   await Promise.all(
     questions.map(async ({ topicId, filename, buffer }) => {
       try {
@@ -320,6 +328,9 @@ export async function syncWorkspace(
         let systemContext = "";
         let messages: storage.Question["messages"] = [];
         let codeContextFiles: string[] = [];
+        let codeAnnotations: storage.Question["codeAnnotations"] = {};
+        let parentTitle: string | null = null;
+        const restoredContextFiles: storage.ContextFile[] = [];
 
         if (filename.endsWith(".json")) {
           // Our own exported JSON — restore fields directly, no text extraction
@@ -329,6 +340,45 @@ export async function syncWorkspace(
             systemContext = parsed.systemContext || "";
             messages = parsed.messages || [];
             codeContextFiles = parsed.codeContextFiles || [];
+            codeAnnotations = parsed.codeAnnotations || {};
+            parentTitle = parsed.parentTitle || null;
+
+            // Restore code snippet context files (user/ai origin)
+            if (
+              Array.isArray(parsed.codeSnippets) &&
+              parsed.codeSnippets.length > 0
+            ) {
+              const ctxDir =
+                storage.getContextFilesDirForWorkspace(workspaceId);
+              await Promise.all(
+                parsed.codeSnippets.map(
+                  async (cs: storage.ContextFile & { content?: string }) => {
+                    if (
+                      cs.content &&
+                      (cs.origin === "user" ||
+                        cs.origin === "ai" ||
+                        cs.origin === "sandbox" ||
+                        cs.origin === "react" ||
+                        cs.origin === "nextjs" ||
+                        cs.origin === "infra")
+                    ) {
+                      try {
+                        await fs.mkdir(ctxDir, { recursive: true });
+                        await fs.writeFile(
+                          path.join(ctxDir, cs.id),
+                          Buffer.from(cs.content, "utf-8"),
+                        );
+                        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                        const { content: _content, ...cfMeta } = cs;
+                        restoredContextFiles.push(cfMeta);
+                      } catch {
+                        /* skip bad blobs */
+                      }
+                    }
+                  },
+                ),
+              );
+            }
           } catch {
             // Malformed JSON — fall through to raw text
             systemContext = buffer.toString("utf-8");
@@ -344,18 +394,47 @@ export async function syncWorkspace(
           title,
           systemContext,
           codeContextFiles,
-          contextFiles: [],
+          contextFiles: restoredContextFiles,
           messages,
+          codeAnnotations,
           createdAt: new Date().toISOString(),
         };
         await storage.saveQuestion(q);
         result.filesImported++;
+        if (parentTitle) {
+          parentLinks.push({ questionId: q.id, topicId, parentTitle });
+        }
       } catch (err: any) {
         result.errors.push(`${filename}: ${err?.message ?? "failed"}`);
       }
     }),
   );
 
+  // ── Phase 4b: re-link parent–child relationships by title ───────────────────
+  // IDs are regenerated on import, so we match parent by title within the same topic.
+  if (parentLinks.length > 0) {
+    // Group by topicId to avoid redundant getQuestionsByTopic calls
+    const byTopic = new Map<string, typeof parentLinks>();
+    for (const link of parentLinks) {
+      const arr = byTopic.get(link.topicId) ?? [];
+      arr.push(link);
+      byTopic.set(link.topicId, arr);
+    }
+    for (const [topicId, links] of byTopic) {
+      const allInTopic = await storage.getQuestionsByTopic(topicId);
+      for (const { questionId, parentTitle } of links) {
+        const parent = allInTopic.find(
+          (q) => q.title === parentTitle && q.id !== questionId,
+        );
+        const child = allInTopic.find((q) => q.id === questionId);
+        if (parent && child) {
+          child.parentQuestionId = parent.id;
+          await storage.saveQuestion(child);
+        }
+      }
+    }
+  }
+
   // ── Phase 5: save context file blobs in parallel, then update topics.json once ─
   if (contextFiles.length > 0) {
     // Write binary files in parallel
@@ -486,7 +565,35 @@ async function getExportDriveClient(): Promise<drive_v3.Drive> {
       /* ok */
     }
   });
-  return google.drive({ version: "v3", auth: client });
+
+  // Wrap the drive client so any invalid_grant errors clear the stored token
+  // and surface a friendlier error that the caller can detect.
+  const drive = google.drive({ version: "v3", auth: client });
+  const originalFiles = drive.files as any;
+  const patchMethod = (obj: any, method: string) => {
+    const orig = obj[method].bind(obj);
+    obj[method] = async (...args: any[]) => {
+      try {
+        return await orig(...args);
+      } catch (err: any) {
+        if (err?.message?.includes("invalid_grant") || err?.code === 400) {
+          try {
+            await fs.unlink(EXPORT_TOKENS_FILE);
+          } catch {
+            /* already gone */
+          }
+          const e = new Error("NEEDS_REAUTH");
+          (e as any).needsReauth = true;
+          throw e;
+        }
+        throw err;
+      }
+    };
+  };
+  ["create", "update", "delete", "list", "get"].forEach((m) =>
+    patchMethod(originalFiles, m),
+  );
+  return drive;
 }
 
 export interface ExportResult {
@@ -645,13 +752,48 @@ export async function exportWorkspace(
             try {
               const safeName =
                 q.title.replace(/[/\\:*?"<>|]/g, "-").trim() || q.id;
+              // Look up parent title so the relationship can be restored on import
+              const parentTitle = q.parentQuestionId
+                ? questions.find((p) => p.id === q.parentQuestionId)?.title
+                : undefined;
+
+              // Read code snippet blobs so they survive drive sync
+              const ctxDir =
+                storage.getContextFilesDirForWorkspace(workspaceId);
+              const contextFilesWithContent: Array<
+                storage.ContextFile & { content?: string }
+              > = [];
+              for (const cf of q.contextFiles || []) {
+                if (
+                  cf.origin === "user" ||
+                  cf.origin === "ai" ||
+                  cf.origin === "sandbox" ||
+                  cf.origin === "react" ||
+                  cf.origin === "nextjs" ||
+                  cf.origin === "infra"
+                ) {
+                  try {
+                    const content = await fs.readFile(
+                      path.join(ctxDir, cf.id),
+                      "utf-8",
+                    );
+                    contextFilesWithContent.push({ ...cf, content });
+                  } catch {
+                    contextFilesWithContent.push(cf);
+                  }
+                }
+              }
+
               // Export full question as JSON so nothing is lost on sync-back
               const payload = JSON.stringify(
                 {
                   title: q.title,
+                  parentTitle: parentTitle ?? null,
                   systemContext: q.systemContext || "",
                   messages: q.messages,
                   codeContextFiles: q.codeContextFiles,
+                  codeAnnotations: q.codeAnnotations ?? {},
+                  codeSnippets: contextFilesWithContent,
                 },
                 null,
                 2,