Merge branch 'main' into group-dls-part-2

Author: phact

frontend/components/cloud-picker/file-item.tsx

@@ -31,10 +31,24 @@ const getMimeTypeLabel = (mimeType: string) => {
     "application/vnd.google-apps.folder": "Folder",
     "application/pdf": "PDF",
     "text/plain": "Text",
+    "text/csv": "CSV",
+    "text/html": "HTML",
+    "application/xml": "XML",
+    "application/json": "JSON",
+    "application/msword": "Word Doc",
+    "application/vnd.ms-excel": "Excel",
+    "application/vnd.ms-powerpoint": "PowerPoint",
     "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
       "Word Doc",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":
+      "Excel",
     "application/vnd.openxmlformats-officedocument.presentationml.presentation":
       "PowerPoint",
+    "application/octet-stream": "File",
+    "image/jpeg": "JPEG",
+    "image/png": "PNG",
+    "image/gif": "GIF",
+    "image/svg+xml": "SVG",
   };
 
   return typeMap[mimeType] || mimeType?.split("/").pop() || "Document";

frontend/components/cloud-picker/provider-handlers.ts

@@ -159,17 +159,20 @@ export class OneDriveHandler {
   private clientId: string;
   private provider: CloudProvider;
   private baseUrl?: string;
+  private onPickerStateChange?: (isOpen: boolean) => void;
 
   constructor(
     accessToken: string,
     clientId: string,
     provider: CloudProvider = "onedrive",
     baseUrl?: string,
+    onPickerStateChange?: (isOpen: boolean) => void,
   ) {
     this.accessToken = accessToken;
     this.clientId = clientId;
     this.provider = provider;
     this.baseUrl = baseUrl;
+    this.onPickerStateChange = onPickerStateChange;
   }
 
   async loadPickerApi(): Promise<boolean> {
@@ -206,57 +209,111 @@ export class OneDriveHandler {
         console.log("OneDrive picker success callback:", response);
         if (!response || !response.value) {
           console.warn("OneDrive picker returned no value");
+          this.onPickerStateChange?.(false);
           return;
         }
 
-        const newFiles: CloudFile[] =
-          response.value?.map((item: any) => {
-            // Extract mimeType from file object or infer from name
-            let mimeType = item.file?.mimeType;
-            if (!mimeType && item.name) {
-              // Infer from extension if mimeType not provided
-              const ext = item.name.split(".").pop()?.toLowerCase();
-              const mimeTypes: { [key: string]: string } = {
-                pdf: "application/pdf",
-                doc: "application/msword",
-                docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-                xls: "application/vnd.ms-excel",
-                xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-                ppt: "application/vnd.ms-powerpoint",
-                pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-                txt: "text/plain",
-                csv: "text/csv",
-                json: "application/json",
-                xml: "application/xml",
-                html: "text/html",
-                jpg: "image/jpeg",
-                jpeg: "image/jpeg",
-                png: "image/png",
-                gif: "image/gif",
-                svg: "image/svg+xml",
-              };
-              mimeType = mimeTypes[ext || ""] || "application/octet-stream";
-            }
+        // v7.2 action:"query" returns stubs with only id/endpoint/parentReference.
+        // Enrich each item by fetching full metadata from the Graph API.
+        const enrichItems = async () => {
+          const enriched = await Promise.all(
+            response.value.map(async (item: any) => {
+              const driveId =
+                item.parentReference?.driveId || item.id?.split("!")[0];
+              const itemId = item.id;
 
-            return {
-              id: item.id,
-              name: item.name || `${this.getProviderName()} File`,
-              mimeType: mimeType || "application/octet-stream",
-              webUrl: item.webUrl || "",
-              downloadUrl: item["@microsoft.graph.downloadUrl"] || "",
-              size: item.size,
-              modifiedTime: item.lastModifiedDateTime,
-              isFolder: !!item.folder,
-            };
-          }) || [];
+              if (driveId && itemId) {
+                try {
+                  const url = `https://graph.microsoft.com/v1.0/drives/${driveId}/items/${itemId}`;
+                  const res = await fetch(url, {
+                    headers: { Authorization: `Bearer ${this.accessToken}` },
+                  });
+                  if (res.ok) {
+                    const meta = await res.json();
+                    console.log(
+                      "OneDrive enriched metadata:",
+                      meta.name,
+                      meta.file?.mimeType,
+                    );
+
+                    let mimeType = meta.file?.mimeType;
+                    if (!mimeType && meta.name) {
+                      const ext = meta.name.split(".").pop()?.toLowerCase();
+                      const mimeTypes: { [key: string]: string } = {
+                        pdf: "application/pdf",
+                        doc: "application/msword",
+                        docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+                        xls: "application/vnd.ms-excel",
+                        xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                        ppt: "application/vnd.ms-powerpoint",
+                        pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+                        txt: "text/plain",
+                        csv: "text/csv",
+                        json: "application/json",
+                        xml: "application/xml",
+                        html: "text/html",
+                        jpg: "image/jpeg",
+                        jpeg: "image/jpeg",
+                        png: "image/png",
+                        gif: "image/gif",
+                        svg: "image/svg+xml",
+                      };
+                      mimeType =
+                        mimeTypes[ext || ""] || "application/octet-stream";
+                    }
 
-        onFileSelected(newFiles);
+                    return {
+                      id: meta.id,
+                      name: meta.name || `${this.getProviderName()} File`,
+                      mimeType: mimeType || "application/octet-stream",
+                      webUrl: meta.webUrl || "",
+                      downloadUrl: meta["@microsoft.graph.downloadUrl"] || "",
+                      size: meta.size,
+                      modifiedTime: meta.lastModifiedDateTime,
+                      isFolder: !!meta.folder,
+                    } as CloudFile;
+                  } else {
+                    console.warn(
+                      "Graph API metadata fetch failed:",
+                      res.status,
+                      await res.text(),
+                    );
+                  }
+                } catch (e) {
+                  console.warn("Graph API metadata fetch error:", e);
+                }
+              }
+
+              // Fallback: use stub data if Graph call fails
+              return {
+                id: item.id,
+                name: item.name || `${this.getProviderName()} File`,
+                mimeType: "application/octet-stream",
+                webUrl: item.webUrl || "",
+                downloadUrl: item["@microsoft.graph.downloadUrl"] || "",
+                size: item.size,
+                modifiedTime: item.lastModifiedDateTime,
+                isFolder: !!item.folder,
+              } as CloudFile;
+            }),
+          );
+
+          onFileSelected(enriched);
+          this.onPickerStateChange?.(false);
+        };
+
+        enrichItems().catch((e) => {
+          console.error("Failed to enrich OneDrive items:", e);
+          this.onPickerStateChange?.(false);
+        });
       },
       cancel: () => {
         console.log("Picker cancelled");
+        this.onPickerStateChange?.(false);
       },
       error: (error: any) => {
         console.error("Picker error callback:", error);
+        this.onPickerStateChange?.(false);
       },
     });
   }
