@sampleapp.ai/sdk 1.0.29 → 1.0.30

package/dist/components/sandbox/guardian/ui/popover.js

@@ -0,0 +1,25 @@
+"use client";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import * as React from "react";
+import * as PopoverPrimitive from "@radix-ui/react-popover";
+import { cn } from "../../../../lib/utils";
+const Popover = PopoverPrimitive.Root;
+const PopoverTrigger = PopoverPrimitive.Trigger;
+const PopoverAnchor = PopoverPrimitive.Anchor;
+const PopoverContent = React.forwardRef((_a, ref) => {
+    var { className, align = "center", sideOffset = 4 } = _a, props = __rest(_a, ["className", "align", "sideOffset"]);
+    return (React.createElement(PopoverPrimitive.Portal, null,
+        React.createElement(PopoverPrimitive.Content, Object.assign({ ref: ref, align: align, sideOffset: sideOffset, className: cn("z-50 w-72 rounded-md border bg-popover p-4 text-popover-foreground shadow-md outline-none data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2", className) }, props))));
+});
+PopoverContent.displayName = PopoverPrimitive.Content.displayName;
+export { Popover, PopoverTrigger, PopoverContent, PopoverAnchor };

package/dist/components/sandbox/guardian/ui/tooltip.js

@@ -0,0 +1,25 @@
+"use client";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import * as React from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+import { cn } from "../../../../lib/utils";
+const TooltipProvider = TooltipPrimitive.Provider;
+const Tooltip = TooltipPrimitive.Root;
+const TooltipTrigger = TooltipPrimitive.Trigger;
+const TooltipContent = React.forwardRef((_a, ref) => {
+    var { className, sideOffset = 4 } = _a, props = __rest(_a, ["className", "sideOffset"]);
+    return (React.createElement(TooltipPrimitive.Portal, null,
+        React.createElement(TooltipPrimitive.Content, Object.assign({ ref: ref, sideOffset: sideOffset, className: cn("z-50 overflow-hidden rounded-md bg-primary px-3 py-1.5 text-xs text-primary-foreground animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2", className) }, props))));
+});
+TooltipContent.displayName = TooltipPrimitive.Content.displayName;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/dist/components/sandbox/guardian/utils.js

@@ -0,0 +1,88 @@
+import { FrameworkLabel, } from "./types/ide-types";
+/**
+ * Creates sandbox URL configs for preloading from a framework's urlsToPreload.
+ * Only includes URLs that need VM preloading (useVm: true).
+ * Uses the same sandboxUid for all configs since caching is done by sandboxUid + browserUrl.
+ */
+export function createSandboxUrlConfigs(sandboxUid, urlsToPreload) {
+    if (!urlsToPreload) {
+        return [];
+    }
+    return urlsToPreload
+        .filter((config) => config.useVm)
+        .map((config) => ({
+        sandboxUid: config.suffix ? `${sandboxUid}-${config.suffix}` : sandboxUid,
+        browserUrl: config.browserUrl,
+        useVm: config.useVm,
+    }));
+}
+/**
+ * Builds a nested GuardianConfig from use cases with nested frameworks.
+ * Returns a structure where config[useCaseId].frameworks[frameworkKey] gives you the full config.
+ *
+ * @example
+ * const config = buildGuardianConfig(USE_CASES, options);
+ * // Access via: config["full-stack-auth"].frameworks["nextjs"]
+ */
+export function buildGuardianConfig(useCases, options) {
+    var _a;
+    const { playgroundUid, playgroundLogo, frameworkLabels, variant } = options;
+    const result = {};
+    for (const uc of useCases) {
+        // Build the use case config
+        const useCaseConfig = {
+            id: uc.id,
+            name: uc.name,
+            description: uc.description,
+            themeColor: uc.themeColor,
+            hasPreview: uc.hasPreview,
+            frameworks: {},
+        };
+        // Compute frameworkOptions from ALL frameworks in this use case
+        const frameworkOptions = uc.frameworks.map((fw) => {
+            var _a, _b;
+            return ({
+                label: (_b = (_a = (frameworkLabels && frameworkLabels[fw.key])) !== null && _a !== void 0 ? _a : FrameworkLabel[fw.key]) !== null && _b !== void 0 ? _b : fw.key,
+                value: fw.key,
+            });
+        });
+        // Add each framework to the use case
+        for (const fw of uc.frameworks) {
+            useCaseConfig.frameworks[fw.key] = {
+                frameworkKey: fw.key,
+                name: uc.name,
+                description: uc.description,
+                demoOptions: [], // Will be populated below
+                frameworkOptions,
+                firstFrameworkByUseCase: undefined, // Will be passed from guardian-playground
+                currentFramework: fw.key,
+                CustomConsole: fw.CustomConsole,
+                GuideView: fw.GuideView,
+                playgroundUid,
+                playgroundLogo,
+                browserUrl: fw.browserUrl,
+                useVm: fw.useVm,
+                sandboxUid: fw.sandboxUid,
+                codeZipFile: fw.codeZipFile,
+                completeCodeZipFile: fw.completeCodeZipFile,
+                consoleUrlConfigs: createSandboxUrlConfigs(fw.sandboxUid, fw.urlsToPreload),
+                themeColor: (_a = fw.themeColor) !== null && _a !== void 0 ? _a : uc.themeColor,
+                variant,
+                hasPreview: uc.hasPreview,
+            };
+        }
+        result[uc.id] = useCaseConfig;
+    }
+    // Now populate demoOptions for all frameworks (they all get the same list)
+    const demoOptions = useCases.map((uc) => ({
+        label: uc.name,
+        value: uc.id, // Use the use case ID as the value
+    }));
+    // Update all framework configs with the complete demoOptions
+    for (const useCaseConfig of Object.values(result)) {
+        for (const frameworkConfig of Object.values(useCaseConfig.frameworks)) {
+            frameworkConfig.demoOptions = demoOptions;
+        }
+    }
+    return result;
+}

