cowork-dash 0.1.8__py3-none-any.whl → 0.1.9__py3-none-any.whl

cowork_dash/app.py

@@ -17,7 +17,15 @@ from typing import Optional, Dict, Any, List
 from dotenv import load_dotenv
 load_dotenv()
 
-from dash import Dash, html, Input, Output, State, callback_context, no_update, ALL
+# Early pandas import to prevent circular import issues with Plotly's JSON serializer.
+# Plotly lazily imports pandas and checks `obj is pd.NaT` which fails if pandas
+# is partially initialized due to concurrent imports.
+try:
+    import pandas
+except (ImportError, AttributeError):
+    pass
+
+from dash import Dash, html, dcc, Input, Output, State, callback_context, no_update, ALL
 from dash.exceptions import PreventUpdate
 import dash_mantine_components as dmc
 from dash_iconify import DashIconify
@@ -1493,7 +1501,8 @@ def handle_interrupt_response(approve_clicks, reject_clicks, edit_clicks, input_
 @app.callback(
     [Output({"type": "folder-children", "path": ALL}, "style"),
      Output({"type": "folder-icon", "path": ALL}, "style"),
-     Output({"type": "folder-children", "path": ALL}, "children")],
+     Output({"type": "folder-children", "path": ALL}, "children"),
+     Output("expanded-folders", "data")],
     Input({"type": "folder-icon", "path": ALL}, "n_clicks"),
     [State({"type": "folder-header", "path": ALL}, "id"),
      State({"type": "folder-header", "path": ALL}, "data-realpath"),
@@ -1503,16 +1512,18 @@ def handle_interrupt_response(approve_clicks, reject_clicks, edit_clicks, input_
      State({"type": "folder-icon", "path": ALL}, "style"),
      State({"type": "folder-children", "path": ALL}, "children"),
      State("theme-store", "data"),
-     State("session-id", "data")],
+     State("session-id", "data"),
+     State("expanded-folders", "data")],
     prevent_initial_call=True
 )
-def toggle_folder(n_clicks, header_ids, real_paths, children_ids, icon_ids, children_styles, icon_styles, children_content, theme, session_id):
+def toggle_folder(n_clicks, header_ids, real_paths, children_ids, icon_ids, children_styles, icon_styles, children_content, theme, session_id, expanded_folders):
     """Toggle folder expansion and lazy load contents if needed."""
     ctx = callback_context
     if not ctx.triggered or not any(n_clicks):
         raise PreventUpdate
 
     colors = get_colors(theme or "light")
+    expanded_folders = expanded_folders or []
 
     # Get workspace for this session (virtual or physical)
     workspace_root = get_workspace_for_session(session_id)
