cowork-dash 0.1.6__py3-none-any.whl → 0.1.7__py3-none-any.whl

cowork_dash/canvas.py

@@ -1,4 +1,8 @@
-"""Canvas utilities for parsing, exporting, and loading canvas objects."""
+"""Canvas utilities for parsing, exporting, and loading canvas objects.
+
+Supports both physical filesystem (Path) and virtual filesystem (VirtualFilesystem)
+for session isolation in multi-user deployments.
+"""
 
 import io
 import json
@@ -6,9 +10,24 @@ import base64
 import re
 import uuid
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 from datetime import datetime
 
+from .virtual_fs import VirtualFilesystem, VirtualPath
+
+
+# Type alias for paths that work with both physical and virtual filesystems
+AnyPath = Union[Path, VirtualPath]
+AnyRoot = Union[Path, VirtualFilesystem]
+
+
+def _get_path(root: AnyRoot, path: str = "") -> AnyPath:
+    """Get a path object from root, handling both Path and VirtualFilesystem."""
+    if isinstance(root, VirtualFilesystem):
+        return root.path(path) if path else root.root
+    else:
+        return root / path if path else root
+
 
 def generate_canvas_id() -> str:
     """Generate a unique ID for a canvas item."""
@@ -17,7 +36,7 @@ def generate_canvas_id() -> str:
 
 def parse_canvas_object(
     obj: Any,
-    workspace_root: Path,
+    workspace_root: AnyRoot,
     title: Optional[str] = None,
     item_id: Optional[str] = None
 ) -> Dict[str, Any]:
@@ -25,7 +44,7 @@ def parse_canvas_object(
 
     Args:
         obj: The Python object to parse (DataFrame, Figure, Image, str, etc.)
-        workspace_root: Path to the workspace root directory
+        workspace_root: Path to the workspace root directory (Path or VirtualFilesystem)
         title: Optional title for the canvas item
         item_id: Optional ID for the canvas item (auto-generated if not provided)
 
@@ -53,7 +72,7 @@ def parse_canvas_object(
         return result
 
     # Ensure .canvas directory exists
-    canvas_dir = workspace_root / ".canvas"
+    canvas_dir = _get_path(workspace_root, ".canvas")
     canvas_dir.mkdir(exist_ok=True)
 
     # Pandas DataFrame - keep inline
@@ -71,15 +90,19 @@ def parse_canvas_object(
         filename = f"matplotlib_{timestamp}.png"
         filepath = canvas_dir / filename
 
-        obj.savefig(filepath, format='png', bbox_inches='tight', dpi=100)
-
-        # Also store base64 for in-memory rendering
+        # Save to buffer first, then to file
         buf = io.BytesIO()
         obj.savefig(buf, format='png', bbox_inches='tight', dpi=100)
         buf.seek(0)
-        img_base64 = base64.b64encode(buf.read()).decode('utf-8')
+        img_data = buf.read()
         buf.close()
 
+        # Write to file (virtual or physical)
+        filepath.write_bytes(img_data)
+
+        # Also store base64 for in-memory rendering
+        img_base64 = base64.b64encode(img_data).decode('utf-8')
+
         return add_metadata({
             "type": "matplotlib",
             "file": filename,  # Relative to .canvas/ directory where canvas.md lives
@@ -107,15 +130,19 @@ def parse_canvas_object(
         filename = f"image_{timestamp}.png"
         filepath = canvas_dir / filename
 
-        obj.save(filepath, format='PNG')
-
-        # Also store base64 for in-memory rendering
+        # Save to buffer first
         buf = io.BytesIO()
         obj.save(buf, format='PNG')
         buf.seek(0)
-        img_base64 = base64.b64encode(buf.read()).decode('utf-8')
+        img_data = buf.read()
         buf.close()
 
+        # Write to file (virtual or physical)
+        filepath.write_bytes(img_data)
+
+        # Also store base64 for in-memory rendering
+        img_base64 = base64.b64encode(img_data).decode('utf-8')
+
         return add_metadata({
             "type": "image",
             "file": filename,  # Relative to .canvas/ directory where canvas.md lives
@@ -162,14 +189,29 @@ def parse_canvas_object(
         })
 
 
-def export_canvas_to_markdown(canvas_items: List[Dict], workspace_root: Path, output_path: str = None):
-    """Export canvas to markdown file with file references and metadata."""
+def export_canvas_to_markdown(
+    canvas_items: List[Dict],
+    workspace_root: AnyRoot,
+    output_path: str = None
+) -> str:
+    """Export canvas to markdown file with file references and metadata.
+
+    Args:
+        canvas_items: List of parsed canvas items
+        workspace_root: Path to the workspace root directory (Path or VirtualFilesystem)
+        output_path: Optional custom output path (relative to workspace_root/.canvas/)
+
+    Returns:
+        Path to the output file
+    """
     # Ensure .canvas directory exists
-    canvas_dir = workspace_root / ".canvas"
+    canvas_dir = _get_path(workspace_root, ".canvas")
     canvas_dir.mkdir(exist_ok=True)
 
     if not output_path:
-        output_path = canvas_dir / "canvas.md"
+        output_file = canvas_dir / "canvas.md"
+    else:
+        output_file = _get_path(workspace_root, output_path)
 
     lines = [
         "# Canvas Export",
@@ -222,24 +264,37 @@ def export_canvas_to_markdown(canvas_items: List[Dict], workspace_root: Path, ou
                 lines.append(f"\n```json\n{json.dumps(parsed.get('data'), indent=2)}\n```\n")
 
     # Write to file
-    output_file = Path(output_path)
     output_file.write_text("\n".join(lines))
     return str(output_file)
 
 
-def load_canvas_from_markdown(workspace_root: Path, markdown_path: str = None) -> List[Dict]:
-    """Load canvas from markdown file and referenced assets, preserving metadata."""
+def load_canvas_from_markdown(
+    workspace_root: AnyRoot,
+    markdown_path: str = None
+) -> List[Dict]:
+    """Load canvas from markdown file and referenced assets, preserving metadata.
+
+    Args:
+        workspace_root: Path to the workspace root directory (Path or VirtualFilesystem)
+        markdown_path: Optional custom markdown file path
+
+    Returns:
+        List of parsed canvas items
+    """
     if not markdown_path:
-        markdown_path = workspace_root / ".canvas" / "canvas.md"
+        canvas_md = _get_path(workspace_root, ".canvas/canvas.md")
     else:
-        markdown_path = Path(markdown_path)
+        canvas_md = _get_path(workspace_root, markdown_path)
 
-    if not markdown_path.exists():
+    if not canvas_md.exists():
         return []
 
-    content = markdown_path.read_text()
+    content = canvas_md.read_text()
     canvas_items = []
 
+    # Get parent directory for loading referenced files
+    canvas_dir = canvas_md.parent
+
     # First, find all metadata comments to get item boundaries and metadata
     metadata_pattern = r'<!-- canvas-item: ({.*?}) -->'
     metadata_matches = list(re.finditer(metadata_pattern, content))
@@ -260,17 +315,21 @@ def load_canvas_from_markdown(workspace_root: Path, markdown_path: str = None) -
                 end = len(content)
 
             item_content = content[start:end].strip()
-            item = _parse_item_content(item_content, metadata, markdown_path)
+            item = _parse_item_content(item_content, metadata, canvas_dir)
             if item:
                 canvas_items.append(item)
     else:
         # Fallback: legacy parsing without metadata (backwards compatibility)
-        canvas_items = _parse_legacy_canvas(content, markdown_path)
+        canvas_items = _parse_legacy_canvas(content, canvas_dir)
 
     return canvas_items
 
 
-def _parse_item_content(content: str, metadata: Dict, markdown_path: Path) -> Optional[Dict]:
+def _parse_item_content(
+    content: str,
+    metadata: Dict,
+    canvas_dir: AnyPath
+) -> Optional[Dict]:
     """Parse a single item's content given its metadata."""
     item_type = metadata.get("type", "markdown")
     item = {
@@ -297,7 +356,7 @@ def _parse_item_content(content: str, metadata: Dict, markdown_path: Path) -> Op
         match = re.search(r'```plotly\s*\n([^\n]+)\n```', content)
         if match:
             file_ref = match.group(1).strip()
-            file_path = markdown_path.parent / file_ref
+            file_path = canvas_dir / file_ref
             if file_path.exists():
                 item["file"] = file_ref
                 item["data"] = json.loads(file_path.read_text())
@@ -308,10 +367,10 @@ def _parse_item_content(content: str, metadata: Dict, markdown_path: Path) -> Op
         if match:
             file_ref = match.group(1)
             if not file_ref.startswith('data:'):
-                file_path = markdown_path.parent / file_ref
+                file_path = canvas_dir / file_ref
                 if file_path.exists():
-                    with open(file_path, 'rb') as f:
-                        item["data"] = base64.b64encode(f.read()).decode('utf-8')
+                    img_data = file_path.read_bytes()
+                    item["data"] = base64.b64encode(img_data).decode('utf-8')
                     item["file"] = file_ref
                     item["type"] = "image"  # Normalize type
                     return item
@@ -332,7 +391,7 @@ def _parse_item_content(content: str, metadata: Dict, markdown_path: Path) -> Op
     return None
 
 
-def _parse_legacy_canvas(content: str, markdown_path: Path) -> List[Dict]:
+def _parse_legacy_canvas(content: str, canvas_dir: AnyPath) -> List[Dict]:
     """Parse canvas without metadata comments (legacy format)."""
     canvas_items = []
     code_blocks = []
@@ -399,17 +458,17 @@ def _parse_legacy_canvas(content: str, markdown_path: Path) -> List[Dict]:
             item["data"] = block['content']
             canvas_items.append(item)
         elif block['type'] == 'plotly_file':
-            file_path = markdown_path.parent / block['content']
+            file_path = canvas_dir / block['content']
             if file_path.exists():
                 item["type"] = "plotly"
                 item["file"] = block['content']
                 item["data"] = json.loads(file_path.read_text())
                 canvas_items.append(item)
         elif block['type'] == 'image_file':
-            file_path = markdown_path.parent / block['content']
+            file_path = canvas_dir / block['content']
             if file_path.exists():
-                with open(file_path, 'rb') as f:
-                    item["data"] = base64.b64encode(f.read()).decode('utf-8')
+                img_data = file_path.read_bytes()
+                item["data"] = base64.b64encode(img_data).decode('utf-8')
                 item["type"] = "image"
                 item["file"] = block['content']
                 canvas_items.append(item)
@@ -429,4 +488,4 @@ def _parse_legacy_canvas(content: str, markdown_path: Path) -> List[Dict]:
                 "data": remaining
             })
 
-    return canvas_items
+    return canvas_items

cowork_dash/cli.py

@@ -126,21 +126,21 @@ cowork-dash run --help
 """
     (project_dir / "README.md").write_text(readme)
 
-    print(f"✓ Created project structure")
-    print(f"✓ Created config.py")
-    print(f"✓ Created workspace/")
-    print(f"✓ Created .env.example")
-    print(f"✓ Created .gitignore")
-    print(f"✓ Created README.md")
+    print("✓ Created project structure")
+    print("✓ Created config.py")
+    print("✓ Created workspace/")
+    print("✓ Created .env.example")
+    print("✓ Created .gitignore")
+    print("✓ Created README.md")
     print(f"\n{'='*50}")
     print(f"🎉 Project '{name}' created successfully!")
     print(f"{'='*50}\n")
-    print(f"Next steps:")
+    print("Next steps:")
     print(f"  1. cd {name}")
-    print(f"  2. cp .env.example .env  # If using DeepAgents")
-    print(f"  3. Edit .env and add your ANTHROPIC_API_KEY")
-    print(f"  4. Edit config.py to customize your agent")
-    print(f"  5. cowork-dash run")
+    print("  2. cp .env.example .env  # If using DeepAgents")
+    print("  3. Edit .env and add your ANTHROPIC_API_KEY")
+    print("  4. Edit config.py to customize your agent")
+    print("  5. cowork-dash run")
     print()
 
     return 0
@@ -151,6 +151,10 @@ def run_app_cli(args):
     # Import here to avoid loading Dash when just running init
     from .app import run_app
 
+    # Only pass virtual_fs if explicitly set via --virtual-fs flag
+    # Otherwise pass None to let env var / config take precedence
+    virtual_fs = True if args.virtual_fs else None
+
     return run_app(
         workspace=args.workspace,
         agent_spec=args.agent,
@@ -159,7 +163,8 @@ def run_app_cli(args):
         debug=args.debug,
         title=args.title,
         welcome_message=args.welcome_message,
-        config_file=args.config
+        config_file=args.config,
+        virtual_fs=virtual_fs
     )
 
 
@@ -259,6 +264,12 @@ For more help: https://github.com/dkedar7/cowork-dash
         dest="welcome_message",
         help="Welcome message shown on startup (supports markdown)"
     )
+    run_parser.add_argument(
+        "--virtual-fs",
+        action="store_true",
+        dest="virtual_fs",
+        help="Use in-memory virtual filesystem (ephemeral, for multi-user isolation)"
+    )
 
     # Parse arguments
     args = parser.parse_args()

cowork_dash/components.py

@@ -335,7 +335,6 @@ def format_interrupt(interrupt_data: Dict, colors: Dict):
     # Show action requests if any
     if action_requests:
         for i, action in enumerate(action_requests):
-            action_type = action.get("type", "unknown")
             action_tool = action.get("tool", "")
             action_args = action.get("args", {})
 

cowork_dash/config.py

@@ -107,3 +107,24 @@ _default_welcome = """This is your AI-powered workspace. I can help you write co
 
 Let's get started!"""
 WELCOME_MESSAGE = get_config("welcome_message", default=_default_welcome)
+
+# Virtual filesystem mode (for multi-user deployments)
+# Environment variable: DEEPAGENT_VIRTUAL_FS
+# Accepts: true/1/yes to enable
+# When enabled:
+#   - Each browser session gets isolated in-memory file storage
+#   - Files, canvas, and uploads are not shared between sessions
+#   - All data is ephemeral (cleared when session ends)
+# When disabled (default):
+#   - All sessions share the same workspace directory on disk
+#   - Files persist on disk
+VIRTUAL_FS = get_config(
+    "virtual_fs",
+    default=False,
+    type_cast=lambda x: str(x).lower() in ("true", "1", "yes")
+)
+
+# Session timeout in seconds (only used when VIRTUAL_FS is True)
+# Environment variable: DEEPAGENT_SESSION_TIMEOUT
+# Default: 3600 (1 hour)
+SESSION_TIMEOUT = get_config("session_timeout", default=3600, type_cast=int)

cowork_dash/file_utils.py

@@ -1,10 +1,16 @@
-"""File tree and file operations utilities."""
+"""File tree and file operations utilities.
+
+Supports both physical filesystem (Path) and virtual filesystem (VirtualFilesystem)
+for session isolation in multi-user deployments.
+"""
 
 import base64
-from pathlib import Path
-from typing import List, Dict, Tuple
+from pathlib import Path, PurePosixPath
+from typing import List, Dict, Tuple, Union, Optional
 from dash import html
 
+from .virtual_fs import VirtualFilesystem, VirtualPath
+
 
 TEXT_EXTENSIONS = {
     ".py", ".js", ".ts", ".jsx", ".tsx", ".html", ".css", ".json", ".md", ".txt",
@@ -12,6 +18,10 @@ TEXT_EXTENSIONS = {
     ".gitignore", ".dockerignore", ".cfg", ".ini", ".conf", ".log"
 }
 
+# Type alias for paths that work with both physical and virtual filesystems
+AnyPath = Union[Path, VirtualPath]
+AnyRoot = Union[Path, VirtualFilesystem]
+
 
 def is_text_file(filename: str) -> bool:
     """Check if a file can be viewed as text."""
@@ -19,25 +29,67 @@ def is_text_file(filename: str) -> bool:
     return ext in TEXT_EXTENSIONS or ext == ""
 
 
-def build_file_tree(root: Path, workspace_root: Path, lazy_load: bool = True) -> List[Dict]:
+def _get_path(root: AnyRoot, path: str = "") -> AnyPath:
+    """Get a path object from root, handling both Path and VirtualFilesystem."""
+    if isinstance(root, VirtualFilesystem):
+        return root.path(path) if path else root.root
+    else:
+        return root / path if path else root
+
+
+def _relative_path(path: AnyPath, root: AnyPath) -> str:
+    """Get relative path string."""
+    if isinstance(path, VirtualPath):
+        path_str = str(path)
+        root_str = str(root)
+        if path_str.startswith(root_str):
+            rel = path_str[len(root_str):].lstrip("/")
+            return rel or "."
+        return str(path)
+    else:
+        return str(path.relative_to(root))
+
+
+def build_file_tree(
+    root: AnyPath,
+    workspace_root: AnyRoot,
+    lazy_load: bool = True
+) -> List[Dict]:
     """
     Build file tree structure.
 
     Args:
-        root: Directory to scan
-        workspace_root: Root workspace directory for relative paths
+        root: Directory to scan (Path or VirtualPath)
+        workspace_root: Root workspace directory for relative paths (Path or VirtualFilesystem)
         lazy_load: If True, only load immediate children (subdirs not expanded)
 
     Returns:
         List of file/folder items
     """
     items = []
+
+    # Get the root path object if workspace_root is a VirtualFilesystem
+    if isinstance(workspace_root, VirtualFilesystem):
+        workspace_root_path = workspace_root.root
+    else:
+        workspace_root_path = workspace_root
+
     try:
-        entries = sorted(root.iterdir(), key=lambda x: (not x.is_dir(), x.name.lower()))
+        # Get entries from directory
+        if isinstance(root, VirtualPath):
+            entries = list(root.iterdir())
+        else:
+            entries = list(root.iterdir())
+
+        # Sort: directories first, then by name
+        entries = sorted(entries, key=lambda x: (not x.is_dir(), x.name.lower()))
+
         for entry in entries:
             if entry.name.startswith('.'):
                 continue
-            rel_path = str(entry.relative_to(workspace_root))
+
+            rel_path = _relative_path(entry, workspace_root_path)
+
             if entry.is_dir():
                 # Count immediate children to show if folder is empty
                 try:
@@ -60,23 +112,27 @@ def build_file_tree(root: Path, workspace_root: Path, lazy_load: bool = True) ->
                     "path": rel_path,
                     "viewable": is_text_file(entry.name)
                 })
-    except PermissionError:
+    except (PermissionError, FileNotFoundError):
         pass
+
     return items
 
 
-def load_folder_contents(folder_path: str, workspace_root: Path) -> List[Dict]:
+def load_folder_contents(
+    folder_path: str,
+    workspace_root: AnyRoot
+) -> List[Dict]:
     """
     Load contents of a specific folder (for lazy loading).
 
     Args:
         folder_path: Relative path to the folder from workspace root
-        workspace_root: Root workspace directory
+        workspace_root: Root workspace directory (Path or VirtualFilesystem)
 
     Returns:
         List of file/folder items in the specified folder
     """
-    full_path = workspace_root / folder_path
+    full_path = _get_path(workspace_root, folder_path)
     return build_file_tree(full_path, workspace_root, lazy_load=True)
 
 
@@ -193,9 +249,13 @@ def render_file_tree(items: List[Dict], colors: Dict, styles: Dict, level: int =
     return components
 
 
-def read_file_content(workspace_root: Path, path: str) -> Tuple[str, bool, str]:
+def read_file_content(
+    workspace_root: AnyRoot,
+    path: str
+) -> Tuple[Optional[str], bool, Optional[str]]:
     """Read file content. Returns (content, is_text, error)."""
-    full_path = workspace_root / path
+    full_path = _get_path(workspace_root, path)
+
     if not full_path.exists() or not full_path.is_file():
         return None, False, "File not found"
 
@@ -211,9 +271,13 @@ def read_file_content(workspace_root: Path, path: str) -> Tuple[str, bool, str]:
         return None, False, "Binary file - download to view"
 
 
-def get_file_download_data(workspace_root: Path, path: str) -> Tuple[str, str, str]:
+def get_file_download_data(
+    workspace_root: AnyRoot,
+    path: str
+) -> Tuple[Optional[str], Optional[str], Optional[str]]:
     """Get file data for download. Returns (base64_content, filename, mime_type)."""
-    full_path = workspace_root / path
+    full_path = _get_path(workspace_root, path)
+
     if not full_path.exists():
         return None, None, None
 
@@ -222,7 +286,7 @@ def get_file_download_data(workspace_root: Path, path: str) -> Tuple[str, str, s
         b64 = base64.b64encode(content).decode('utf-8')
 
         # Determine MIME type
-        ext = full_path.suffix.lower()
+        ext = PurePosixPath(path).suffix.lower()
         mime_types = {
             ".txt": "text/plain", ".py": "text/x-python", ".js": "text/javascript",
             ".json": "application/json", ".html": "text/html", ".css": "text/css",
@@ -232,6 +296,71 @@ def get_file_download_data(workspace_root: Path, path: str) -> Tuple[str, str, s
         }
         mime = mime_types.get(ext, "application/octet-stream")
 
-        return b64, full_path.name, mime
+        # Get filename
+        if isinstance(full_path, VirtualPath):
+            filename = full_path.name
+        else:
+            filename = full_path.name
+
+        return b64, filename, mime
     except Exception:
         return None, None, None
+
+
+def write_file(
+    workspace_root: AnyRoot,
+    path: str,
+    content: Union[str, bytes],
+    encoding: str = "utf-8"
+) -> bool:
+    """
+    Write content to a file.
+
+    Args:
+        workspace_root: Root workspace directory (Path or VirtualFilesystem)
+        path: Relative path to the file
+        content: Content to write (str or bytes)
+        encoding: Encoding for text content
+
+    Returns:
+        True if successful, False otherwise
+    """
+    full_path = _get_path(workspace_root, path)
+
+    try:
+        if isinstance(content, str):
+            full_path.write_text(content, encoding=encoding)
+        else:
+            full_path.write_bytes(content)
+        return True
+    except Exception as e:
+        print(f"Error writing file {path}: {e}")
+        return False
+
+
+def create_directory(
+    workspace_root: AnyRoot,
+    path: str,
+    parents: bool = True,
+    exist_ok: bool = True
+) -> bool:
+    """
+    Create a directory.
+
+    Args:
+        workspace_root: Root workspace directory (Path or VirtualFilesystem)
+        path: Relative path to the directory
+        parents: Create parent directories if needed
+        exist_ok: Don't error if directory exists
+
+    Returns:
+        True if successful, False otherwise
+    """
+    full_path = _get_path(workspace_root, path)
+
+    try:
+        full_path.mkdir(parents=parents, exist_ok=exist_ok)
+        return True
+    except Exception as e:
+        print(f"Error creating directory {path}: {e}")
+        return False

cowork_dash/layout.py

@@ -13,7 +13,7 @@ def create_layout(workspace_root, app_title, app_subtitle, colors, styles, agent
     Create the app layout with current configuration.
 
     Args:
-        workspace_root: Path to workspace directory
+        workspace_root: Path to workspace directory (or None for virtual FS mode)
         app_title: Application title
         app_subtitle: Application subtitle
         colors: Color scheme dictionary
@@ -27,6 +27,12 @@ def create_layout(workspace_root, app_title, app_subtitle, colors, styles, agent
     # Use provided welcome message or fall back to default
     message = welcome_message if welcome_message is not None else DEFAULT_WELCOME_MESSAGE
 
+    # Build initial file tree (empty if workspace_root is None for virtual FS mode)
+    if workspace_root is not None:
+        initial_file_tree = render_file_tree(build_file_tree(workspace_root, workspace_root), colors, styles)
+    else:
+        initial_file_tree = []  # Empty tree for virtual FS - will be populated per-session
+
     return dmc.MantineProvider(
         id="mantine-provider",
         forceColorScheme="light",
@@ -39,6 +45,7 @@ def create_layout(workspace_root, app_title, app_subtitle, colors, styles, agent
             dcc.Store(id="pending-message", data=None),
             dcc.Store(id="skip-history-render", data=False),  # Flag to skip display_initial_messages render
             dcc.Store(id="session-initialized", data=False),  # Flag to track if session has been initialized
+            dcc.Store(id="session-id", data=None, storage_type="session"),  # Session ID for virtual FS isolation
             dcc.Store(id="expanded-folders", data=[]),
             dcc.Store(id="file-to-view", data=None),
             dcc.Store(id="file-click-tracker", data={}),
@@ -292,7 +299,7 @@ def create_layout(workspace_root, app_title, app_subtitle, colors, styles, agent
                         }),
                         html.Div(
                             id="file-tree",
-                            children=render_file_tree(build_file_tree(workspace_root, workspace_root), colors, styles),
+                            children=initial_file_tree,
                             style={
                                 "flex": "1",
                                 "overflowY": "auto",