create-interview-cockpit 0.17.3 → 0.19.0

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

@@ -138,7 +138,11 @@ async function downloadFileAuthed(
 }
 
 const WORKSPACE_FILES_FOLDER_NAME = "workspace-files";
-const RESERVED_EXPORT_FOLDER_NAMES = new Set([WORKSPACE_FILES_FOLDER_NAME]);
+const EXPORT_FOLDER_NAME = "_export";
+const RESERVED_EXPORT_FOLDER_NAMES = new Set([
+  WORKSPACE_FILES_FOLDER_NAME,
+  EXPORT_FOLDER_NAME,
+]);
 
 function extensionForFilename(filename: string): string {
   return filename.split(".").pop()?.toLowerCase() ?? "";
@@ -224,6 +228,173 @@ export interface SyncResult {
   errors: string[];
 }
 
+function getWorkspaceSyncRoot(ws: storage.WorkspaceMeta): string {
+  if (!ws.driveConfig?.folderId) {
+    throw new Error("No Drive folder linked to this workspace");
+  }
+  return ws.driveConfig.subFolderId || ws.driveConfig.folderId;
+}
+
+async function getDriveReadAdapters(): Promise<{
+  doListFolders: (id: string) => Promise<DriveItem[]>;
+  doListFiles: (id: string) => Promise<DriveItem[]>;
+  doDownload: (id: string, mime: string) => Promise<Buffer>;
+}> {
+  // Use OAuth client when available — it bypasses public sharing restrictions.
+  // Fall back to API-key functions for read-only public workspaces.
+  const authed = await isExportAuthed();
+  const drive = authed ? await getExportDriveClient() : null;
+
+  return {
+    doListFolders: drive
+      ? (id: string) => listFoldersAuthed(drive, id)
+      : listFolders,
+    doListFiles: drive ? (id: string) => listFilesAuthed(drive, id) : listFiles,
+    doDownload: drive
+      ? (id: string, mime: string) => downloadFileAuthed(drive, id, mime)
+      : downloadFile,
+  };
+}
+
+type ParentTitleLink = {
+  questionId: string;
+  topicId: string;
+  parentTitle: string;
+};
+
+async function importQuestionFromDriveBuffer(input: {
+  workspaceId: string;
+  topicId: string;
+  filename: string;
+  buffer: Buffer;
+  extractText: (buffer: Buffer, filename: string) => Promise<string>;
+  parentLinks: ParentTitleLink[];
+  result: SyncResult;
+}): Promise<void> {
+  const { workspaceId, topicId, filename, buffer, extractText, parentLinks } =
+    input;
+  const { result } = input;
+
+  try {
+    let title = filename.replace(/\.[^/.]+$/, "") || filename;
+    let systemContext = "";
+    let messages: storage.Question["messages"] = [];
+    let codeContextFiles: string[] = [];
+    let codeAnnotations: storage.Question["codeAnnotations"] = {};
+    let parentTitle: string | null = null;
+    let restoredCreatedAt: string | null = null;
+    const restoredContextFiles: storage.ContextFile[] = [];
+
+    if (filename.endsWith(".json")) {
+      try {
+        const parsed = JSON.parse(buffer.toString("utf-8"));
+        title = parsed.title || title;
+        systemContext = parsed.systemContext || "";
+        messages = parsed.messages || [];
+        codeContextFiles = parsed.codeContextFiles || [];
+        codeAnnotations = parsed.codeAnnotations || {};
+        parentTitle = parsed.parentTitle || null;
+        if (parsed.createdAt) restoredCreatedAt = parsed.createdAt;
+
+        const parsedContextFiles: SerializedContextFile[] = Array.isArray(
+          parsed.contextFiles,
+        )
+          ? parsed.contextFiles
+          : Array.isArray(parsed.codeSnippets)
+            ? parsed.codeSnippets
+            : [];
+        if (parsedContextFiles.length > 0) {
+          const ctxDir = storage.getContextFilesDirForWorkspace(workspaceId);
+          await Promise.all(
+            parsedContextFiles.map(async (cs) => {
+              if (!cs.id) return;
+              const originalName = cs.originalName || cs.name || cs.id;
+              try {
+                const originalBuffer = cs.originalBase64
+                  ? Buffer.from(cs.originalBase64, "base64")
+                  : null;
+                const content =
+                  typeof cs.content === "string"
+                    ? cs.content
+                    : originalBuffer
+                      ? await extractText(originalBuffer, originalName)
+                      : null;
+
+                if (content == null) return;
+                await fs.mkdir(ctxDir, { recursive: true });
+                await fs.writeFile(
+                  path.join(ctxDir, cs.id),
+                  Buffer.from(content, "utf-8"),
+                );
+                if (originalBuffer) {
+                  await storage.writeOriginalBlob(
+                    cs.id,
+                    originalBuffer,
+                    workspaceId,
+                  );
+                }
+                restoredContextFiles.push(
+                  contextFileMetadataForImport(cs, originalName),
+                );
+              } catch {
+                /* skip bad blobs */
+              }
+            }),
+          );
+        }
+      } catch {
+        systemContext = buffer.toString("utf-8");
+      }
+    } else {
+      systemContext = await extractText(buffer, filename);
+    }
+
+    const q: storage.Question = {
+      id: randomUUID(),
+      topicId,
+      title,
+      systemContext,
+      codeContextFiles,
+      contextFiles: restoredContextFiles,
+      messages,
+      codeAnnotations,
+      createdAt: restoredCreatedAt ?? 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"}`);
+  }
+}
+
+async function relinkImportedParents(
+  parentLinks: ParentTitleLink[],
+): Promise<void> {
+  if (parentLinks.length === 0) return;
+  const byTopic = new Map<string, ParentTitleLink[]>();
+  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);
+      }
+    }
+  }
+}
+
 export async function syncWorkspace(
   workspaceId: string,
   extractText: (buffer: Buffer, filename: string) => Promise<string>,
@@ -234,25 +405,12 @@ export async function syncWorkspace(
     throw new Error("No Drive folder linked to this workspace");
   }
 
-  const { folderId, subFolderId } = ws.driveConfig;
-  const syncRoot = subFolderId || folderId;
+  const syncRoot = getWorkspaceSyncRoot(ws);
 
   storage.setActiveWorkspaceId(workspaceId);
 
-  // Use OAuth client when available — it bypasses public sharing restrictions.
-  // Fall back to API-key functions for read-only public workspaces.
-  const authed = await isExportAuthed();
-  const drive = authed ? await getExportDriveClient() : null;
-
-  const doListFolders = drive
-    ? (id: string) => listFoldersAuthed(drive, id)
-    : listFolders;
-  const doListFiles = drive
-    ? (id: string) => listFilesAuthed(drive, id)
-    : listFiles;
-  const doDownload = drive
-    ? (id: string, mime: string) => downloadFileAuthed(drive, id, mime)
-    : downloadFile;
+  const { doListFolders, doListFiles, doDownload } =
+    await getDriveReadAdapters();
 
   const result: SyncResult = {
     topicsUpserted: 0,
@@ -261,9 +419,6 @@ export async function syncWorkspace(
     errors: [],
   };
 
-  // ── Phase 0: fast wipe (parallel deletes instead of serial deleteTopic calls) ──
-  await storage.clearWorkspaceData(workspaceId);
-
   const importedQuestionKeys = new Set<string>();
 
   // ── Phase 1: fetch all folder listings in parallel ──────────────────────────
@@ -301,15 +456,14 @@ export async function syncWorkspace(
       : Promise.resolve([]),
   ]);
 
-  // ── Phase 2: write all topics in one batch (one topics.json write) ───────────
+  // ── Phase 2: build topic records in memory ─────────────────────────────────
   const topicRecords: storage.Topic[] = folderData.map(({ folder }) => ({
     id: randomUUID(),
     name: folder.name,
     contextFiles: [],
     createdAt: new Date().toISOString(),
   }));
-  await storage.replaceAllTopics(topicRecords);
-  result.topicsUpserted = topicRecords.length;
+  const extraTopicRecords: storage.Topic[] = [];
 
   const topicIdByFolderId = new Map(
     folderData.map(({ folder }, i) => [folder.id, topicRecords[i].id]),
@@ -394,8 +548,7 @@ export async function syncWorkspace(
       contextFiles: [],
       createdAt: new Date().toISOString(),
     };
-    await storage.saveTopic(generalTopic);
-    result.topicsUpserted++;
+    extraTopicRecords.push(generalTopic);
 
     await Promise.all(
       rootFiles.map(async (file) => {
@@ -420,6 +573,18 @@ export async function syncWorkspace(
     );
   }
 
+  // If downloads hit private Drive files or an old token lacks enough scope,
+  // stop before wiping the local workspace. The route will prompt re-auth.
+  if (result.errors.some((error) => /\b403\b/.test(error))) {
+    return result;
+  }
+
+  // ── Phase 3b: fast wipe + write all topics in one batch ────────────────────
+  await storage.clearWorkspaceData(workspaceId);
+  const allTopicRecords = [...topicRecords, ...extraTopicRecords];
+  await storage.replaceAllTopics(allTopicRecords);
+  result.topicsUpserted = allTopicRecords.length;
+
   // ── Phase 4: save questions in parallel (each is an individual file) ─────────
   const questions = pending.filter((p) => !p.isContextFile);
   const contextFiles = pending.filter((p) => p.isContextFile);
@@ -563,19 +728,19 @@ export async function syncWorkspace(
 
   // ── Phase 5: save workspace/topic context file blobs ───────────────────────
   if (pendingWorkspaceFiles.length > 0) {
-    await Promise.all(
-      pendingWorkspaceFiles.map(async ({ filename, buffer }) => {
-        const fileId = randomUUID();
-        const text = await extractText(buffer, filename);
-        await storage.writeOriginalBlob(fileId, buffer, workspaceId);
-        await storage.saveWorkspaceContextFile(
-          fileId,
-          filename,
-          Buffer.from(text, "utf-8"),
-          workspaceId,
-        );
-      }),
-    );
+    // saveWorkspaceContextFile updates workspace-files.json; do this
+    // sequentially so concurrent reads/writes do not overwrite metadata.
+    for (const { filename, buffer } of pendingWorkspaceFiles) {
+      const fileId = randomUUID();
+      const text = await extractText(buffer, filename);
+      await storage.writeOriginalBlob(fileId, buffer, workspaceId);
+      await storage.saveWorkspaceContextFile(
+        fileId,
+        filename,
+        Buffer.from(text, "utf-8"),
+        workspaceId,
+      );
+    }
     result.filesImported += pendingWorkspaceFiles.length;
   }
 
@@ -622,6 +787,168 @@ export async function syncWorkspace(
   return result;
 }
 
+export async function syncTopic(
+  workspaceId: string,
+  topicId: string,
+  extractText: (buffer: Buffer, filename: string) => Promise<string>,
+): Promise<SyncResult> {
+  const registry = await storage.getWorkspaces();
+  const ws = registry.workspaces.find((w) => w.id === workspaceId);
+  if (!ws?.driveConfig?.folderId) {
+    throw new Error("No Drive folder linked to this workspace");
+  }
+
+  storage.setActiveWorkspaceId(workspaceId);
+  const topics = await storage.getTopics();
+  const topic = topics.find((t) => t.id === topicId);
+  if (!topic) {
+    throw new Error("Topic not found");
+  }
+
+  const syncRoot = getWorkspaceSyncRoot(ws);
+  const { doListFolders, doListFiles, doDownload } =
+    await getDriveReadAdapters();
+  const subfolders = await doListFolders(syncRoot);
+  let topicFolder = subfolders.find((folder) => folder.name === topic.name);
+  if (!topicFolder && !ws.driveConfig.subFolderId) {
+    // Workspace-level push uses an _export folder when no Drive subfolder is
+    // selected. Check there too so "Push topic" then "Pull topic" round-trips.
+    const exportFolder = subfolders.find(
+      (folder) => folder.name === EXPORT_FOLDER_NAME,
+    );
+    if (exportFolder) {
+      const exportedTopicFolders = await doListFolders(exportFolder.id);
+      topicFolder = exportedTopicFolders.find(
+        (folder) => folder.name === topic.name,
+      );
+    }
+  }
+  if (!topicFolder) {
+    throw new Error(`No Drive topic folder named "${topic.name}" was found`);
+  }
+
+  const result: SyncResult = {
+    topicsUpserted: 0,
+    filesImported: 0,
+    filesSkipped: 0,
+    errors: [],
+  };
+
+  const innerFolders = await doListFolders(topicFolder.id);
+  const questionsFolder = innerFolders.find((f) => f.name === "questions");
+  const ctxFilesFolder = innerFolders.find((f) => f.name === "context-files");
+
+  const [qFiles, cfFiles] = await Promise.all([
+    questionsFolder
+      ? doListFiles(questionsFolder.id)
+      : doListFiles(topicFolder.id),
+    ctxFilesFolder ? doListFiles(ctxFilesFolder.id) : Promise.resolve([]),
+  ]);
+
+  type Pending = {
+    filename: string;
+    buffer: Buffer;
+    isContextFile: boolean;
+  };
+  const pending: Pending[] = [];
+  const importedQuestionTitles = new Set<string>();
+
+  await Promise.all([
+    ...qFiles.map(async (file) => {
+      const title = file.name.replace(/\.[^/.]+$/, "") || file.name;
+      if (importedQuestionTitles.has(title)) {
+        result.filesSkipped++;
+        return;
+      }
+      try {
+        const buffer = await doDownload(file.id, file.mimeType);
+        pending.push({ filename: file.name, buffer, isContextFile: false });
+        importedQuestionTitles.add(title);
+      } catch (err: any) {
+        result.errors.push(`${file.name}: ${err?.message ?? "failed"}`);
+      }
+    }),
+    ...cfFiles.map(async (cf) => {
+      try {
+        const buffer = await doDownload(cf.id, cf.mimeType);
+        pending.push({ filename: cf.name, buffer, isContextFile: true });
+      } catch (err: any) {
+        result.errors.push(
+          `Context file "${cf.name}": ${err?.message ?? "failed"}`,
+        );
+      }
+    }),
+  ]);
+
+  // If downloads hit private Drive files or an old token lacks enough scope,
+  // stop before replacing the local topic. The route will prompt re-auth.
+  if (result.errors.some((error) => /\b403\b/.test(error))) {
+    return result;
+  }
+
+  const ctxDir = storage.getContextFilesDirForWorkspace(workspaceId);
+  await Promise.all(
+    (topic.contextFiles || []).map((cf) =>
+      fs.unlink(path.join(ctxDir, cf.id)).catch(() => {}),
+    ),
+  );
+  const oldQuestions = await storage.getQuestionsByTopic(topicId);
+  await Promise.all(oldQuestions.map((q) => storage.deleteQuestion(q.id)));
+
+  const questions = pending.filter((p) => !p.isContextFile);
+  const contextFiles = pending.filter((p) => p.isContextFile);
+  const parentLinks: ParentTitleLink[] = [];
+
+  await Promise.all(
+    questions.map(({ filename, buffer }) =>
+      importQuestionFromDriveBuffer({
+        workspaceId,
+        topicId,
+        filename,
+        buffer,
+        extractText,
+        parentLinks,
+        result,
+      }),
+    ),
+  );
+  await relinkImportedParents(parentLinks);
+
+  const importedTopicContextFiles = await Promise.all(
+    contextFiles.map(async ({ filename, buffer }) => {
+      const fileId = randomUUID();
+      const text = await extractText(buffer, filename);
+      await storage.writeOriginalBlob(fileId, buffer, workspaceId);
+      await storage.writeContextFileBlob(
+        workspaceId,
+        fileId,
+        Buffer.from(text, "utf-8"),
+      );
+      result.filesImported++;
+      return {
+        id: fileId,
+        name: filename,
+        originalName: filename,
+        createdAt: new Date().toISOString(),
+      } satisfies storage.ContextFile;
+    }),
+  );
+
+  await storage.updateTopic(topicId, {
+    contextFiles: importedTopicContextFiles,
+  });
+  result.topicsUpserted = 1;
+
+  await storage.updateWorkspace(workspaceId, {
+    driveConfig: {
+      ...ws.driveConfig,
+      lastSyncedAt: new Date().toISOString(),
+    },
+  });
+
+  return result;
+}
+
 /** List subfolders directly inside the workspace's linked Drive folder (public API key read). */
 export async function listDriveSubfolders(
   workspaceId: string,
@@ -631,6 +958,10 @@ export async function listDriveSubfolders(
   if (!ws?.driveConfig?.folderId) {
     throw new Error("No Drive folder linked to this workspace");
   }
+  if (await isExportAuthed()) {
+    const drive = await getExportDriveClient();
+    return listFoldersAuthed(drive, ws.driveConfig.folderId);
+  }
   return listFolders(ws.driveConfig.folderId);
 }
 
@@ -663,11 +994,11 @@ const EXPORT_TOKENS_FILE = path.resolve(
 );
 
 function createExportOAuthClient() {
+  const defaultRedirectUri = `http://localhost:${process.env.GOOGLE_EXPORT_REDIRECT_PORT || "3001"}/api/drive/export-callback`;
   return new google.auth.OAuth2(
     process.env.GOOGLE_CLIENT_ID,
     process.env.GOOGLE_CLIENT_SECRET,
-    process.env.GOOGLE_EXPORT_REDIRECT_URI ||
-      "http://localhost:3001/api/drive/export-callback",
+    process.env.GOOGLE_EXPORT_REDIRECT_URI || defaultRedirectUri,
   );
 }
 
@@ -675,7 +1006,7 @@ export function getExportAuthUrl(): string {
   const client = createExportOAuthClient();
   return client.generateAuthUrl({
     access_type: "offline",
-    scope: ["https://www.googleapis.com/auth/drive.file"],
+    scope: ["https://www.googleapis.com/auth/drive"],
     prompt: "consent",
   });
 }
@@ -878,6 +1209,128 @@ async function uploadFileToFolder(
   }
 }
 
+async function exportTopicToFolder(input: {
+  drive: drive_v3.Drive;
+  workspaceId: string;
+  exportFolderId: string;
+  topic: storage.Topic;
+  ctxDir: string;
+  result: ExportResult;
+}): Promise<void> {
+  const { drive, workspaceId, exportFolderId, topic, ctxDir, result } = input;
+
+  try {
+    const topicFolderId = await getOrCreateFolder(
+      drive,
+      exportFolderId,
+      topic.name,
+    );
+    const questions = await storage.getQuestionsByTopicForWorkspace(
+      workspaceId,
+      topic.id,
+    );
+
+    // Upload questions into a questions/ subfolder (parallel uploads)
+    if (questions.length > 0) {
+      const questionsFolderId = await getOrCreateFolder(
+        drive,
+        topicFolderId,
+        "questions",
+      );
+      await Promise.all(
+        questions.map(async (q) => {
+          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 every question-attached context file so uploaded docs,
+            // images, and generated code snippets survive Drive sync.
+            const contextFilesWithContent = await Promise.all(
+              (q.contextFiles || []).map((cf) =>
+                serializeContextFileForExport(cf, workspaceId, ctxDir),
+              ),
+            );
+            const legacyCodeSnippets = contextFilesWithContent.filter(
+              (cf) => cf.origin && cf.origin !== "upload",
+            );
+
+            // 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 ?? {},
+                contextFiles: contextFilesWithContent,
+                codeSnippets: legacyCodeSnippets,
+                createdAt: q.createdAt,
+              },
+              null,
+              2,
+            );
+            await uploadFileToFolder(
+              drive,
+              questionsFolderId,
+              `${safeName}.json`,
+              payload,
+              "application/json",
+            );
+            result.questionsExported++;
+          } catch (err: any) {
+            result.errors.push(
+              `Question "${q.title}": ${err?.message || "upload failed"}`,
+            );
+          }
+        }),
+      );
+    }
+
+    // Upload context files into a context-files/ subfolder (parallel uploads)
+    if (topic.contextFiles.length > 0) {
+      const ctxFolderId = await getOrCreateFolder(
+        drive,
+        topicFolderId,
+        "context-files",
+      );
+      await Promise.all(
+        topic.contextFiles.map(async (cf) => {
+          try {
+            const buffer = await readContextFileExportBytes(
+              cf,
+              workspaceId,
+              ctxDir,
+            );
+            await uploadFileToFolder(
+              drive,
+              ctxFolderId,
+              cf.originalName,
+              buffer,
+              mimeForFilename(cf.originalName),
+            );
+            result.filesExported++;
+          } catch (err: any) {
+            result.errors.push(
+              `File "${cf.originalName}": ${err?.message || "upload failed"}`,
+            );
+          }
+        }),
+      );
+    }
+
+    result.topicsExported++;
+  } catch (err: any) {
+    result.errors.push(
+      `Topic "${topic.name}": ${err?.message || "export failed"}`,
+    );
+  }
+}
+
 export async function exportWorkspace(
   workspaceId: string,
   targetFolderId?: string,
@@ -899,7 +1352,8 @@ export async function exportWorkspace(
 
   // Use the chosen subfolder directly, or fall back to an "_export" subfolder
   const exportFolderId =
-    targetFolderId ?? (await getOrCreateFolder(drive, folderId, "_export"));
+    targetFolderId ??
+    (await getOrCreateFolder(drive, folderId, EXPORT_FOLDER_NAME));
   const topics = await storage.getTopicsForWorkspace(workspaceId);
   const ctxDir = storage.getContextFilesDirForWorkspace(workspaceId);
 
@@ -936,117 +1390,56 @@ export async function exportWorkspace(
   }
 
   for (const topic of topics) {
-    try {
-      const topicFolderId = await getOrCreateFolder(
-        drive,
-        exportFolderId,
-        topic.name,
-      );
-      const questions = await storage.getQuestionsByTopicForWorkspace(
-        workspaceId,
-        topic.id,
-      );
-
-      // Upload questions into a questions/ subfolder (parallel uploads)
-      if (questions.length > 0) {
-        const questionsFolderId = await getOrCreateFolder(
-          drive,
-          topicFolderId,
-          "questions",
-        );
-        await Promise.all(
-          questions.map(async (q) => {
-            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 every question-attached context file so uploaded docs,
-              // images, and generated code snippets survive Drive sync.
-              const contextFilesWithContent = await Promise.all(
-                (q.contextFiles || []).map((cf) =>
-                  serializeContextFileForExport(cf, workspaceId, ctxDir),
-                ),
-              );
-              const legacyCodeSnippets = contextFilesWithContent.filter(
-                (cf) => cf.origin && cf.origin !== "upload",
-              );
+    await exportTopicToFolder({
+      drive,
+      workspaceId,
+      exportFolderId,
+      topic,
+      ctxDir,
+      result,
+    });
+  }
 
-              // 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 ?? {},
-                  contextFiles: contextFilesWithContent,
-                  codeSnippets: legacyCodeSnippets,
-                  createdAt: q.createdAt,
-                },
-                null,
-                2,
-              );
-              await uploadFileToFolder(
-                drive,
-                questionsFolderId,
-                `${safeName}.json`,
-                payload,
-                "application/json",
-              );
-              result.questionsExported++;
-            } catch (err: any) {
-              result.errors.push(
-                `Question "${q.title}": ${err?.message || "upload failed"}`,
-              );
-            }
-          }),
-        );
-      }
+  return result;
+}
 
-      // Upload context files into a context-files/ subfolder (parallel uploads)
-      if (topic.contextFiles.length > 0) {
-        const ctxFolderId = await getOrCreateFolder(
-          drive,
-          topicFolderId,
-          "context-files",
-        );
-        await Promise.all(
-          topic.contextFiles.map(async (cf) => {
-            try {
-              const buffer = await readContextFileExportBytes(
-                cf,
-                workspaceId,
-                ctxDir,
-              );
-              await uploadFileToFolder(
-                drive,
-                ctxFolderId,
-                cf.originalName,
-                buffer,
-                mimeForFilename(cf.originalName),
-              );
-              result.filesExported++;
-            } catch (err: any) {
-              result.errors.push(
-                `File "${cf.originalName}": ${err?.message || "upload failed"}`,
-              );
-            }
-          }),
-        );
-      }
+export async function exportTopic(
+  workspaceId: string,
+  topicId: string,
+  targetFolderId?: string,
+): Promise<ExportResult> {
+  const registry = await storage.getWorkspaces();
+  const ws = registry.workspaces.find((w) => w.id === workspaceId);
+  if (!ws?.driveConfig?.folderId) {
+    throw new Error("No Drive folder linked to this workspace");
+  }
 
-      result.topicsExported++;
-    } catch (err: any) {
-      result.errors.push(
-        `Topic "${topic.name}": ${err?.message || "export failed"}`,
-      );
-    }
+  const drive = await getExportDriveClient();
+  const { folderId } = ws.driveConfig;
+  const exportFolderId =
+    targetFolderId ??
+    (await getOrCreateFolder(drive, folderId, EXPORT_FOLDER_NAME));
+  const topic = (await storage.getTopicsForWorkspace(workspaceId)).find(
+    (t) => t.id === topicId,
+  );
+  if (!topic) {
+    throw new Error("Topic not found");
   }
 
+  const result: ExportResult = {
+    topicsExported: 0,
+    questionsExported: 0,
+    filesExported: 0,
+    errors: [],
+  };
+  const ctxDir = storage.getContextFilesDirForWorkspace(workspaceId);
+  await exportTopicToFolder({
+    drive,
+    workspaceId,
+    exportFolderId,
+    topic,
+    ctxDir,
+    result,
+  });
   return result;
 }