package/dist/components/sandbox/guardian/zip-to-codebase.js

@@ -0,0 +1,259 @@
+import JSZip from "jszip";
+import { filePathToCodeLanguage, } from "./types/ide-types";
+/**
+ * Converts a zip file to UpdateContainerCodebaseType (flat Record structure)
+ * @param zipData - The zip file as Blob, File, ArrayBuffer, or Uint8Array
+ * @returns Promise<UpdateContainerCodebaseType> - A flat record of file paths to CodeOutput
+ */
+export async function zipToCodebase(zipData) {
+    try {
+        const zip = await JSZip.loadAsync(zipData);
+        const codebase = {};
+        // Get all file paths (excluding directories and __MACOSX)
+        const filePaths = Object.keys(zip.files).filter((path) => {
+            const file = zip.files[path];
+            return (!file.dir &&
+                !path.includes("__MACOSX") &&
+                !path.includes("__pycache__") &&
+                !path.includes(".DS_Store") &&
+                !path.startsWith("._") &&
+                !path.includes("/._"));
+        });
+        // Find common root folder prefix
+        let commonPrefix = "";
+        if (filePaths.length > 0) {
+            // Get the first path's root folder
+            const firstPath = filePaths[0];
+            const firstSlashIndex = firstPath.indexOf("/");
+            if (firstSlashIndex > 0) {
+                const potentialPrefix = firstPath.substring(0, firstSlashIndex + 1);
+                // Check if all paths start with this prefix
+                const allHavePrefix = filePaths.every((path) => path.startsWith(potentialPrefix));
+                if (allHavePrefix) {
+                    commonPrefix = potentialPrefix;
+                }
+            }
+        }
+        // Process all files in the zip
+        const filePromises = [];
+        for (const relativePath of filePaths) {
+            const file = zip.files[relativePath];
+            // Get file content as text
+            const contentPromise = file
+                .async("string")
+                .then((content) => {
+                // Strip common prefix from the file path
+                let filePath = relativePath;
+                if (commonPrefix && filePath.startsWith(commonPrefix)) {
+                    filePath = filePath.substring(commonPrefix.length);
+                }
+                const fileName = filePath.split("/").pop() || filePath;
+                const codeLanguage = filePathToCodeLanguage(filePath);
+                codebase[filePath] = {
+                    response_type: "CodeOutput",
+                    file_path: filePath,
+                    code_file_name: fileName,
+                    code_language: codeLanguage,
+                    dependencies_to_install: [],
+                    framework: null,
+                    full_code: content,
+                };
+            })
+                .catch((error) => {
+                // If file can't be read as text, skip it or handle binary files
+                console.warn(`Could not read file ${relativePath} as text:`, error);
+            });
+            filePromises.push(contentPromise);
+        }
+        // Wait for all files to be processed
+        await Promise.all(filePromises);
+        return codebase;
+    }
+    catch (error) {
+        console.error("Error parsing zip file:", error);
+        throw new Error(`Failed to parse zip file: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Converts a zip file to UpdateContainerCodebaseType with binary file support
+ * Binary files will have their content as base64 encoded strings
+ * @param zipData - The zip file as Blob, File, ArrayBuffer, or Uint8Array
+ * @returns Promise<UpdateContainerCodebaseType> - A flat record of file paths to CodeOutput
+ */
+export async function zipToCodebaseWithBinary(zipData) {
+    try {
+        const zip = await JSZip.loadAsync(zipData);
+        const codebase = {};
+        // Get all file paths (excluding directories and __MACOSX)
+        const filePaths = Object.keys(zip.files).filter((path) => {
+            const file = zip.files[path];
+            return (!file.dir &&
+                !path.includes("__MACOSX") &&
+                !path.includes("__pycache__") &&
+                !path.includes(".DS_Store") &&
+                !path.startsWith("._") &&
+                !path.includes("/._"));
+        });
+        // Find common root folder prefix
+        let commonPrefix = "";
+        if (filePaths.length > 0) {
+            // Get the first path's root folder
+            const firstPath = filePaths[0];
+            const firstSlashIndex = firstPath.indexOf("/");
+            if (firstSlashIndex > 0) {
+                const potentialPrefix = firstPath.substring(0, firstSlashIndex + 1);
+                // Check if all paths start with this prefix
+                const allHavePrefix = filePaths.every((path) => path.startsWith(potentialPrefix));
+                if (allHavePrefix) {
+                    commonPrefix = potentialPrefix;
+                }
+            }
+        }
+        // Process all files in the zip
+        const filePromises = [];
+        for (const relativePath of filePaths) {
+            const file = zip.files[relativePath];
+            // Try to read as text first, fallback to base64 for binary files
+            const contentPromise = (async () => {
+                let content;
+                try {
+                    // Try reading as text
+                    content = await file.async("string");
+                }
+                catch (_a) {
+                    // If that fails, read as base64
+                    const binary = await file.async("base64");
+                    content = binary;
+                }
+                // Strip common prefix from the file path
+                let filePath = relativePath;
+                if (commonPrefix && filePath.startsWith(commonPrefix)) {
+                    filePath = filePath.substring(commonPrefix.length);
+                }
+                const fileName = filePath.split("/").pop() || filePath;
+                const codeLanguage = filePathToCodeLanguage(filePath);
+                codebase[filePath] = {
+                    response_type: "CodeOutput",
+                    file_path: filePath,
+                    code_file_name: fileName,
+                    code_language: codeLanguage,
+                    dependencies_to_install: [],
+                    framework: null,
+                    full_code: content,
+                };
+            })();
+            filePromises.push(contentPromise);
+        }
+        // Wait for all files to be processed
+        await Promise.all(filePromises);
+        return codebase;
+    }
+    catch (error) {
+        console.error("Error parsing zip file:", error);
+        throw new Error(`Failed to parse zip file: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Converts codeZipFile (string path or UpdateContainerCodebaseType) to UpdateContainerCodebaseType
+ * @param codeZipFile - Either a string path to a zip file OR an UpdateContainerCodebaseType object
+ * @returns Promise<UpdateContainerCodebaseType> - A flat record of file paths to CodeOutput
+ */
+export async function codeZipFileToCodebase(codeZipFile) {
+    // If it's already an object (generated_code), return it directly
+    if (typeof codeZipFile !== "string") {
+        return codeZipFile;
+    }
+    // Otherwise, treat it as a file path and fetch it
+    return zipPathToCodebase(codeZipFile);
+}
+/**
+ * Reads a zip file from a path and converts it to UpdateContainerCodebaseType
+ * @param filePath - The path to the zip file (e.g., "/public/guardian/launchdarkly-guardian/code-1.zip" or "/guardian/launchdarkly-guardian/code-1.zip")
+ * @returns Promise<UpdateContainerCodebaseType> - A flat record of file paths to CodeOutput
+ */
+export async function zipPathToCodebase(filePath) {
+    try {
+        // Normalize the path - remove /public prefix if present (Next.js serves public folder from root)
+        let normalizedPath = filePath;
+        if (normalizedPath.startsWith("/public/")) {
+            normalizedPath = normalizedPath.slice("/public".length);
+        }
+        // Ensure path starts with /
+        if (!normalizedPath.startsWith("/")) {
+            normalizedPath = "/" + normalizedPath;
+        }
+        // Build the URL - handle both client-side (relative) and server-side (absolute) cases
+        let url;
+        if (typeof window !== "undefined") {
+            // Client-side: use relative URL
+            url = normalizedPath;
+        }
+        else {
+            // Server-side: need absolute URL
+            // Try to get base URL from environment or use a default
+            const baseUrl = process.env.NEXT_PUBLIC_BASE_URL ||
+                process.env.VERCEL_URL ||
+                "http://localhost:3000";
+            url = `${baseUrl}${normalizedPath}`;
+        }
+        // Fetch the file from the public folder
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch zip file from ${url}: ${response.status} ${response.statusText}`);
+        }
+        // Get the file as a blob
+        const blob = await response.blob();
+        // Convert to UpdateContainerCodebaseType using zipToCodebase
+        return await zipToCodebase(blob);
+    }
+    catch (error) {
+        console.error(`Error reading zip file from path ${filePath}:`, error);
+        throw new Error(`Failed to read zip file from path: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Reads a zip file from a path and converts it to UpdateContainerCodebaseType with binary file support
+ * Binary files will have their content as base64 encoded strings
+ * @param filePath - The path to the zip file (e.g., "/public/guardian/launchdarkly-guardian/code-1.zip" or "/guardian/launchdarkly-guardian/code-1.zip")
+ * @returns Promise<UpdateContainerCodebaseType> - A flat record of file paths to CodeOutput
+ */
+export async function zipPathToCodebaseWithBinary(filePath) {
+    try {
+        // Normalize the path - remove /public prefix if present (Next.js serves public folder from root)
+        let normalizedPath = filePath;
+        if (normalizedPath.startsWith("/public/")) {
+            normalizedPath = normalizedPath.slice("/public".length);
+        }
+        // Ensure path starts with /
+        if (!normalizedPath.startsWith("/")) {
+            normalizedPath = "/" + normalizedPath;
+        }
+        // Build the URL - handle both client-side (relative) and server-side (absolute) cases
+        let url;
+        if (typeof window !== "undefined") {
+            // Client-side: use relative URL
+            url = normalizedPath;
+        }
+        else {
+            // Server-side: need absolute URL
+            // Try to get base URL from environment or use a default
+            const baseUrl = process.env.NEXT_PUBLIC_BASE_URL ||
+                process.env.VERCEL_URL ||
+                "http://localhost:3000";
+            url = `${baseUrl}${normalizedPath}`;
+        }
+        // Fetch the file from the public folder
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch zip file from ${url}: ${response.status} ${response.statusText}`);
+        }
+        // Get the file as a blob
+        const blob = await response.blob();
+        // Convert to UpdateContainerCodebaseType using zipToCodebaseWithBinary
+        return await zipToCodebaseWithBinary(blob);
+    }
+    catch (error) {
+        console.error(`Error reading zip file from path ${filePath}:`, error);
+        throw new Error(`Failed to read zip file from path: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/components/sandbox/guardian/zip-to-filetree.js

@@ -0,0 +1,284 @@
+import JSZip from "jszip";
+import { CodeLanguage, filePathToCodeLanguage, } from "./types/ide-types";
+/**
+ * Converts a zip file to a FileTreeNode structure
+ * @param zipData - The zip file as Blob, File, ArrayBuffer, or Uint8Array
+ * @returns Promise<FileTreeNode> - The root node of the file tree
+ */
+export async function zipToFileTree(zipData) {
+    try {
+        const zip = await JSZip.loadAsync(zipData);
+        // Create root node
+        const root = {
+            name: "root",
+            children: {},
+            type: "folder",
+            metadata: {
+                response_type: "CodeOutput",
+                file_path: "",
+                code_file_name: "",
+                code_language: CodeLanguage.TEXT,
+                dependencies_to_install: [],
+                framework: null,
+                full_code: "",
+            },
+        };
+        // Process all files in the zip
+        const filePromises = [];
+        for (const relativePath in zip.files) {
+            const file = zip.files[relativePath];
+            // Skip directories (they're handled by the path structure)
+            if (file.dir) {
+                continue;
+            }
+            // Get file content as text
+            const contentPromise = file
+                .async("string")
+                .then((content) => {
+                // Build the tree structure from the path
+                const pathParts = relativePath.split("/").filter(Boolean);
+                let currentNode = root;
+                // Navigate/create folder structure
+                for (let i = 0; i < pathParts.length - 1; i++) {
+                    const part = pathParts[i];
+                    if (!currentNode.children[part]) {
+                        currentNode.children[part] = {
+                            name: part,
+                            children: {},
+                            type: "folder",
+                            metadata: {
+                                response_type: "CodeOutput",
+                                file_path: pathParts.slice(0, i + 1).join("/"),
+                                code_file_name: part,
+                                code_language: CodeLanguage.TEXT,
+                                dependencies_to_install: [],
+                                framework: null,
+                                full_code: "",
+                            },
+                        };
+                    }
+                    currentNode = currentNode.children[part];
+                }
+                // Add the file
+                const fileName = pathParts[pathParts.length - 1];
+                const filePath = relativePath;
+                const codeLanguage = filePathToCodeLanguage(filePath);
+                currentNode.children[fileName] = {
+                    name: fileName,
+                    children: {},
+                    type: "file",
+                    metadata: {
+                        response_type: "CodeOutput",
+                        file_path: filePath,
+                        code_file_name: fileName,
+                        code_language: codeLanguage,
+                        dependencies_to_install: [],
+                        framework: null,
+                        full_code: content,
+                    },
+                };
+            })
+                .catch((error) => {
+                // If file can't be read as text, skip it or handle binary files
+                console.warn(`Could not read file ${relativePath} as text:`, error);
+            });
+            filePromises.push(contentPromise);
+        }
+        // Wait for all files to be processed
+        await Promise.all(filePromises);
+        return root;
+    }
+    catch (error) {
+        console.error("Error parsing zip file:", error);
+        throw new Error(`Failed to parse zip file: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Reads a zip file from a path and converts it to a FileTreeNode structure
+ * @param filePath - The path to the zip file (e.g., "/public/code/guardian/launchdarkly-guardian/code-1.zip" or "/code/guardian/launchdarkly-guardian/code-1.zip")
+ * @returns Promise<FileTreeNode> - The root node of the file tree
+ */
+export async function zipPathToFileTree(filePath) {
+    try {
+        // Normalize the path - remove /public prefix if present (Next.js serves public folder from root)
+        let normalizedPath = filePath;
+        if (normalizedPath.startsWith("/public/")) {
+            normalizedPath = normalizedPath.slice("/public".length);
+        }
+        // Ensure path starts with /
+        if (!normalizedPath.startsWith("/")) {
+            normalizedPath = "/" + normalizedPath;
+        }
+        // Build the URL - handle both client-side (relative) and server-side (absolute) cases
+        let url;
+        if (typeof window !== "undefined") {
+            // Client-side: use relative URL
+            url = normalizedPath;
+        }
+        else {
+            // Server-side: need absolute URL
+            // Try to get base URL from environment or use a default
+            const baseUrl = process.env.NEXT_PUBLIC_BASE_URL ||
+                process.env.VERCEL_URL ||
+                "http://localhost:3000";
+            url = `${baseUrl}${normalizedPath}`;
+        }
+        // Fetch the file from the public folder
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch zip file from ${url}: ${response.status} ${response.statusText}`);
+        }
+        // Get the file as a blob
+        const blob = await response.blob();
+        // Convert to FileTreeNode using zipToFileTree
+        return await zipToFileTree(blob);
+    }
+    catch (error) {
+        console.error(`Error reading zip file from path ${filePath}:`, error);
+        throw new Error(`Failed to read zip file from path: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Reads a zip file from a path and converts it to a FileTreeNode structure with binary file support
+ * Binary files will have their content as base64 encoded strings
+ * @param filePath - The path to the zip file (e.g., "/public/code/guardian/launchdarkly-guardian/code-1.zip" or "/code/guardian/launchdarkly-guardian/code-1.zip")
+ * @returns Promise<FileTreeNode> - The root node of the file tree
+ */
+export async function zipPathToFileTreeWithBinary(filePath) {
+    try {
+        // Normalize the path - remove /public prefix if present (Next.js serves public folder from root)
+        let normalizedPath = filePath;
+        if (normalizedPath.startsWith("/public/")) {
+            normalizedPath = normalizedPath.slice("/public".length);
+        }
+        // Ensure path starts with /
+        if (!normalizedPath.startsWith("/")) {
+            normalizedPath = "/" + normalizedPath;
+        }
+        // Build the URL - handle both client-side (relative) and server-side (absolute) cases
+        let url;
+        if (typeof window !== "undefined") {
+            // Client-side: use relative URL
+            url = normalizedPath;
+        }
+        else {
+            // Server-side: need absolute URL
+            // Try to get base URL from environment or use a default
+            const baseUrl = process.env.NEXT_PUBLIC_BASE_URL ||
+                process.env.VERCEL_URL ||
+                "http://localhost:3000";
+            url = `${baseUrl}${normalizedPath}`;
+        }
+        // Fetch the file from the public folder
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch zip file from ${url}: ${response.status} ${response.statusText}`);
+        }
+        // Get the file as a blob
+        const blob = await response.blob();
+        // Convert to FileTreeNode using zipToFileTreeWithBinary
+        return await zipToFileTreeWithBinary(blob);
+    }
+    catch (error) {
+        console.error(`Error reading zip file from path ${filePath}:`, error);
+        throw new Error(`Failed to read zip file from path: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Converts a zip file to a FileTreeNode structure with binary file support
+ * Binary files will have their content as base64 encoded strings
+ * @param zipData - The zip file as Blob, File, ArrayBuffer, or Uint8Array
+ * @returns Promise<FileTreeNode> - The root node of the file tree
+ */
+export async function zipToFileTreeWithBinary(zipData) {
+    try {
+        const zip = await JSZip.loadAsync(zipData);
+        // Create root node
+        const root = {
+            name: "root",
+            children: {},
+            type: "folder",
+            metadata: {
+                response_type: "CodeOutput",
+                file_path: "",
+                code_file_name: "",
+                code_language: CodeLanguage.TEXT,
+                dependencies_to_install: [],
+                framework: null,
+                full_code: "",
+            },
+        };
+        // Process all files in the zip
+        const filePromises = [];
+        for (const relativePath in zip.files) {
+            const file = zip.files[relativePath];
+            // Skip directories (they're handled by the path structure)
+            if (file.dir) {
+                continue;
+            }
+            // Try to read as text first, fallback to base64 for binary files
+            const contentPromise = (async () => {
+                let content;
+                try {
+                    // Try reading as text
+                    content = await file.async("string");
+                }
+                catch (_a) {
+                    // If that fails, read as base64
+                    const binary = await file.async("base64");
+                    content = binary;
+                }
+                // Build the tree structure from the path
+                const pathParts = relativePath.split("/").filter(Boolean);
+                let currentNode = root;
+                // Navigate/create folder structure
+                for (let i = 0; i < pathParts.length - 1; i++) {
+                    const part = pathParts[i];
+                    if (!currentNode.children[part]) {
+                        currentNode.children[part] = {
+                            name: part,
+                            children: {},
+                            type: "folder",
+                            metadata: {
+                                response_type: "CodeOutput",
+                                file_path: pathParts.slice(0, i + 1).join("/"),
+                                code_file_name: part,
+                                code_language: CodeLanguage.TEXT,
+                                dependencies_to_install: [],
+                                framework: null,
+                                full_code: "",
+                            },
+                        };
+                    }
+                    currentNode = currentNode.children[part];
+                }
+                // Add the file
+                const fileName = pathParts[pathParts.length - 1];
+                const filePath = relativePath;
+                const codeLanguage = filePathToCodeLanguage(filePath);
+                currentNode.children[fileName] = {
+                    name: fileName,
+                    children: {},
+                    type: "file",
+                    metadata: {
+                        response_type: "CodeOutput",
+                        file_path: filePath,
+                        code_file_name: fileName,
+                        code_language: codeLanguage,
+                        dependencies_to_install: [],
+                        framework: null,
+                        full_code: content,
+                    },
+                };
+            })();
+            filePromises.push(contentPromise);
+        }
+        // Wait for all files to be processed
+        await Promise.all(filePromises);
+        return root;
+    }
+    catch (error) {
+        console.error("Error parsing zip file:", error);
+        throw new Error(`Failed to parse zip file: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}