@@ -1538,6 +1549,9 @@ def toggle_folder(n_clicks, header_ids, real_paths, children_ids, icon_ids, chil
     new_icon_styles = []
     new_children_content = []
 
+    # Track whether we're expanding or collapsing the clicked folder
+    will_expand = None
+
     # Process all folder-children elements
     for i, child_id in enumerate(children_ids):
         path = child_id["path"]
@@ -1547,6 +1561,7 @@ def toggle_folder(n_clicks, header_ids, real_paths, children_ids, icon_ids, chil
         if path == clicked_path:
             # Toggle this folder
             is_expanded = current_style.get("display") != "none"
+            will_expand = not is_expanded
             new_children_styles.append({"display": "none" if is_expanded else "block"})
 
             # If expanding and content is just "Loading...", load the actual contents
@@ -1560,7 +1575,8 @@ def toggle_folder(n_clicks, header_ids, real_paths, children_ids, icon_ids, chil
                         folder_items = load_folder_contents(folder_rel_path, workspace_root)
                         loaded_content = render_file_tree(folder_items, colors, STYLES,
                                                           level=folder_rel_path.count("/") + folder_rel_path.count("\\") + 1,
-                                                          parent_path=folder_rel_path)
+                                                          parent_path=folder_rel_path,
+                                                          expanded_folders=expanded_folders)
                         new_children_content.append(loaded_content if loaded_content else current_content)
                     except Exception as e:
                         print(f"Error loading folder {folder_rel_path}: {e}")
@@ -1597,14 +1613,23 @@ def toggle_folder(n_clicks, header_ids, real_paths, children_ids, icon_ids, chil
         else:
             new_icon_styles.append(current_icon_style)
 
-    return new_children_styles, new_icon_styles, new_children_content
+    # Update expanded folders list
+    new_expanded_folders = list(expanded_folders)
+    if will_expand is not None:
+        if will_expand and clicked_path not in new_expanded_folders:
+            new_expanded_folders.append(clicked_path)
+        elif not will_expand and clicked_path in new_expanded_folders:
+            new_expanded_folders.remove(clicked_path)
+
+    return new_children_styles, new_icon_styles, new_children_content, new_expanded_folders
 
 
 # Enter folder callback - triggered by double-clicking folder name (changes workspace root)
 @app.callback(
     [Output("current-workspace-path", "data"),
      Output("workspace-breadcrumb", "children"),
-     Output("file-tree", "children", allow_duplicate=True)],
+     Output("file-tree", "children", allow_duplicate=True),
+     Output("expanded-folders", "data", allow_duplicate=True)],
     [Input({"type": "folder-select", "path": ALL}, "n_clicks"),
      Input("breadcrumb-root", "n_clicks"),
      Input({"type": "breadcrumb-segment", "index": ALL}, "n_clicks")],
@@ -1720,13 +1745,13 @@ def enter_folder(folder_clicks, root_clicks, breadcrumb_clicks, folder_ids, fold
     else:
         workspace_full_path = workspace_root / new_path if new_path else workspace_root
 
-    # Render new file tree
+    # Render new file tree (reset expanded folders when navigating)
     file_tree = render_file_tree(
         build_file_tree(workspace_full_path, workspace_full_path),
         colors, STYLES
     )
 
-    return new_path, breadcrumb_children, file_tree
+    return new_path, breadcrumb_children, file_tree, []  # Reset expanded folders
 
 
 # File click - open modal
@@ -1805,23 +1830,207 @@ def open_file_modal(all_n_clicks, all_ids, click_tracker, theme, session_id):
     colors = get_colors(theme or "light")
     content, is_text, error = read_file_content(workspace_root, file_path)
     filename = Path(file_path).name
-
-    if is_text and content:
-        modal_content = html.Pre(
-            content,
-            style={
-                "background": colors["bg_tertiary"],
-                "padding": "16px",
-                "fontSize": "12px",
-                "fontFamily": "'IBM Plex Mono', monospace",
-                "overflow": "auto",
-                "maxHeight": "60vh",
-                "whiteSpace": "pre-wrap",
-                "wordBreak": "break-word",
-                "margin": "0",
-                "color": colors["text_primary"],
-            }
-        )
+    file_ext = Path(file_path).suffix.lower()
+
+    # Define file type categories for binary previews
+    image_exts = {'.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', '.ico', '.bmp'}
+    pdf_exts = {'.pdf'}
+
+    # Check for binary preview types first
+    if file_ext in image_exts | pdf_exts:
+        b64, _, mime = get_file_download_data(workspace_root, file_path)
+        if b64:
+            data_url = f"data:{mime};base64,{b64}"
+
+            if file_ext in image_exts:
+                # Image preview
+                modal_content = html.Div([
+                    html.Img(
+                        src=data_url,
+                        style={
+                            "maxWidth": "100%",
+                            "maxHeight": "80vh",
+                            "display": "block",
+                            "margin": "0 auto",
+                            "borderRadius": "4px",
+                        }
+                    )
+                ], style={"textAlign": "center"})
+
+            elif file_ext in pdf_exts:
+                # PDF preview via embed
+                modal_content = html.Embed(
+                    src=data_url,
+                    type="application/pdf",
+                    style={
+                        "width": "100%",
+                        "height": "80vh",
+                        "borderRadius": "4px",
+                    }
+                )
+        else:
+            # Failed to read binary file
+            modal_content = html.Div([
+                html.P("Failed to load file preview", style={
+                    "color": colors["text_muted"],
+                    "textAlign": "center",
+                    "padding": "40px",
+                }),
+                html.P("Click Download to save the file.", style={
+                    "color": colors["text_muted"],
+                    "textAlign": "center",
+                    "fontSize": "13px",
+                })
+            ])
+
+    elif is_text and content:
+        # HTML files get rendered preview
+        if file_ext in ('.html', '.htm'):
+            modal_content = html.Div([
+                # Tab buttons for switching views
+                html.Div([
+                    html.Button("Preview", id="html-preview-tab", n_clicks=0,
+                        className="html-tab-btn html-tab-active",
+                        style={"marginRight": "8px", "padding": "6px 12px", "border": "none",
+                               "borderRadius": "4px", "cursor": "pointer",
+                               "background": colors["accent"], "color": "#fff"}),
+                    html.Button("Source", id="html-source-tab", n_clicks=0,
+                        className="html-tab-btn",
+                        style={"padding": "6px 12px", "border": f"1px solid {colors['border']}",
+                               "borderRadius": "4px", "cursor": "pointer",
+                               "background": "transparent", "color": colors["text_primary"]}),
+                ], style={"marginBottom": "12px", "display": "flex"}),
+                # Preview iframe (default visible)
+                html.Iframe(
+                    srcDoc=content,
+                    style={
+                        "width": "100%",
+                        "height": "80vh",
+                        "border": f"1px solid {colors['border']}",
+                        "borderRadius": "4px",
+                        "background": "#fff",
+                    },
+                    id="html-preview-frame"
+                ),
+                # Source code (hidden by default)
+                html.Pre(
+                    content,
+                    id="html-source-code",
+                    style={
+                        "display": "none",
+                        "background": colors["bg_tertiary"],
+                        "padding": "16px",
+                        "fontSize": "12px",
+                        "fontFamily": "'IBM Plex Mono', monospace",
+                        "overflow": "auto",
+                        "maxHeight": "80vh",
+                        "whiteSpace": "pre-wrap",
+                        "wordBreak": "break-word",
+                        "margin": "0",
+                        "color": colors["text_primary"],
+                        "border": f"1px solid {colors['border']}",
+                        "borderRadius": "4px",
+                    }
+                )
+            ])
+        elif file_ext == '.json':
+            # Try to parse as Plotly JSON figure
+            plotly_figure = None
+            try:
+                data = json.loads(content)
+                # Check if it looks like a Plotly figure (has 'data' key with list)
+                if isinstance(data, dict) and 'data' in data and isinstance(data['data'], list):
+                    plotly_figure = data
+            except (json.JSONDecodeError, KeyError):
+                pass
+
+            if plotly_figure:
+                # Render as interactive Plotly chart with source toggle
+                modal_content = html.Div([
+                    # Tab buttons for switching views
+                    html.Div([
+                        html.Button("Chart", id="html-preview-tab", n_clicks=0,
+                            className="html-tab-btn html-tab-active",
+                            style={"marginRight": "8px", "padding": "6px 12px", "border": "none",
+                                   "borderRadius": "4px", "cursor": "pointer",
+                                   "background": colors["accent"], "color": "#fff"}),
+                        html.Button("JSON", id="html-source-tab", n_clicks=0,
+                            className="html-tab-btn",
+                            style={"padding": "6px 12px", "border": f"1px solid {colors['border']}",
+                                   "borderRadius": "4px", "cursor": "pointer",
+                                   "background": "transparent", "color": colors["text_primary"]}),
+                    ], style={"marginBottom": "12px", "display": "flex"}),
+                    # Plotly chart (default visible)
+                    html.Div([
+                        dcc.Graph(
+                            figure=plotly_figure,
+                            style={"height": "75vh"},
+                            config={"displayModeBar": True, "responsive": True}
+                        )
+                    ], id="html-preview-frame", style={
+                        "border": f"1px solid {colors['border']}",
+                        "borderRadius": "4px",
+                        "background": "#fff",
+                    }),
+                    # JSON source (hidden by default)
+                    html.Pre(
+                        json.dumps(plotly_figure, indent=2),
+                        id="html-source-code",
+                        style={
+                            "display": "none",
+                            "background": colors["bg_tertiary"],
+                            "padding": "16px",
+                            "fontSize": "12px",
+                            "fontFamily": "'IBM Plex Mono', monospace",
+                            "overflow": "auto",
+                            "maxHeight": "80vh",
+                            "whiteSpace": "pre-wrap",
+                            "wordBreak": "break-word",
+                            "margin": "0",
+                            "color": colors["text_primary"],
+                            "border": f"1px solid {colors['border']}",
+                            "borderRadius": "4px",
+                        }
+                    )
+                ])
+            else:
+                # Regular JSON - show formatted
+                try:
+                    formatted = json.dumps(json.loads(content), indent=2)
+                except json.JSONDecodeError:
+                    formatted = content
+                modal_content = html.Pre(
+                    formatted,
+                    style={
+                        "background": colors["bg_tertiary"],
+                        "padding": "16px",
+                        "fontSize": "12px",
+                        "fontFamily": "'IBM Plex Mono', monospace",
+                        "overflow": "auto",
+                        "maxHeight": "80vh",
+                        "whiteSpace": "pre-wrap",
+                        "wordBreak": "break-word",
+                        "margin": "0",
+                        "color": colors["text_primary"],
+                    }
+                )
+        else:
+            # Regular text files
+            modal_content = html.Pre(
+                content,
+                style={
+                    "background": colors["bg_tertiary"],
+                    "padding": "16px",
+                    "fontSize": "12px",
+                    "fontFamily": "'IBM Plex Mono', monospace",
+                    "overflow": "auto",
+                    "maxHeight": "80vh",
+                    "whiteSpace": "pre-wrap",
+                    "wordBreak": "break-word",
+                    "margin": "0",
+                    "color": colors["text_primary"],
+                }
+            )
     else:
         modal_content = html.Div([
             html.P(error or "Cannot display file", style={
@@ -1870,6 +2079,71 @@ def download_from_modal(n_clicks, file_path, session_id):
     return dict(content=b64, filename=filename, base64=True, type=mime)
 
 
+# HTML preview/source tab switching
+@app.callback(
+    [Output("html-preview-frame", "style"),
+     Output("html-source-code", "style"),
+     Output("html-preview-tab", "style"),
+     Output("html-source-tab", "style")],
+    [Input("html-preview-tab", "n_clicks"),
+     Input("html-source-tab", "n_clicks")],
+    [State("theme-store", "data")],
+    prevent_initial_call=True
+)
+def toggle_html_view(preview_clicks, source_clicks, theme):
+    """Toggle between HTML preview and source code view."""
+    ctx = callback_context
+    if not ctx.triggered:
+        raise PreventUpdate
+
+    colors = get_colors(theme or "light")
+    triggered_id = ctx.triggered[0]["prop_id"].split(".")[0]
+
+    # Base styles
+    preview_frame_style = {
+        "width": "100%",
+        "height": "80vh",
+        "border": f"1px solid {colors['border']}",
+        "borderRadius": "4px",
+        "background": "#fff",
+    }
+    source_code_style = {
+        "background": colors["bg_tertiary"],
+        "padding": "16px",
+        "fontSize": "12px",
+        "fontFamily": "'IBM Plex Mono', monospace",
+        "overflow": "auto",
+        "maxHeight": "80vh",
+        "whiteSpace": "pre-wrap",
+        "wordBreak": "break-word",
+        "margin": "0",
+        "color": colors["text_primary"],
+        "border": f"1px solid {colors['border']}",
+        "borderRadius": "4px",
+    }
+    active_btn_style = {
+        "marginRight": "8px", "padding": "6px 12px", "border": "none",
+        "borderRadius": "4px", "cursor": "pointer",
+        "background": colors["accent"], "color": "#fff"
+    }
+    inactive_btn_style = {
+        "padding": "6px 12px", "border": f"1px solid {colors['border']}",
+        "borderRadius": "4px", "cursor": "pointer",
+        "background": "transparent", "color": colors["text_primary"]
+    }
+
+    if triggered_id == "html-source-tab":
+        # Show source, hide preview
+        preview_frame_style["display"] = "none"
+        source_code_style["display"] = "block"
+        return preview_frame_style, source_code_style, {**inactive_btn_style, "marginRight": "8px"}, active_btn_style
+    else:
+        # Show preview, hide source (default)
+        preview_frame_style["display"] = "block"
+        source_code_style["display"] = "none"
+        return preview_frame_style, source_code_style, active_btn_style, {**inactive_btn_style}
+
+
 # Open terminal
 @app.callback(
     Output("open-terminal-btn", "n_clicks"),
@@ -1922,13 +2196,15 @@ def open_terminal(n_clicks):
     [State("current-workspace-path", "data"),
      State("theme-store", "data"),
      State("collapsed-canvas-items", "data"),
-     State("session-id", "data")],
+     State("session-id", "data"),
+     State("expanded-folders", "data")],
     prevent_initial_call=True
 )
-def refresh_sidebar(n_clicks, current_workspace, theme, collapsed_ids, session_id):
+def refresh_sidebar(n_clicks, current_workspace, theme, collapsed_ids, session_id, expanded_folders):
     """Refresh both file tree and canvas content."""
     colors = get_colors(theme or "light")
     collapsed_ids = collapsed_ids or []
+    expanded_folders = expanded_folders or []
 
     # Get workspace for this session (virtual or physical)
     workspace_root = get_workspace_for_session(session_id)
@@ -1939,8 +2215,8 @@ def refresh_sidebar(n_clicks, current_workspace, theme, collapsed_ids, session_i
     else:
         current_workspace_dir = workspace_root / current_workspace if current_workspace else workspace_root
 
-    # Refresh file tree for current workspace
-    file_tree = render_file_tree(build_file_tree(current_workspace_dir, current_workspace_dir), colors, STYLES)
+    # Refresh file tree for current workspace, preserving expanded folders
+    file_tree = render_file_tree(build_file_tree(current_workspace_dir, current_workspace_dir), colors, STYLES, expanded_folders=expanded_folders)
 
     # Re-render canvas from current in-memory state (don't reload from file)
     # This preserves canvas items that may not have been exported to .canvas/canvas.md yet
@@ -1960,15 +2236,17 @@ def refresh_sidebar(n_clicks, current_workspace, theme, collapsed_ids, session_i
     [State("file-upload-sidebar", "filename"),
      State("current-workspace-path", "data"),
      State("theme-store", "data"),
-     State("session-id", "data")],
+     State("session-id", "data"),
+     State("expanded-folders", "data")],
     prevent_initial_call=True
 )
-def handle_sidebar_upload(contents, filenames, current_workspace, theme, session_id):
+def handle_sidebar_upload(contents, filenames, current_workspace, theme, session_id, expanded_folders):
     """Handle file uploads from sidebar button to current workspace."""
     if not contents:
         raise PreventUpdate
 
     colors = get_colors(theme or "light")
+    expanded_folders = expanded_folders or []
 
     # Get workspace for this session (virtual or physical)
     workspace_root = get_workspace_for_session(session_id)
@@ -1991,7 +2269,7 @@ def handle_sidebar_upload(contents, filenames, current_workspace, theme, session
         except Exception as e:
             print(f"Upload error: {e}")
 
-    return render_file_tree(build_file_tree(current_workspace_dir, current_workspace_dir), colors, STYLES)
+    return render_file_tree(build_file_tree(current_workspace_dir, current_workspace_dir), colors, STYLES, expanded_folders=expanded_folders)
 
 
 # Create folder modal - open
@@ -2034,15 +2312,17 @@ def toggle_create_folder_modal(open_clicks, cancel_clicks, confirm_clicks, is_op
     [State("new-folder-name", "value"),
      State("current-workspace-path", "data"),
      State("theme-store", "data"),
-     State("session-id", "data")],
+     State("session-id", "data"),
+     State("expanded-folders", "data")],
     prevent_initial_call=True
 )
-def create_folder(n_clicks, folder_name, current_workspace, theme, session_id):
+def create_folder(n_clicks, folder_name, current_workspace, theme, session_id, expanded_folders):
     """Create a new folder in the current workspace directory."""
     if not n_clicks:
         raise PreventUpdate
 
     colors = get_colors(theme or "light")
+    expanded_folders = expanded_folders or []
 
     if not folder_name or not folder_name.strip():
         return no_update, "Please enter a folder name", no_update
@@ -2070,7 +2350,7 @@ def create_folder(n_clicks, folder_name, current_workspace, theme, session_id):
 
     try:
         folder_path.mkdir(parents=True, exist_ok=False)
-        return render_file_tree(build_file_tree(current_workspace_dir, current_workspace_dir), colors, STYLES), "", ""
+        return render_file_tree(build_file_tree(current_workspace_dir, current_workspace_dir), colors, STYLES, expanded_folders=expanded_folders), "", ""
     except Exception as e:
         return no_update, f"Error creating folder: {e}", no_update
 
@@ -2156,15 +2436,17 @@ def update_canvas_content(n_intervals, view_value, theme, collapsed_ids, session
     [State("current-workspace-path", "data"),
      State("theme-store", "data"),
      State("session-id", "data"),
-     State("sidebar-view-toggle", "value")],
+     State("sidebar-view-toggle", "value"),
+     State("expanded-folders", "data")],
     prevent_initial_call=True
 )
-def poll_file_tree_update(n_intervals, current_workspace, theme, session_id, view_value):
+def poll_file_tree_update(n_intervals, current_workspace, theme, session_id, view_value, expanded_folders):
     """Refresh file tree during agent execution to show newly created files.
 
     This callback runs on each poll interval and refreshes the file tree
     so that files created by the agent are visible in real-time.
     Only updates when viewing files (not canvas).
+    Preserves expanded folder state across refreshes.
     """
     # Only refresh when viewing files panel
     if view_value != "files":
@@ -2180,6 +2462,7 @@ def poll_file_tree_update(n_intervals, current_workspace, theme, session_id, vie
         raise PreventUpdate
 
     colors = get_colors(theme or "light")
+    expanded_folders = expanded_folders or []
 
     # Get workspace for this session (virtual or physical)
     workspace_root = get_workspace_for_session(session_id)
@@ -2190,8 +2473,8 @@ def poll_file_tree_update(n_intervals, current_workspace, theme, session_id, vie
     else:
         current_workspace_dir = workspace_root / current_workspace if current_workspace else workspace_root
 
-    # Refresh file tree
-    return render_file_tree(build_file_tree(current_workspace_dir, current_workspace_dir), colors, STYLES)
+    # Refresh file tree, preserving expanded folder state
+    return render_file_tree(build_file_tree(current_workspace_dir, current_workspace_dir), colors, STYLES, expanded_folders=expanded_folders)
 
 
 # Open clear canvas confirmation modal

cowork_dash/canvas.py

@@ -13,6 +13,14 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 from datetime import datetime
 
+# Early pandas import to prevent circular import issues with Plotly's JSON serializer.
+# Plotly lazily imports pandas and checks `obj is pd.NaT` which fails if pandas
+# is partially initialized due to concurrent imports.
+try:
+    import pandas
+except (ImportError, AttributeError):
+    pass
+
 from .virtual_fs import VirtualFilesystem, VirtualPath
 
 

cowork_dash/file_utils.py

@@ -136,15 +136,17 @@ def load_folder_contents(
     return build_file_tree(full_path, workspace_root, lazy_load=True)
 
 
-def render_file_tree(items: List[Dict], colors: Dict, styles: Dict, level: int = 0, parent_path: str = "") -> List:
+def render_file_tree(items: List[Dict], colors: Dict, styles: Dict, level: int = 0, parent_path: str = "", expanded_folders: List[str] = None) -> List:
     """Render file tree with collapsible folders using CSS classes for theming."""
     components = []
     indent = level * 15  # Scaled up indent
+    expanded_folders = expanded_folders or []
 
     for item in items:
         if item["type"] == "folder":
             folder_id = item["path"].replace("/", "_").replace("\\", "_")
             children = item.get("children", [])
+            is_expanded = folder_id in expanded_folders
 
             # Folder header with expand icon and selectable name
             components.append(
@@ -160,6 +162,7 @@ def render_file_tree(items: List[Dict], colors: Dict, styles: Dict, level: int =
                             "transition": "transform 0.15s",
                             "display": "inline-block",
                             "padding": "2px",
+                            "transform": "rotate(90deg)" if is_expanded else "rotate(0deg)",
                         }
                     ),
                     # Folder name (clickable for selection)
@@ -196,7 +199,7 @@ def render_file_tree(items: List[Dict], colors: Dict, styles: Dict, level: int =
 
             if children:
                 # Children are loaded, render them
-                child_content = render_file_tree(children, colors, styles, level + 1, item["path"])
+                child_content = render_file_tree(children, colors, styles, level + 1, item["path"], expanded_folders)
             elif not has_children:
                 # Folder is known to be empty
                 child_content = [
@@ -226,7 +229,7 @@ def render_file_tree(items: List[Dict], colors: Dict, styles: Dict, level: int =
                 html.Div(
                     child_content,
                     id={"type": "folder-children", "path": folder_id},
-                    style={"display": "none"}  # Collapsed by default
+                    style={"display": "block" if is_expanded else "none"}
                 )
             )
         else:
@@ -288,11 +291,25 @@ def get_file_download_data(
         # Determine MIME type
         ext = PurePosixPath(path).suffix.lower()
         mime_types = {
+            # Text
             ".txt": "text/plain", ".py": "text/x-python", ".js": "text/javascript",
-            ".json": "application/json", ".html": "text/html", ".css": "text/css",
-            ".md": "text/markdown", ".csv": "text/csv", ".xml": "text/xml",
-            ".pdf": "application/pdf", ".png": "image/png", ".jpg": "image/jpeg",
-            ".gif": "image/gif", ".zip": "application/zip",
+            ".json": "application/json", ".html": "text/html", ".htm": "text/html",
+            ".css": "text/css", ".md": "text/markdown", ".csv": "text/csv",
+            ".xml": "text/xml", ".yaml": "text/yaml", ".yml": "text/yaml",
+            # Images
+            ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg",
+            ".gif": "image/gif", ".webp": "image/webp", ".svg": "image/svg+xml",
+            ".ico": "image/x-icon", ".bmp": "image/bmp",
+            # Video
+            ".mp4": "video/mp4", ".webm": "video/webm", ".ogg": "video/ogg",
+            ".mov": "video/quicktime",
+            # Audio
+            ".mp3": "audio/mpeg", ".wav": "audio/wav", ".m4a": "audio/mp4",
+            ".flac": "audio/flac",
+            # Documents
+            ".pdf": "application/pdf",
+            # Archives
+            ".zip": "application/zip",
         }
         mime = mime_types.get(ext, "application/octet-stream")
 

cowork_dash/tools.py

@@ -1,15 +1,61 @@
 from typing import Any, Dict, List, Optional
 import sys
 import io
+import os
 import traceback
 import subprocess
 import threading
-from contextlib import redirect_stdout, redirect_stderr
+import platform
+from contextlib import redirect_stdout, redirect_stderr, contextmanager
 
 from .config import WORKSPACE_ROOT, VIRTUAL_FS
 from .canvas import parse_canvas_object, generate_canvas_id
 
 
+# Memory limit for cell execution (in bytes)
+# Default: 512 MB - can be overridden via environment variable
+CELL_MEMORY_LIMIT_MB = int(os.environ.get("COWORK_CELL_MEMORY_LIMIT_MB", "512"))
+CELL_MEMORY_LIMIT_BYTES = CELL_MEMORY_LIMIT_MB * 1024 * 1024
+
+
+@contextmanager
+def memory_limit(max_bytes: int = CELL_MEMORY_LIMIT_BYTES):
+    """Context manager to set memory limits for code execution on Linux.
+
+    On Linux, uses resource.setrlimit() to set soft memory limit.
+    On other platforms (macOS, Windows), this is a no-op as they don't
+    support RLIMIT_AS in the same way or at all.
+
+    The limit applies to the virtual address space (RLIMIT_AS) which
+    will cause MemoryError when exceeded rather than OOM kill.
+
+    Args:
+        max_bytes: Maximum memory in bytes. Default from CELL_MEMORY_LIMIT_BYTES.
+    """
+    if platform.system() != "Linux":
+        # Memory limits via resource module only work reliably on Linux
+        yield
+        return
+
+    try:
+        import resource
+    except ImportError:
+        yield
+        return
+
+    # Get current limits
+    soft, hard = resource.getrlimit(resource.RLIMIT_AS)
+
+    try:
+        # Set new soft limit (don't exceed hard limit)
+        new_soft = min(max_bytes, hard) if hard != resource.RLIM_INFINITY else max_bytes
+        resource.setrlimit(resource.RLIMIT_AS, (new_soft, hard))
+        yield
+    finally:
+        # Restore original limits
+        resource.setrlimit(resource.RLIMIT_AS, (soft, hard))
+
+
 # Thread-local storage for current session context
 # This allows tools to know which session they're operating in
 _tool_context = threading.local()
@@ -383,47 +429,54 @@ except (ImportError, AttributeError):
         }
 
         try:
-            # Try IPython first for better execution handling
-            ipython = self._get_ipython()
-
-            if ipython is not None:
-                # Use IPython's run_cell for magic commands support
-                with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
-                    exec_result = ipython.run_cell(cell["source"], store_history=True)
-
-                result["stdout"] = stdout_capture.getvalue()
-                result["stderr"] = stderr_capture.getvalue()
-
-                if exec_result.success:
-                    if exec_result.result is not None:
-                        result["result"] = repr(exec_result.result)
+            # Apply memory limit on Linux to prevent OOM kills
+            with memory_limit():
+                # Try IPython first for better execution handling
+                ipython = self._get_ipython()
+
+                if ipython is not None:
+                    # Use IPython's run_cell for magic commands support
+                    with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
+                        exec_result = ipython.run_cell(cell["source"], store_history=True)
+
+                    result["stdout"] = stdout_capture.getvalue()
+                    result["stderr"] = stderr_capture.getvalue()
+
+                    if exec_result.success:
+                        if exec_result.result is not None:
+                            result["result"] = repr(exec_result.result)
+                    else:
+                        if exec_result.error_in_exec:
+                            result["error"] = str(exec_result.error_in_exec)
+                            result["status"] = "error"
+                        elif exec_result.error_before_exec:
+                            result["error"] = str(exec_result.error_before_exec)
+                            result["status"] = "error"
                 else:
-                    if exec_result.error_in_exec:
-                        result["error"] = str(exec_result.error_in_exec)
-                        result["status"] = "error"
-                    elif exec_result.error_before_exec:
-                        result["error"] = str(exec_result.error_before_exec)
-                        result["status"] = "error"
-            else:
-                # Fallback to exec() if IPython is not available
-                with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
-                    # Compile to check for expression vs statement
-                    code = cell["source"].strip()
-
-                    # Try to evaluate as expression first (to get return value)
-                    try:
-                        # Check if it's a simple expression
-                        compiled = compile(code, "<cell>", "eval")
-                        exec_result = eval(compiled, self._namespace)
-                        if exec_result is not None:
-                            result["result"] = repr(exec_result)
-                    except SyntaxError:
-                        # It's a statement, execute it
-                        exec(code, self._namespace)
-
-                result["stdout"] = stdout_capture.getvalue()
-                result["stderr"] = stderr_capture.getvalue()
-
+                    # Fallback to exec() if IPython is not available
+                    with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
+                        # Compile to check for expression vs statement
+                        code = cell["source"].strip()
+
+                        # Try to evaluate as expression first (to get return value)
+                        try:
+                            # Check if it's a simple expression
+                            compiled = compile(code, "<cell>", "eval")
+                            exec_result = eval(compiled, self._namespace)
+                            if exec_result is not None:
+                                result["result"] = repr(exec_result)
+                        except SyntaxError:
+                            # It's a statement, execute it
+                            exec(code, self._namespace)
+
+                    result["stdout"] = stdout_capture.getvalue()
+                    result["stderr"] = stderr_capture.getvalue()
+
+        except MemoryError:
+            result["error"] = f"MemoryError: Cell execution exceeded memory limit ({CELL_MEMORY_LIMIT_MB} MB). Try processing data in smaller chunks."
+            result["status"] = "error"
+            result["stdout"] = stdout_capture.getvalue()
+            result["stderr"] = stderr_capture.getvalue()
         except Exception:
             result["error"] = traceback.format_exc()
             result["status"] = "error"

{cowork_dash-0.1.8.dist-info → cowork_dash-0.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cowork-dash
-Version: 0.1.8
+Version: 0.1.9
 Summary: AI Agent Web Interface with Filesystem and Canvas Visualization
 Project-URL: Homepage, https://github.com/dkedar7/cowork-dash
 Project-URL: Documentation, https://github.com/dkedar7/cowork-dash/blob/main/README.md

{cowork_dash-0.1.8.dist-info → cowork_dash-0.1.9.dist-info}/RECORD

@@ -1,22 +1,22 @@
 cowork_dash/__init__.py,sha256=37qBKl7g12Zos8GFukXLXligCdpD32e2qe9F8cd8Qdk,896
 cowork_dash/__main__.py,sha256=CCM9VIkWuwh7hwVGNBBgCCbeVAcHj1soyBVXUaPgABk,131
 cowork_dash/agent.py,sha256=JhCeQuMJj3VaQij2i8OPznKN6qGAixN-hakueiGfdt0,5851
-cowork_dash/app.py,sha256=a7Z1N81h5BbI0rYfvy4_j4RDepVVTzJ622ma4KFjBec,109947
+cowork_dash/app.py,sha256=5Fd2MZThIovq3uxf2qNq1i9lEKIPtmvUHO3ikk3k4Mc,122674
 cowork_dash/backends.py,sha256=YQE8f65o2qGxIIfvBITAS6krCLjl8D9UixW-pgbdgZk,15050
-cowork_dash/canvas.py,sha256=TNDku1AKpkajj1RgJW3zUDIq45H3M2RNR1plcsBS3dc,16969
+cowork_dash/canvas.py,sha256=sYOQ5WBLm29UazA5KO7j8jvIeQpx55LToz1o44o2U-k,17261
 cowork_dash/cli.py,sha256=E7H9p21XcvuF6Kae4rjVVOavU7U8-TY0qFLHLPOtYWg,7125
 cowork_dash/components.py,sha256=SlR0U1d0XThdcPZYButE_Fqt8MWPoLAgOTqtwfisvOQ,23776
 cowork_dash/config.py,sha256=PoAxUbctyd_2JjH4eVffKhOPCEOvaRyPSzCmS4MFPi8,4570
-cowork_dash/file_utils.py,sha256=KwYHOtVkp-anysqktGsLvtb3yg-N4e3QhnliSfvFr6o,12533
+cowork_dash/file_utils.py,sha256=mhy7gZFxwd1YN28C8jxYrtTCRLVDx4JVqELN-KCdtu8,13368
 cowork_dash/layout.py,sha256=6K6O7rxnYxcrIzMOQYtyth12wRGcZ_l8qKaZFvbxvRo,16634
-cowork_dash/tools.py,sha256=ywfF1EVA8swI81z9yBwU0U7sA9ZzwiqrYjlyV1ygDN4,33275
+cowork_dash/tools.py,sha256=AOzO4_dl_mvTKr9bL0ibg0BUD53axm_Nfnth7io8bl0,35357
 cowork_dash/virtual_fs.py,sha256=PAAdRiMkxgJ4xPpGUyAUd69KbH-nFlt-FjldfB1FrQ4,16296
 cowork_dash/assets/app.js,sha256=Fo_tgFat9eXtpvrptLHmS0qAs04pfF0IaQYiT-Tohm8,8768
 cowork_dash/assets/favicon.ico,sha256=IiP0rVr0m-TBGGmCY88SyFC14drNwDhLRqb0n2ZufKk,54252
 cowork_dash/assets/favicon.svg,sha256=MdT50APCvIlWh3HSwW5SNXYWB3q_wKfuLP-JV53SnKg,1065
 cowork_dash/assets/styles.css,sha256=w4D9jAneSUjCZxdXu1tIbbKPt_HnNF0nax4hy9liOHw,24095
-cowork_dash-0.1.8.dist-info/METADATA,sha256=cdWkiguLARGvtAyg61S8fmhuk2nseXgU37rNeYDSXgY,6719
-cowork_dash-0.1.8.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-cowork_dash-0.1.8.dist-info/entry_points.txt,sha256=lL_9XJINiky3nh13tLqWd61LitKbbyh085ROATH9fck,53
-cowork_dash-0.1.8.dist-info/licenses/LICENSE,sha256=2SFXFfIa_c_g_uwY0JApQDXI1mWqEfJeG87Pn4ehLMQ,1072
-cowork_dash-0.1.8.dist-info/RECORD,,
+cowork_dash-0.1.9.dist-info/METADATA,sha256=Y1_ieezAgbVMwQoy7HovfZ9696BZvX3QZoXNeXXYAuE,6719
+cowork_dash-0.1.9.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+cowork_dash-0.1.9.dist-info/entry_points.txt,sha256=lL_9XJINiky3nh13tLqWd61LitKbbyh085ROATH9fck,53
+cowork_dash-0.1.9.dist-info/licenses/LICENSE,sha256=2SFXFfIa_c_g_uwY0JApQDXI1mWqEfJeG87Pn4ehLMQ,1072
+cowork_dash-0.1.9.dist-info/RECORD,,