@@ -310,7 +367,13 @@ export const createProviderHandler = (
       if (!clientId) {
         throw new Error("Client ID required for OneDrive");
       }
-      return new OneDriveHandler(accessToken, clientId, provider, baseUrl);
+      return new OneDriveHandler(
+        accessToken,
+        clientId,
+        provider,
+        baseUrl,
+        onPickerStateChange,
+      );
     default:
       throw new Error(`Unsupported provider: ${provider}`);
   }

src/connectors/onedrive/connector.py

@@ -737,7 +737,7 @@ async def _fetch_item_metadata(self, file_id: str) -> dict[str, Any] | None:
                 # Try: /drives/{driveId}/items/{itemId} with full item ID (including 's' prefix)
                 logger.info(f"Trying drives endpoint: /drives/{drive_id}/items/{item_id}")
                 try:
-                    url = f"{self._graph_base_url}/drives/{drive_id}/items/{item_id}"
+                    url = f"{self._graph_base_url}/drives/{drive_id}/items/{file_id}"
                     response = await self._make_graph_request(url, params=params)
                     if response.status_code == 200:
                         return response.json()
@@ -755,7 +755,7 @@ async def _fetch_item_metadata(self, file_id: str) -> dict[str, Any] | None:
                         f"Trying drives endpoint without 's' prefix: /drives/{drive_id}/items/{clean_item_id}"
                     )
                     try:
-                        url = f"{self._graph_base_url}/drives/{drive_id}/items/{clean_item_id}"
+                        url = f"{self._graph_base_url}/drives/{drive_id}/items/{clean_file_id}"
                         response = await self._make_graph_request(url, params=params)
                         if response.status_code == 200:
                             return response.json()
@@ -811,8 +811,8 @@ async def _download_file_content(self, file_id: str) -> bytes:
                         if content is not None:
                             return content
 
-                    # Try drives endpoint for driveId!itemId format (including the 's' prefix)
-                    url = f"{self._graph_base_url}/drives/{drive_id}/items/{item_id}/content"
+                    # Try drives endpoint for driveId!itemId format
+                    url = f"{self._graph_base_url}/drives/{drive_id}/items/{file_id}/content"
                     logger.info(f"Downloading via drives endpoint: {url}")
                 else:
                     url = f"{self._graph_base_url}/me/drive/items/{file_id}/content"