Add JSON fallback for worktrees endpoint when SSE fails

SSE doesn't work through Cloudflare tunnels (502 Bad Gateway). Added:
- X-Accel-Buffering header to disable proxy buffering
- Immediate ping comment to establish SSE connection faster
- /api/worktrees/json endpoint as fallback
- Frontend auto-fallback from SSE to JSON on connection error

Author: knowsuchagency

.claude-plugin/marketplace.json

@@ -8,7 +8,7 @@
       "name": "vibora",
       "source": "./plugins/vibora",
       "description": "Task orchestration for Claude Code",
-      "version": "3.2.3"
+      "version": "3.2.4"
     }
   ]
 }

desktop/neutralino.config.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/neutralinojs/neutralinojs/main/schemas/neutralino.config.schema.json",
   "applicationId": "io.vibora.desktop",
-  "version": "3.2.3",
+  "version": "3.2.4",
   "defaultMode": "window",
   "port": 0,
   "documentRoot": "/resources/",
@@ -26,7 +26,7 @@
   ],
   "globalVariables": {
     "APP_NAME": "Vibora",
-    "APP_VERSION": "3.2.3"
+    "APP_VERSION": "3.2.4"
   },
   "modes": {
     "window": {

frontend/hooks/use-worktrees.ts

@@ -15,6 +15,11 @@ interface UseWorktreesReturn {
   refetch: () => void
 }
 
+interface WorktreesJsonResponse {
+  worktrees: (WorktreeBasic & Partial<WorktreeDetails>)[]
+  summary: WorktreesSummary
+}
+
 export function useWorktrees(): UseWorktreesReturn {
   const [worktreesMap, setWorktreesMap] = useState<Map<string, Worktree>>(new Map())
   const [summary, setSummary] = useState<WorktreesSummary | null>(null)
@@ -23,8 +28,47 @@ export function useWorktrees(): UseWorktreesReturn {
   const [error, setError] = useState<Error | null>(null)
   const eventSourceRef = useRef<EventSource | null>(null)
   const pendingDetailsRef = useRef<number>(0)
+  const useJsonFallbackRef = useRef(false)
+
+  // JSON fallback for environments where SSE doesn't work (e.g., Cloudflare tunnels)
+  const fetchJson = useCallback(async () => {
+    setIsLoading(true)
+    setError(null)
+    try {
+      const response = await fetch(`${API_BASE}/api/worktrees/json`)
+      if (!response.ok) throw new Error('Failed to fetch worktrees')
+      const data: WorktreesJsonResponse = await response.json()
+
+      setWorktreesMap(
+        new Map(
+          data.worktrees.map((w) => [
+            w.path,
+            {
+              ...w,
+              size: w.size || 0,
+              sizeFormatted: w.sizeFormatted || '0 B',
+              branch: w.branch || 'unknown',
+            },
+          ])
+        )
+      )
+      setSummary(data.summary)
+      setIsLoading(false)
+      setIsLoadingDetails(false)
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error('Failed to load worktrees'))
+      setIsLoading(false)
+      setIsLoadingDetails(false)
+    }
+  }, [])
 
   const connect = useCallback(() => {
+    // If we've determined SSE doesn't work, use JSON fallback
+    if (useJsonFallbackRef.current) {
+      fetchJson()
+      return
+    }
+
     // Close existing connection
     eventSourceRef.current?.close()
 
@@ -98,12 +142,13 @@ export function useWorktrees(): UseWorktreesReturn {
     })
 
     eventSource.onerror = () => {
-      setError(new Error('Connection lost'))
-      setIsLoading(false)
-      setIsLoadingDetails(false)
       eventSource.close()
+      // SSE failed, try JSON fallback
+      log.viewer.info('SSE connection failed, trying JSON fallback')
+      useJsonFallbackRef.current = true
+      fetchJson()
     }
-  }, [])
+  }, [fetchJson])
 
   useEffect(() => {
     connect()

frontend/routes/terminals/index.tsx

@@ -95,7 +95,6 @@ const TerminalsView = observer(function TerminalsView() {
     newTerminalIds,
     pendingTabCreation,
     lastCreatedTabId,
-    clearLastCreatedTabId,
   } = useTerminalStore()
 
   // State for tab edit dialog

package.json

@@ -1,7 +1,7 @@
 {
   "name": "vibora",
   "private": true,
-  "version": "3.2.3",
+  "version": "3.2.4",
   "description": "The Vibe Engineer's Cockpit",
   "license": "PolyForm-Shield-1.0.0",
   "type": "module",

plugins/vibora/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "vibora",
   "description": "Vibora task orchestration for Claude Code",
-  "version": "3.2.3",
+  "version": "3.2.4",
   "author": {
     "name": "Vibora"
   },

server/routes/worktrees.ts

@@ -98,7 +98,13 @@ const app = new Hono()
 
 // GET /api/worktrees - Stream worktrees via SSE for progressive loading
 app.get('/', (c) => {
+  // Disable proxy buffering for SSE (required for Cloudflare tunnels)
+  c.header('X-Accel-Buffering', 'no')
+
   return streamSSE(c, async (stream) => {
+    // Send immediate comment to establish connection (helps with proxies/tunnels)
+    await stream.write(': ping\n\n')
+
     const worktreeBasePath = getWorktreeBasePath()
 
     // Handle missing directory
@@ -223,6 +229,90 @@ app.get('/', (c) => {
   })
 })
 
+// GET /api/worktrees/json - JSON fallback for environments where SSE doesn't work (e.g., Cloudflare tunnels)
+app.get('/json', async (c) => {
+  const worktreeBasePath = getWorktreeBasePath()
+
+  // Handle missing directory
+  if (!fs.existsSync(worktreeBasePath)) {
+    return c.json({
+      worktrees: [],
+      summary: {
+        total: 0,
+        orphaned: 0,
+        totalSize: 0,
+        totalSizeFormatted: '0 B',
+      },
+    })
+  }
+
+  // Get all tasks to build a map of worktreePath -> task
+  const allTasks = db.select().from(tasks).all()
+  const worktreeToTask = new Map<string, (typeof allTasks)[0]>()
+  for (const task of allTasks) {
+    if (task.worktreePath) {
+      worktreeToTask.set(task.worktreePath, task)
+    }
+  }
+
+  // Read all directories in worktreeBasePath
+  const entries = fs.readdirSync(worktreeBasePath, { withFileTypes: true })
+  const worktrees: (WorktreeBasic & Partial<WorktreeDetails>)[] = []
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+
+    const fullPath = path.join(worktreeBasePath, entry.name)
+
+    // Check if it's a git worktree (has .git file or directory)
+    const gitPath = path.join(fullPath, '.git')
+    if (!fs.existsSync(gitPath)) continue
+
+    const stats = fs.statSync(fullPath)
+    const linkedTask = worktreeToTask.get(fullPath)
+
+    // Get size and branch in parallel
+    const [size, branch] = await Promise.all([
+      getDirectorySizeAsync(fullPath),
+      getGitBranchAsync(fullPath),
+    ])
+
+    worktrees.push({
+      path: fullPath,
+      name: entry.name,
+      lastModified: stats.mtime.toISOString(),
+      isOrphaned: !linkedTask,
+      taskId: linkedTask?.id,
+      taskTitle: linkedTask?.title,
+      taskStatus: linkedTask?.status,
+      repoPath: linkedTask?.repoPath,
+      size,
+      sizeFormatted: formatBytes(size),
+      branch,
+    })
+  }
+
+  // Sort: orphaned first, then by last modified (newest first)
+  worktrees.sort((a, b) => {
+    if (a.isOrphaned !== b.isOrphaned) {
+      return a.isOrphaned ? -1 : 1
+    }
+    return new Date(b.lastModified).getTime() - new Date(a.lastModified).getTime()
+  })
+
+  const totalSize = worktrees.reduce((sum, w) => sum + (w.size || 0), 0)
+
+  return c.json({
+    worktrees,
+    summary: {
+      total: worktrees.length,
+      orphaned: worktrees.filter((w) => w.isOrphaned).length,
+      totalSize,
+      totalSizeFormatted: formatBytes(totalSize),
+    },
+  })
+})
+
 // DELETE /api/worktrees - Delete a worktree (optionally delete linked task)
 app.delete('/', async (c) => {
   try {