Feature Request: Firefox Workspace Sync Support

[jms830]

Overview

Currently, Eidolon's core workspace sync feature does not work in Firefox due to browser API limitations. This issue documents the technical constraints and explores potential solutions for bringing full feature parity to Firefox users.

Current Status

✅ What Works in Firefox

• ✅ Authentication (with manual session key input)
• ✅ Dashboard UI
• ✅ Projects browsing
• ✅ Files viewing
• ✅ Conversations management
• ✅ Search functionality
• ✅ Tags system

❌ What Doesn't Work in Firefox

• ❌ Workspace directory selection (showDirectoryPicker())
• ❌ Bidirectional file sync
• ❌ Workspace diff preview
• ❌ Local file system integration

Technical Root Cause

Eidolon uses the File System Access API (window.showDirectoryPicker()) for workspace sync, which allows users to select a real directory on their computer for bidirectional sync with Claude.ai projects.

Browser Support:

• ✅ Chrome/Edge: Full support since Chrome 86 (2020)
• ❌ Firefox: Not supported, and Mozilla has explicitly stated they will not implement it due to security/UX concerns
• ❌ Safari: Limited support

Mozilla's position: "We are not implementing or considering implementing APIs that relate to allowing origins access to the user's file system through explicit semi-durable grants at this time due to concerns about how to safely provide users with informed consent."

Alternative APIs Considered

1. Origin Private File System (OPFS)

Status: ✅ Supported in Firefox since v111 (March 2023)

API:

const root = await navigator.storage.getDirectory();
const fileHandle = await root.getFileHandle('myfile.txt', { create: true });

Why This Doesn't Work for Eidolon:

• Files are sandboxed browser storage (like IndexedDB), not real file system
• Files are invisible to users (can't browse in Finder/Explorer)
• No integration with text editors (VSCode, Sublime, etc.)
• No git integration or build tools access
• Files are isolated per-origin and not in a user-chosen workspace directory

Use Cases OPFS IS Good For:

• Offline web apps (Google Docs)
• In-browser media editors
• Temporary file storage
• High-performance Worker file I/O

Verdict: ❌ Not suitable for workspace sync - users need access to real files in real directories

Potential Solutions

Option 1: Native Messaging ⭐ (Recommended)

How It Works:

• Extension communicates with a small native application installed on user's computer
• Native app has full file system access (like any desktop app)
• Communication via JSON messages over stdin/stdout
• Cross-browser compatible (Firefox, Chrome, Edge)

Architecture:

┌─────────────────┐         ┌──────────────────┐
│  Browser        │ Native  │  Native Host     │
│  Extension      │ Messaging│  (Python/Node)   │
│  (JavaScript)   │◄───────►│  Full FS Access  │
└─────────────────┘         └──────────────────┘

Real-World Examples:

• 1Password, Bitwarden - Secure file access
• KeePassXC-Browser - Database file access
• TabFS - File system mounting
• File System Access polyfill extension

Implementation Requirements:

1. Native host executable (Python, Node.js, Go, or Rust)
2. Native messaging manifest (tells browser where host is)
3. Extension manifest permission: "nativeMessaging"
4. Cross-platform installers (Windows, Mac, Linux)

Sample Native Host (Python):

#!/usr/bin/env python3
import json
import sys
import os

def read_message():
    text_length_bytes = sys.stdin.buffer.read(4)
    text_length = int.from_bytes(text_length_bytes, 'little')
    text = sys.stdin.buffer.read(text_length).decode('utf-8')
    return json.loads(text)

def send_message(message):
    encoded_content = json.dumps(message).encode('utf-8')
    encoded_length = len(encoded_content).to_bytes(4, 'little')
    sys.stdout.buffer.write(encoded_length)
    sys.stdout.buffer.write(encoded_content)
    sys.stdout.buffer.flush()

# Main loop handles readFile, writeFile, listDirectory, etc.

Pros:

• ✅ Full file system access (same UX as Chrome)
• ✅ Works in Firefox, Chrome, and Edge
• ✅ Cross-platform (Windows, Mac, Linux)
• ✅ Can reuse existing SyncManager logic
• ✅ Offline, no server needed
• ✅ Professional approach (used by major extensions)

Cons:

• ❌ Requires users to install native host (extra step)
• ❌ More complex distribution/setup
• ❌ Need to build installers for each OS
• ❌ Antivirus software might flag the native host
• ❌ Additional maintenance burden

Option 2: OPFS + Export/Import (Hybrid)

How It Works:

• Store workspace in OPFS (browser-sandboxed storage)
• Provide "Export Workspace" button → downloads ZIP file
• Provide "Import Workspace" button → uploads ZIP to OPFS
• Manual sync workflow instead of seamless bidirectional sync

Implementation:

// Store workspace in OPFS
const opfsRoot = await navigator.storage.getDirectory();

// Export button: Download entire workspace as ZIP
async function exportWorkspace() {
  const zip = await createZipFromOPFS(opfsRoot);
  browser.downloads.download({
    url: URL.createObjectURL(zip),
    filename: 'eidolon-workspace.zip'
  });
}

// Import button: Upload ZIP to OPFS
async function importWorkspace(zipFile) {
  await extractZipToOPFS(zipFile, opfsRoot);
  await syncToClaudeAI();
}

Pros:

• ✅ Works in Firefox without installation
• ✅ No native host required
• ✅ Simple implementation
• ✅ Users can download/backup workspace as ZIP

Cons:

• ❌ Not true bidirectional sync
• ❌ Manual export/import workflow
• ❌ Files not accessible to external editors
• ❌ No git integration
• ❌ Degraded user experience vs Chrome

Option 3: Chrome/Edge Only (Current Approach)

Strategy:

• Focus on Chrome/Edge for full workspace sync
• Firefox version supports all features except sync
• Clear messaging about browser requirements
• Wait for Firefox to reconsider (unlikely based on Mozilla's position)

Pros:

• ✅ Clean, simple implementation
• ✅ Best user experience for supported browsers
• ✅ No compromises or workarounds
• ✅ Matches user expectations (most devs use Chrome/Edge)

Cons:

• ❌ Excludes Firefox users from core feature
• ❌ Limits potential user base
• ❌ Firefox users may feel second-class

Recommended Approach

Phase 1 (Current):

• ✅ Chrome/Edge: Full workspace sync support
• ✅ Firefox: Authentication, dashboard, project browsing (no sync)
• ✅ Clear documentation about browser requirements
• ✅ Manual session key input for Firefox authentication

Phase 2 (Future - Optional):

• Add Native Messaging host for Firefox power users
• Make it opt-in/advanced feature
• Provide installers for Windows/Mac/Linux
• Auto-detect and use appropriate method (File System Access API vs Native Messaging)

Phase 3 (Alternative):

• OPFS-based workspace with export/import for Firefox
• Downgrade to manual workflow but maintain some functionality
• Better than nothing for Firefox-only users

Related Resources

• Mozilla's Position on File System Access API
• MDN: File System Access API
• MDN: Native Messaging
• MDN: Origin Private File System (OPFS)
• Can I Use: File System Access API
• Native Messaging Examples
• simov/native-messaging - Protocol implementation

Next Steps

1. Decide on implementation approach based on project priorities
2. If Native Messaging is chosen:
   • Design native host protocol
   • Choose implementation language (Python, Node.js, Go, or Rust)
   • Create cross-platform build/install scripts
   • Update extension to detect and use native messaging when available
3. If OPFS+Export is chosen:
   • Implement OPFS storage adapter
   • Add ZIP export/import functionality
   • Update UI for manual sync workflow
4. Update documentation with browser compatibility matrix