From b35f2638b5dc8b51d984e084772dc315d74018a3 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Mon, 29 Dec 2025 18:15:48 +0200 Subject: [PATCH 01/98] feat(desktop): add Workbench/Review mode with FileViewer panes Introduces a workspace-level view mode toggle allowing users to switch between: - **Workbench mode**: Mosaic panes layout with terminals + file viewers for in-flow work - **Review mode**: Dedicated Changes page for focused code review Key changes: - Add ViewModeToggle component in workspace header (prominent segmented control) - Add FileViewerPane with Raw/Rendered/Diff modes, lock/unlock, and split support - Add GroupStrip for group switching above Mosaic content - Unify sidebar to use full ChangesView in both modes (with onFileOpen callback) - Add workspace-view-mode store with per-workspace persistence - Add readWorkingFile tRPC procedure for safe file reads (size/binary checks) - Wire file clicks to open/reuse FileViewer panes (MRU unlocked policy) - Cmd+T in Review mode switches to Workbench first, then creates terminal --- .../lib/trpc/routers/changes/file-contents.ts | 133 ++++- .../TabsContent/GroupStrip/GroupStrip.tsx | 151 +++++ .../TabsContent/GroupStrip/index.ts | 1 + .../TabView/FileViewerPane/FileViewerPane.tsx | 537 ++++++++++++++++++ .../TabView/FileViewerPane/index.ts | 1 + .../ContentView/TabsContent/TabView/index.tsx | 25 + .../ContentView/TabsContent/index.tsx | 10 +- .../WorkspaceView/ContentView/index.tsx | 17 +- .../Sidebar/ChangesView/ChangesView.tsx | 15 +- .../WorkspaceView/Sidebar/index.tsx | 49 +- .../WorkspaceActionBar/WorkspaceActionBar.tsx | 8 +- .../ViewModeToggle/ViewModeToggle.tsx | 55 ++ .../components/ViewModeToggle/index.ts | 1 + .../main/components/WorkspaceView/index.tsx | 18 +- apps/desktop/src/renderer/stores/index.ts | 1 + .../desktop/src/renderer/stores/tabs/store.ts | 109 +++- .../desktop/src/renderer/stores/tabs/types.ts | 15 + .../desktop/src/renderer/stores/tabs/utils.ts | 61 ++ .../renderer/stores/workspace-view-mode.ts | 56 ++ apps/desktop/src/shared/tabs-types.ts | 35 +- 20 files changed, 1267 insertions(+), 31 deletions(-) create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/index.ts create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/index.ts create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/ViewModeToggle/ViewModeToggle.tsx create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/ViewModeToggle/index.ts create mode 100644 apps/desktop/src/renderer/stores/workspace-view-mode.ts diff --git a/apps/desktop/src/lib/trpc/routers/changes/file-contents.ts b/apps/desktop/src/lib/trpc/routers/changes/file-contents.ts index 8af04dd68e4..29f035a058f 100644 --- a/apps/desktop/src/lib/trpc/routers/changes/file-contents.ts +++ b/apps/desktop/src/lib/trpc/routers/changes/file-contents.ts @@ -1,11 +1,78 @@ -import { readFile, writeFile } from "node:fs/promises"; -import { join } from "node:path"; +import { lstat, readFile, realpath, writeFile } from "node:fs/promises"; +import { isAbsolute, join, normalize, relative } from "node:path"; import type { FileContents } from "shared/changes-types"; import simpleGit from "simple-git"; import { z } from "zod"; import { publicProcedure, router } from "../.."; import { detectLanguage } from "./utils/parse-status"; +/** Maximum file size for reading (2 MiB) */ +const MAX_FILE_SIZE = 2 * 1024 * 1024; + +/** Bytes to scan for binary detection */ +const BINARY_CHECK_SIZE = 8192; + +/** + * Result type for readWorkingFile procedure + */ +type ReadWorkingFileResult = + | { ok: true; content: string; truncated: boolean; byteLength: number } + | { + ok: false; + reason: "not-found" | "too-large" | "binary" | "outside-worktree"; + }; + +/** + * Validates that a file path is within the worktree and doesn't escape via symlinks + */ +async function validatePathInWorktree( + worktreePath: string, + filePath: string, +): Promise<{ valid: boolean; resolvedPath?: string; reason?: string }> { + // Reject absolute paths + if (isAbsolute(filePath)) { + return { valid: false, reason: "outside-worktree" }; + } + + // Normalize and check for traversal + const normalizedPath = normalize(filePath); + if (normalizedPath.startsWith("..") || normalizedPath.includes("/../")) { + return { valid: false, reason: "outside-worktree" }; + } + + const fullPath = join(worktreePath, normalizedPath); + + // Resolve symlinks and verify the real path is still within worktree + try { + const realWorktreePath = await realpath(worktreePath); + const realFilePath = await realpath(fullPath); + const relativePath = relative(realWorktreePath, realFilePath); + + // If relative path starts with "..", the file is outside worktree + if (relativePath.startsWith("..") || isAbsolute(relativePath)) { + return { valid: false, reason: "outside-worktree" }; + } + + return { valid: true, resolvedPath: realFilePath }; + } catch { + // File doesn't exist + return { valid: false, reason: "not-found" }; + } +} + +/** + * Detects if a buffer contains binary content by checking for NUL bytes + */ +function isBinaryContent(buffer: Buffer): boolean { + const checkLength = Math.min(buffer.length, BINARY_CHECK_SIZE); + for (let i = 0; i < checkLength; i++) { + if (buffer[i] === 0) { + return true; + } + } + return false; +} + export const createFileContentsRouter = () => { return router({ getFileContents: publicProcedure @@ -54,6 +121,68 @@ export const createFileContentsRouter = () => { await writeFile(fullPath, input.content, "utf-8"); return { success: true }; }), + + /** + * Read a working tree file safely with size cap and binary detection. + * Used for File Viewer raw/rendered modes. + * Follows DL-005 (path validation) and DL-008 (size/binary policy). + */ + readWorkingFile: publicProcedure + .input( + z.object({ + worktreePath: z.string(), + filePath: z.string(), + }), + ) + .query(async ({ input }): Promise => { + // Validate path is within worktree + const validation = await validatePathInWorktree( + input.worktreePath, + input.filePath, + ); + + if (!validation.valid || !validation.resolvedPath) { + return { + ok: false, + reason: (validation.reason ?? "not-found") as + | "not-found" + | "outside-worktree", + }; + } + + const resolvedPath = validation.resolvedPath; + + // Check file size + try { + const stats = await lstat(resolvedPath); + if (stats.size > MAX_FILE_SIZE) { + return { ok: false, reason: "too-large" }; + } + } catch { + return { ok: false, reason: "not-found" }; + } + + // Read file content + let buffer: Buffer; + try { + buffer = await readFile(resolvedPath); + } catch { + return { ok: false, reason: "not-found" }; + } + + // Check for binary content + if (isBinaryContent(buffer)) { + return { ok: false, reason: "binary" }; + } + + // Return content as string + return { + ok: true, + content: buffer.toString("utf-8"), + truncated: false, + byteLength: buffer.length, + }; + }), }); }; diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx new file mode 100644 index 00000000000..e4aa4e47352 --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx @@ -0,0 +1,151 @@ +import { Button } from "@superset/ui/button"; +import { Tooltip, TooltipContent, TooltipTrigger } from "@superset/ui/tooltip"; +import { useMemo } from "react"; +import { HiMiniPlus, HiMiniXMark } from "react-icons/hi2"; +import { trpc } from "renderer/lib/trpc"; +import { useTabsStore } from "renderer/stores/tabs/store"; +import type { Tab } from "renderer/stores/tabs/types"; +import { getTabDisplayName } from "renderer/stores/tabs/utils"; + +interface GroupItemProps { + tab: Tab; + isActive: boolean; + needsAttention: boolean; + onSelect: () => void; + onClose: () => void; +} + +function GroupItem({ + tab, + isActive, + needsAttention, + onSelect, + onClose, +}: GroupItemProps) { + const displayName = getTabDisplayName(tab); + + return ( +
+ + + + + + {displayName} + + + +
+ ); +} + +export function GroupStrip() { + const { data: activeWorkspace } = trpc.workspaces.getActive.useQuery(); + const activeWorkspaceId = activeWorkspace?.id; + + const allTabs = useTabsStore((s) => s.tabs); + const panes = useTabsStore((s) => s.panes); + const activeTabIds = useTabsStore((s) => s.activeTabIds); + const addTab = useTabsStore((s) => s.addTab); + const removeTab = useTabsStore((s) => s.removeTab); + const setActiveTab = useTabsStore((s) => s.setActiveTab); + + const tabs = useMemo( + () => + activeWorkspaceId + ? allTabs.filter((tab) => tab.workspaceId === activeWorkspaceId) + : [], + [activeWorkspaceId, allTabs], + ); + + const activeTabId = activeWorkspaceId + ? activeTabIds[activeWorkspaceId] + : null; + + // Check which tabs have panes that need attention + const tabsWithAttention = useMemo(() => { + const result = new Set(); + for (const pane of Object.values(panes)) { + if (pane.needsAttention) { + result.add(pane.tabId); + } + } + return result; + }, [panes]); + + const handleAddGroup = () => { + if (activeWorkspaceId) { + addTab(activeWorkspaceId); + } + }; + + const handleSelectGroup = (tabId: string) => { + if (activeWorkspaceId) { + setActiveTab(activeWorkspaceId, tabId); + } + }; + + const handleCloseGroup = (tabId: string) => { + removeTab(tabId); + }; + + if (tabs.length === 0) { + return null; + } + + return ( +
+
+ {tabs.map((tab) => ( + handleSelectGroup(tab.id)} + onClose={() => handleCloseGroup(tab.id)} + /> + ))} +
+ + + + + + New Group + + +
+ ); +} diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/index.ts new file mode 100644 index 00000000000..e905a6c8bad --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/index.ts @@ -0,0 +1 @@ +export { GroupStrip } from "./GroupStrip"; diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx new file mode 100644 index 00000000000..a9dac12d7a5 --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx @@ -0,0 +1,537 @@ +import Editor, { type OnMount } from "@monaco-editor/react"; +import { Badge } from "@superset/ui/badge"; +import { ToggleGroup, ToggleGroupItem } from "@superset/ui/toggle-group"; +import { Tooltip, TooltipContent, TooltipTrigger } from "@superset/ui/tooltip"; +import type * as Monaco from "monaco-editor"; +import { useCallback, useEffect, useRef, useState } from "react"; +import { + HiMiniLockClosed, + HiMiniLockOpen, + HiMiniPencil, + HiMiniXMark, +} from "react-icons/hi2"; +import { LuLoader } from "react-icons/lu"; +import { TbLayoutColumns, TbLayoutRows } from "react-icons/tb"; +import type { MosaicBranch } from "react-mosaic-component"; +import { MosaicWindow } from "react-mosaic-component"; +import { MarkdownRenderer } from "renderer/components/MarkdownRenderer"; +import { + monaco, + SUPERSET_THEME, + useMonacoReady, +} from "renderer/contexts/MonacoProvider"; +import { trpc } from "renderer/lib/trpc"; +import { useTabsStore } from "renderer/stores/tabs/store"; +import type { Pane } from "renderer/stores/tabs/types"; +import type { FileViewerMode } from "shared/tabs-types"; +import { DiffViewer } from "../../../ChangesContent/components/DiffViewer"; + +type SplitOrientation = "vertical" | "horizontal"; + +/** Client-side language detection for Monaco editor */ +function detectLanguage(filePath: string): string { + const ext = filePath.split(".").pop()?.toLowerCase() ?? ""; + const languageMap: Record = { + ts: "typescript", + tsx: "typescript", + js: "javascript", + jsx: "javascript", + mjs: "javascript", + cjs: "javascript", + json: "json", + md: "markdown", + mdx: "markdown", + css: "css", + scss: "scss", + less: "less", + html: "html", + xml: "xml", + yaml: "yaml", + yml: "yaml", + py: "python", + rs: "rust", + go: "go", + java: "java", + kt: "kotlin", + swift: "swift", + c: "c", + cpp: "cpp", + h: "c", + hpp: "cpp", + sh: "shell", + bash: "shell", + zsh: "shell", + sql: "sql", + graphql: "graphql", + gql: "graphql", + }; + return languageMap[ext] ?? "plaintext"; +} + +interface FileViewerPaneProps { + paneId: string; + path: MosaicBranch[]; + pane: Pane; + isActive: boolean; + tabId: string; + worktreePath: string; + splitPaneAuto: ( + tabId: string, + sourcePaneId: string, + dimensions: { width: number; height: number }, + path?: MosaicBranch[], + ) => void; + removePane: (paneId: string) => void; + setFocusedPane: (tabId: string, paneId: string) => void; +} + +export function FileViewerPane({ + paneId, + path, + pane, + isActive, + tabId, + worktreePath, + splitPaneAuto, + removePane, + setFocusedPane, +}: FileViewerPaneProps) { + const containerRef = useRef(null); + const [splitOrientation, setSplitOrientation] = + useState("vertical"); + const isMonacoReady = useMonacoReady(); + const editorRef = useRef(null); + const [isDirty, setIsDirty] = useState(false); + const originalContentRef = useRef(""); + const utils = trpc.useUtils(); + + // Track container dimensions for auto-split orientation + useEffect(() => { + const container = containerRef.current; + if (!container) return; + + const updateOrientation = () => { + const { width, height } = container.getBoundingClientRect(); + setSplitOrientation(width >= height ? "vertical" : "horizontal"); + }; + + updateOrientation(); + + const resizeObserver = new ResizeObserver(updateOrientation); + resizeObserver.observe(container); + + return () => { + resizeObserver.disconnect(); + }; + }, []); + + const fileViewer = pane.fileViewer; + + // Extract values with defaults for hooks (hooks must be called unconditionally) + const filePath = fileViewer?.filePath ?? ""; + const viewMode = fileViewer?.viewMode ?? "raw"; + const isLocked = fileViewer?.isLocked ?? false; + const diffCategory = fileViewer?.diffCategory; + const commitHash = fileViewer?.commitHash; + const oldPath = fileViewer?.oldPath; + + // Save mutation + const saveFileMutation = trpc.changes.saveFile.useMutation({ + onSuccess: () => { + setIsDirty(false); + // Update original content to current content after save + if (editorRef.current) { + originalContentRef.current = editorRef.current.getValue(); + } + // Invalidate queries to refresh data + utils.changes.readWorkingFile.invalidate(); + utils.changes.getFileContents.invalidate(); + utils.changes.getStatus.invalidate(); + }, + }); + + // Save handler for raw mode editor + const handleSaveRaw = useCallback(() => { + if (!editorRef.current || !filePath) return; + saveFileMutation.mutate({ + worktreePath, + filePath, + content: editorRef.current.getValue(), + }); + }, [worktreePath, filePath, saveFileMutation]); + + // Save handler for diff mode + const handleSaveDiff = useCallback( + (content: string) => { + if (!filePath) return; + saveFileMutation.mutate({ + worktreePath, + filePath, + content, + }); + }, + [worktreePath, filePath, saveFileMutation], + ); + + // Editor mount handler - set up Cmd+S keybinding + const handleEditorMount: OnMount = useCallback( + (editor) => { + editorRef.current = editor; + // Store original content for dirty tracking + originalContentRef.current = editor.getValue(); + + // Register save action with Cmd+S / Ctrl+S + editor.addAction({ + id: "save-file", + label: "Save File", + keybindings: [monaco.KeyMod.CtrlCmd | monaco.KeyCode.KeyS], + run: () => { + handleSaveRaw(); + }, + }); + }, + [handleSaveRaw], + ); + + // Track content changes for dirty state + const handleEditorChange = useCallback((value: string | undefined) => { + if (value !== undefined) { + setIsDirty(value !== originalContentRef.current); + } + }, []); + + // Reset dirty state when file changes + // biome-ignore lint/correctness/useExhaustiveDependencies: Reset on file change only + useEffect(() => { + setIsDirty(false); + originalContentRef.current = ""; + }, [filePath]); + + // Fetch raw file content - always call hook, use enabled to control fetching + const { data: rawFileData, isLoading: isLoadingRaw } = + trpc.changes.readWorkingFile.useQuery( + { worktreePath, filePath }, + { enabled: !!fileViewer && viewMode !== "diff" && !!filePath }, + ); + + // Fetch diff content - always call hook, use enabled to control fetching + const { data: diffData, isLoading: isLoadingDiff } = + trpc.changes.getFileContents.useQuery( + { + worktreePath, + filePath, + oldPath, + category: diffCategory ?? "unstaged", + commitHash, + }, + { + enabled: + !!fileViewer && viewMode === "diff" && !!diffCategory && !!filePath, + }, + ); + + // Early return AFTER hooks + if (!fileViewer) { + return ( + path={path} title=""> +
+ No file viewer state +
+ + ); + } + + const handleFocus = () => { + setFocusedPane(tabId, paneId); + }; + + const handleClosePane = (e: React.MouseEvent) => { + e.stopPropagation(); + removePane(paneId); + }; + + const handleSplitPane = (e: React.MouseEvent) => { + e.stopPropagation(); + const container = containerRef.current; + if (!container) return; + + const { width, height } = container.getBoundingClientRect(); + splitPaneAuto(tabId, paneId, { width, height }, path); + }; + + const handleToggleLock = () => { + // Update the pane's lock state in the store + const panes = useTabsStore.getState().panes; + const currentPane = panes[paneId]; + if (currentPane?.fileViewer) { + useTabsStore.setState({ + panes: { + ...panes, + [paneId]: { + ...currentPane, + fileViewer: { + ...currentPane.fileViewer, + isLocked: !currentPane.fileViewer.isLocked, + }, + }, + }, + }); + } + }; + + const handleViewModeChange = (value: string) => { + if (!value) return; + const newMode = value as FileViewerMode; + + // Update the pane's view mode in the store + const panes = useTabsStore.getState().panes; + const currentPane = panes[paneId]; + if (currentPane?.fileViewer) { + useTabsStore.setState({ + panes: { + ...panes, + [paneId]: { + ...currentPane, + fileViewer: { + ...currentPane.fileViewer, + viewMode: newMode, + }, + }, + }, + }); + } + }; + + const fileName = filePath.split("/").pop() || filePath; + + // Render content based on view mode + const renderContent = () => { + if (viewMode === "diff") { + if (isLoadingDiff) { + return ( +
+ Loading diff... +
+ ); + } + if (!diffData) { + return ( +
+ No diff available +
+ ); + } + return ( + + ); + } + + if (isLoadingRaw) { + return ( +
+ Loading... +
+ ); + } + + if (!rawFileData?.ok) { + const errorMessage = + rawFileData?.reason === "too-large" + ? "File is too large to preview" + : rawFileData?.reason === "binary" + ? "Binary file preview not supported" + : rawFileData?.reason === "outside-worktree" + ? "File is outside worktree" + : "File not found"; + return ( +
+ {errorMessage} +
+ ); + } + + if (viewMode === "rendered") { + return ( +
+ +
+ ); + } + + // Raw mode - editable Monaco editor + if (!isMonacoReady) { + return ( +
+ + Loading editor... +
+ ); + } + + return ( + + + Loading editor... + + } + options={{ + minimap: { enabled: false }, + scrollBeyondLastLine: false, + wordWrap: "on", + fontSize: 13, + lineHeight: 20, + fontFamily: + "ui-monospace, SFMono-Regular, SF Mono, Menlo, Consolas, Liberation Mono, monospace", + padding: { top: 8, bottom: 8 }, + scrollbar: { + verticalScrollbarSize: 8, + horizontalScrollbarSize: 8, + }, + }} + /> + ); + }; + + // Determine which view modes are available + const isMarkdown = filePath.endsWith(".md") || filePath.endsWith(".markdown"); + const hasDiff = !!diffCategory; + + const splitIcon = + splitOrientation === "vertical" ? ( + + ) : ( + + ); + + // Show editable badge for raw and diff modes (not rendered) + const showEditableBadge = viewMode !== "rendered"; + const isSaving = saveFileMutation.isPending; + + return ( + + path={path} + title="" + renderToolbar={() => ( +
+
+ + {isDirty && ●} + {fileName} + + {showEditableBadge && ( + + + {isSaving ? "Saving..." : "⌘S"} + + )} +
+
+ + {isMarkdown && ( + + Rendered + + )} + + Raw + + {hasDiff && ( + + Diff + + )} + + + + + + + Split pane + + + + + + + + {isLocked + ? "Unlock (allow file replacement)" + : "Lock (prevent file replacement)"} + + + + + + + + Close + + +
+
+ )} + className={isActive ? "mosaic-window-focused" : ""} + > + {/* biome-ignore lint/a11y/useKeyWithClickEvents lint/a11y/noStaticElementInteractions: Focus handler */} +
+ {renderContent()} +
+ + ); +} diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/index.ts new file mode 100644 index 00000000000..96c33fa0b12 --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/index.ts @@ -0,0 +1 @@ +export { FileViewerPane } from "./FileViewerPane"; diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/index.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/index.tsx index b6df3608e13..3502a82dce2 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/index.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/index.tsx @@ -8,6 +8,7 @@ import { type MosaicNode, } from "react-mosaic-component"; import { dragDropManager } from "renderer/lib/dnd"; +import { trpc } from "renderer/lib/trpc"; import { useTabsStore } from "renderer/stores/tabs/store"; import type { Pane, Tab } from "renderer/stores/tabs/types"; import { @@ -15,6 +16,7 @@ import { extractPaneIdsFromLayout, getPaneIdsForTab, } from "renderer/stores/tabs/utils"; +import { FileViewerPane } from "./FileViewerPane"; import { TabPane } from "./TabPane"; interface TabViewProps { @@ -35,6 +37,10 @@ export function TabView({ tab, panes }: TabViewProps) { const movePaneToNewTab = useTabsStore((s) => s.movePaneToNewTab); const allTabs = useTabsStore((s) => s.tabs); + // Get worktree path for file viewer panes + const { data: activeWorkspace } = trpc.workspaces.getActive.useQuery(); + const worktreePath = activeWorkspace?.worktreePath ?? ""; + // Get tabs in the same workspace for move targets const workspaceTabs = allTabs.filter( (t) => t.workspaceId === tab.workspaceId, @@ -90,6 +96,24 @@ export function TabView({ tab, panes }: TabViewProps) { ); } + // Route file-viewer panes to FileViewerPane component + if (pane.type === "file-viewer") { + return ( + + ); + } + + // Default: terminal panes return ( ; } - return ; + return ( +
+ +
+ +
+
+ ); } diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/index.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/index.tsx index 1a2e20bd0fb..835e914fc05 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/index.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/index.tsx @@ -1,11 +1,22 @@ -import { SidebarMode, useSidebarStore } from "renderer/stores"; +import { trpc } from "renderer/lib/trpc"; +import { useWorkspaceViewModeStore } from "renderer/stores/workspace-view-mode"; import { ChangesContent } from "./ChangesContent"; import { TabsContent } from "./TabsContent"; export function ContentView() { - const { currentMode } = useSidebarStore(); + const { data: activeWorkspace } = trpc.workspaces.getActive.useQuery(); + const workspaceId = activeWorkspace?.id; - if (currentMode === SidebarMode.Changes) { + // Subscribe to the actual data, not just the getter function + const viewModeByWorkspaceId = useWorkspaceViewModeStore( + (s) => s.viewModeByWorkspaceId, + ); + + const viewMode = workspaceId + ? (viewModeByWorkspaceId[workspaceId] ?? "workbench") + : "workbench"; + + if (viewMode === "review") { return (
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/ChangesView.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/ChangesView.tsx index ee0ec6d2e9c..b269533cc7f 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/ChangesView.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/ChangesView/ChangesView.tsx @@ -6,13 +6,22 @@ import { HiMiniMinus, HiMiniPlus } from "react-icons/hi2"; import { trpc } from "renderer/lib/trpc"; import { useChangesStore } from "renderer/stores/changes"; import type { ChangeCategory, ChangedFile } from "shared/changes-types"; +import { PortsList } from "../TabsView/PortsList"; import { CategorySection } from "./components/CategorySection"; import { ChangesHeader } from "./components/ChangesHeader"; import { CommitInput } from "./components/CommitInput"; import { CommitItem } from "./components/CommitItem"; import { FileList } from "./components/FileList"; -export function ChangesView() { +interface ChangesViewProps { + onFileOpen?: ( + file: ChangedFile, + category: ChangeCategory, + commitHash?: string, + ) => void; +} + +export function ChangesView({ onFileOpen }: ChangesViewProps) { const { data: activeWorkspace } = trpc.workspaces.getActive.useQuery(); const worktreePath = activeWorkspace?.worktreePath; @@ -128,11 +137,13 @@ export function ChangesView() { const handleFileSelect = (file: ChangedFile, category: ChangeCategory) => { if (!worktreePath) return; selectFile(worktreePath, file, category, null); + onFileOpen?.(file, category); }; const handleCommitFileSelect = (file: ChangedFile, commitHash: string) => { if (!worktreePath) return; selectFile(worktreePath, file, "committed", commitHash); + onFileOpen?.(file, "committed", commitHash); }; const handleCommitToggle = (hash: string) => { @@ -349,6 +360,8 @@ export function ChangesView() {
)} + +
); } diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/index.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/index.tsx index 7511587610a..b93ef1f3849 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/index.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/index.tsx @@ -1,29 +1,40 @@ -import { useSidebarStore } from "renderer/stores"; -import { SidebarMode } from "renderer/stores/sidebar-state"; +import { trpc } from "renderer/lib/trpc"; +import { useTabsStore } from "renderer/stores/tabs/store"; +import { useWorkspaceViewModeStore } from "renderer/stores/workspace-view-mode"; +import type { ChangeCategory, ChangedFile } from "shared/changes-types"; import { ChangesView } from "./ChangesView"; -import { ModeCarousel } from "./ModeCarousel"; -import { TabsView } from "./TabsView"; export function Sidebar() { - const { currentMode, setMode } = useSidebarStore(); + const { data: activeWorkspace } = trpc.workspaces.getActive.useQuery(); + const workspaceId = activeWorkspace?.id; - const modes: SidebarMode[] = [SidebarMode.Tabs, SidebarMode.Changes]; + // Subscribe to the actual data, not just the getter function + const viewModeByWorkspaceId = useWorkspaceViewModeStore( + (s) => s.viewModeByWorkspaceId, + ); + + const viewMode = workspaceId + ? (viewModeByWorkspaceId[workspaceId] ?? "workbench") + : "workbench"; + + const addFileViewerPane = useTabsStore((s) => s.addFileViewerPane); + + // In Workbench mode, open files in FileViewerPane + const handleFileOpen = + viewMode === "workbench" && workspaceId + ? (file: ChangedFile, category: ChangeCategory, commitHash?: string) => { + addFileViewerPane(workspaceId, { + filePath: file.path, + diffCategory: category, + commitHash, + oldPath: file.oldPath, + }); + } + : undefined; return ( ); } diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/WorkspaceActionBar.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/WorkspaceActionBar.tsx index f641fde5af1..526bca55e10 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/WorkspaceActionBar.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/WorkspaceActionBar.tsx @@ -1,3 +1,4 @@ +import { ViewModeToggle } from "./components/ViewModeToggle"; import { WorkspaceActionBarLeft } from "./components/WorkspaceActionBarLeft"; import { WorkspaceActionBarRight } from "./components/WorkspaceActionBarRight"; @@ -9,11 +10,14 @@ export function WorkspaceActionBar({ worktreePath }: WorkspaceActionBarProps) { if (!worktreePath) return null; return ( -
+
-
+
+ +
+
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/ViewModeToggle/ViewModeToggle.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/ViewModeToggle/ViewModeToggle.tsx new file mode 100644 index 00000000000..bce7ecd1289 --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/ViewModeToggle/ViewModeToggle.tsx @@ -0,0 +1,55 @@ +import { cn } from "@superset/ui/utils"; +import { trpc } from "renderer/lib/trpc"; +import { + useWorkspaceViewModeStore, + type WorkspaceViewMode, +} from "renderer/stores/workspace-view-mode"; + +export function ViewModeToggle() { + const { data: activeWorkspace } = trpc.workspaces.getActive.useQuery(); + const workspaceId = activeWorkspace?.id; + + const viewModeByWorkspaceId = useWorkspaceViewModeStore( + (s) => s.viewModeByWorkspaceId, + ); + const setWorkspaceViewMode = useWorkspaceViewModeStore( + (s) => s.setWorkspaceViewMode, + ); + + if (!workspaceId) return null; + + const currentMode = viewModeByWorkspaceId[workspaceId] ?? "workbench"; + + const handleModeChange = (mode: WorkspaceViewMode) => { + setWorkspaceViewMode(workspaceId, mode); + }; + + return ( +
+ + +
+ ); +} diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/ViewModeToggle/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/ViewModeToggle/index.ts new file mode 100644 index 00000000000..5e69ac17ef8 --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/ViewModeToggle/index.ts @@ -0,0 +1 @@ +export { ViewModeToggle } from "./ViewModeToggle"; diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/index.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/index.tsx index 661543c8580..a1d61bf3e53 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/index.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/index.tsx @@ -3,6 +3,7 @@ import { trpc } from "renderer/lib/trpc"; import { useAppHotkey } from "renderer/stores/hotkeys"; import { useTabsStore } from "renderer/stores/tabs/store"; import { getNextPaneId, getPreviousPaneId } from "renderer/stores/tabs/utils"; +import { useWorkspaceViewModeStore } from "renderer/stores/workspace-view-mode"; import { ContentView } from "./ContentView"; import { ResizableSidebar } from "./ResizableSidebar"; import { WorkspaceActionBar } from "./WorkspaceActionBar"; @@ -39,16 +40,31 @@ export function WorkspaceView() { // Get focused pane ID for the active tab const focusedPaneId = activeTabId ? focusedPaneIds[activeTabId] : null; + // View mode for terminal creation - subscribe to actual data for reactivity + const viewModeByWorkspaceId = useWorkspaceViewModeStore( + (s) => s.viewModeByWorkspaceId, + ); + const setWorkspaceViewMode = useWorkspaceViewModeStore( + (s) => s.setWorkspaceViewMode, + ); + const viewMode = activeWorkspaceId + ? (viewModeByWorkspaceId[activeWorkspaceId] ?? "workbench") + : "workbench"; + // Tab management shortcuts useAppHotkey( "NEW_TERMINAL", () => { if (activeWorkspaceId) { + // If in Review mode, switch to Workbench first + if (viewMode === "review") { + setWorkspaceViewMode(activeWorkspaceId, "workbench"); + } addTab(activeWorkspaceId); } }, undefined, - [activeWorkspaceId, addTab], + [activeWorkspaceId, addTab, viewMode, setWorkspaceViewMode], ); useAppHotkey( diff --git a/apps/desktop/src/renderer/stores/index.ts b/apps/desktop/src/renderer/stores/index.ts index b289f0bfb38..886d0523e00 100644 --- a/apps/desktop/src/renderer/stores/index.ts +++ b/apps/desktop/src/renderer/stores/index.ts @@ -6,3 +6,4 @@ export * from "./ringtone"; export * from "./sidebar-state"; export * from "./tabs"; export * from "./theme"; +export * from "./workspace-view-mode"; diff --git a/apps/desktop/src/renderer/stores/tabs/store.ts b/apps/desktop/src/renderer/stores/tabs/store.ts index d28d8316add..b139bf235fd 100644 --- a/apps/desktop/src/renderer/stores/tabs/store.ts +++ b/apps/desktop/src/renderer/stores/tabs/store.ts @@ -4,9 +4,10 @@ import { create } from "zustand"; import { devtools, persist } from "zustand/middleware"; import { trpcTabsStorage } from "../../lib/trpc-storage"; import { movePaneToNewTab, movePaneToTab } from "./actions/move-pane"; -import type { TabsState, TabsStore } from "./types"; +import type { AddFileViewerPaneOptions, TabsState, TabsStore } from "./types"; import { type CreatePaneOptions, + createFileViewerPane, createPane, createTabWithPane, extractPaneIdsFromLayout, @@ -340,6 +341,112 @@ export const useTabsStore = create()( return newPane.id; }, + addFileViewerPane: ( + workspaceId: string, + options: AddFileViewerPaneOptions, + ) => { + const state = get(); + const activeTabId = state.activeTabIds[workspaceId]; + const activeTab = state.tabs.find((t) => t.id === activeTabId); + + // If no active tab, create a new one (this shouldn't normally happen) + if (!activeTab) { + const { tabId, paneId } = get().addTab(workspaceId); + // Update the pane to be a file-viewer + const pane = state.panes[paneId]; + if (pane) { + const fileViewerPane = createFileViewerPane(tabId, options); + set((s) => ({ + panes: { + ...s.panes, + [paneId]: { + ...fileViewerPane, + id: paneId, // Keep the original ID + }, + }, + })); + } + return paneId; + } + + // Look for an existing unlocked file-viewer pane in the active tab + const tabPaneIds = extractPaneIdsFromLayout(activeTab.layout); + const fileViewerPanes = tabPaneIds + .map((id) => state.panes[id]) + .filter( + (p) => + p?.type === "file-viewer" && + p.fileViewer && + !p.fileViewer.isLocked, + ); + + // If we found an unlocked file-viewer pane, reuse it + if (fileViewerPanes.length > 0) { + const paneToReuse = fileViewerPanes[0]; + const fileName = + options.filePath.split("/").pop() || options.filePath; + + // Determine default view mode + let viewMode: "raw" | "rendered" | "diff" = "raw"; + if (options.diffCategory) { + viewMode = "diff"; + } else if ( + options.filePath.endsWith(".md") || + options.filePath.endsWith(".markdown") + ) { + viewMode = "rendered"; + } + + set({ + panes: { + ...state.panes, + [paneToReuse.id]: { + ...paneToReuse, + name: fileName, + fileViewer: { + filePath: options.filePath, + viewMode, + isLocked: false, + diffLayout: "inline", + diffCategory: options.diffCategory, + commitHash: options.commitHash, + oldPath: options.oldPath, + }, + }, + }, + focusedPaneIds: { + ...state.focusedPaneIds, + [activeTab.id]: paneToReuse.id, + }, + }); + + return paneToReuse.id; + } + + // No reusable pane found, create a new one + const newPane = createFileViewerPane(activeTab.id, options); + + const newLayout: MosaicNode = { + direction: "row", + first: activeTab.layout, + second: newPane.id, + splitPercentage: 50, + }; + + set({ + tabs: state.tabs.map((t) => + t.id === activeTab.id ? { ...t, layout: newLayout } : t, + ), + panes: { ...state.panes, [newPane.id]: newPane }, + focusedPaneIds: { + ...state.focusedPaneIds, + [activeTab.id]: newPane.id, + }, + }); + + return newPane.id; + }, + removePane: (paneId) => { const state = get(); const pane = state.panes[paneId]; diff --git a/apps/desktop/src/renderer/stores/tabs/types.ts b/apps/desktop/src/renderer/stores/tabs/types.ts index bcb0f70af82..03fc45d921b 100644 --- a/apps/desktop/src/renderer/stores/tabs/types.ts +++ b/apps/desktop/src/renderer/stores/tabs/types.ts @@ -1,4 +1,5 @@ import type { MosaicBranch, MosaicNode } from "react-mosaic-component"; +import type { ChangeCategory } from "shared/changes-types"; import type { BaseTab, BaseTabsState, Pane, PaneType } from "shared/tabs-types"; // Re-export shared types @@ -28,6 +29,16 @@ export interface AddTabOptions { initialCwd?: string; } +/** + * Options for opening a file in a file-viewer pane + */ +export interface AddFileViewerPaneOptions { + filePath: string; + diffCategory?: ChangeCategory; + commitHash?: string; + oldPath?: string; +} + /** * Actions available on the tabs store */ @@ -51,6 +62,10 @@ export interface TabsStore extends TabsState { // Pane operations addPane: (tabId: string, options?: AddTabOptions) => string; + addFileViewerPane: ( + workspaceId: string, + options: AddFileViewerPaneOptions, + ) => string; removePane: (paneId: string) => void; setFocusedPane: (tabId: string, paneId: string) => void; markPaneAsUsed: (paneId: string) => void; diff --git a/apps/desktop/src/renderer/stores/tabs/utils.ts b/apps/desktop/src/renderer/stores/tabs/utils.ts index a1e7bef16cf..207ac8295a7 100644 --- a/apps/desktop/src/renderer/stores/tabs/utils.ts +++ b/apps/desktop/src/renderer/stores/tabs/utils.ts @@ -1,4 +1,10 @@ import type { MosaicBranch, MosaicNode } from "react-mosaic-component"; +import type { ChangeCategory } from "shared/changes-types"; +import type { + DiffLayout, + FileViewerMode, + FileViewerState, +} from "shared/tabs-types"; import type { Pane, PaneType, Tab } from "./types"; /** @@ -82,6 +88,61 @@ export const createPane = ( }; }; +/** + * Options for creating a file-viewer pane + */ +export interface CreateFileViewerPaneOptions { + filePath: string; + viewMode?: FileViewerMode; + isLocked?: boolean; + diffLayout?: DiffLayout; + diffCategory?: ChangeCategory; + commitHash?: string; + oldPath?: string; +} + +/** + * Creates a new file-viewer pane with the given properties + */ +export const createFileViewerPane = ( + tabId: string, + options: CreateFileViewerPaneOptions, +): Pane => { + const id = generateId("pane"); + + // Determine default view mode based on file and category + let defaultViewMode: FileViewerMode = "raw"; + if (options.diffCategory) { + defaultViewMode = "diff"; + } else if ( + options.filePath.endsWith(".md") || + options.filePath.endsWith(".markdown") + ) { + defaultViewMode = "rendered"; + } + + const fileViewer: FileViewerState = { + filePath: options.filePath, + viewMode: options.viewMode ?? defaultViewMode, + isLocked: options.isLocked ?? false, + diffLayout: options.diffLayout ?? "inline", + diffCategory: options.diffCategory, + commitHash: options.commitHash, + oldPath: options.oldPath, + }; + + // Use filename for display name + const fileName = options.filePath.split("/").pop() || options.filePath; + + return { + id, + tabId, + type: "file-viewer", + name: fileName, + fileViewer, + }; +}; + /** * Generates a static tab name based on existing tabs * (e.g., "Terminal 1", "Terminal 2", finding the next available number) diff --git a/apps/desktop/src/renderer/stores/workspace-view-mode.ts b/apps/desktop/src/renderer/stores/workspace-view-mode.ts new file mode 100644 index 00000000000..b9bee9b2665 --- /dev/null +++ b/apps/desktop/src/renderer/stores/workspace-view-mode.ts @@ -0,0 +1,56 @@ +import { create } from "zustand"; +import { devtools, persist } from "zustand/middleware"; + +/** + * Workspace view modes: + * - "workbench": Groups + Mosaic panes layout for in-flow work + * - "review": Dedicated Changes page for focused code review + */ +export type WorkspaceViewMode = "workbench" | "review"; + +interface WorkspaceViewModeState { + /** + * Per-workspace view mode. Defaults to "workbench" when not set. + */ + viewModeByWorkspaceId: Record; + + /** + * Get the view mode for a workspace, defaulting to "workbench" + */ + getWorkspaceViewMode: (workspaceId: string) => WorkspaceViewMode; + + /** + * Set the view mode for a workspace + */ + setWorkspaceViewMode: (workspaceId: string, mode: WorkspaceViewMode) => void; +} + +export const useWorkspaceViewModeStore = create()( + devtools( + persist( + (set, get) => ({ + viewModeByWorkspaceId: {}, + + getWorkspaceViewMode: (workspaceId: string) => { + return get().viewModeByWorkspaceId[workspaceId] ?? "workbench"; + }, + + setWorkspaceViewMode: ( + workspaceId: string, + mode: WorkspaceViewMode, + ) => { + set((state) => ({ + viewModeByWorkspaceId: { + ...state.viewModeByWorkspaceId, + [workspaceId]: mode, + }, + })); + }, + }), + { + name: "workspace-view-mode-store", + }, + ), + { name: "WorkspaceViewModeStore" }, + ), +); diff --git a/apps/desktop/src/shared/tabs-types.ts b/apps/desktop/src/shared/tabs-types.ts index 8ae323601eb..d38ce4c4284 100644 --- a/apps/desktop/src/shared/tabs-types.ts +++ b/apps/desktop/src/shared/tabs-types.ts @@ -3,10 +3,42 @@ * Renderer extends these with MosaicNode layout specifics. */ +import type { ChangeCategory } from "./changes-types"; + /** * Pane types that can be displayed within a tab */ -export type PaneType = "terminal" | "webview"; +export type PaneType = "terminal" | "webview" | "file-viewer"; + +/** + * File viewer display modes + */ +export type FileViewerMode = "rendered" | "raw" | "diff"; + +/** + * Diff layout options for file viewer + */ +export type DiffLayout = "inline" | "side-by-side"; + +/** + * File viewer pane-specific properties + */ +export interface FileViewerState { + /** Worktree-relative file path */ + filePath: string; + /** Display mode: rendered (markdown), raw (source), or diff */ + viewMode: FileViewerMode; + /** If true, this pane won't be reused for new file clicks */ + isLocked: boolean; + /** Diff display layout */ + diffLayout: DiffLayout; + /** Category for diff source (against-main, committed, staged, unstaged) */ + diffCategory?: ChangeCategory; + /** Commit hash for committed category diffs */ + commitHash?: string; + /** Original path for renamed files */ + oldPath?: string; +} /** * Base Pane interface - shared between main and renderer @@ -23,6 +55,7 @@ export interface Pane { url?: string; // For webview panes cwd?: string | null; // Current working directory cwdConfirmed?: boolean; // True if cwd confirmed via OSC-7, false if seeded + fileViewer?: FileViewerState; // For file-viewer panes } /** From 0d91d554d99fac1dc31bebdd1d91cfb3270676b5 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Mon, 29 Dec 2025 18:32:50 +0200 Subject: [PATCH 02/98] fix(desktop): add worktreePath guards and fix stale state in tabs store - Add !!worktreePath checks to FileViewerPane query enabled conditions - Add !!worktreePath checks to save handler guards (handleSaveRaw, handleSaveDiff) - Fix stale state reference after addTab() in addFileViewerPane action Addresses CodeRabbit review feedback. --- .../TabView/FileViewerPane/FileViewerPane.tsx | 15 ++++++++---- .../desktop/src/renderer/stores/tabs/store.ts | 23 ++++++++----------- 2 files changed, 21 insertions(+), 17 deletions(-) diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx index a9dac12d7a5..a607ed7b184 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx @@ -152,7 +152,7 @@ export function FileViewerPane({ // Save handler for raw mode editor const handleSaveRaw = useCallback(() => { - if (!editorRef.current || !filePath) return; + if (!editorRef.current || !filePath || !worktreePath) return; saveFileMutation.mutate({ worktreePath, filePath, @@ -163,7 +163,7 @@ export function FileViewerPane({ // Save handler for diff mode const handleSaveDiff = useCallback( (content: string) => { - if (!filePath) return; + if (!filePath || !worktreePath) return; saveFileMutation.mutate({ worktreePath, filePath, @@ -211,7 +211,10 @@ export function FileViewerPane({ const { data: rawFileData, isLoading: isLoadingRaw } = trpc.changes.readWorkingFile.useQuery( { worktreePath, filePath }, - { enabled: !!fileViewer && viewMode !== "diff" && !!filePath }, + { + enabled: + !!fileViewer && viewMode !== "diff" && !!filePath && !!worktreePath, + }, ); // Fetch diff content - always call hook, use enabled to control fetching @@ -226,7 +229,11 @@ export function FileViewerPane({ }, { enabled: - !!fileViewer && viewMode === "diff" && !!diffCategory && !!filePath, + !!fileViewer && + viewMode === "diff" && + !!diffCategory && + !!filePath && + !!worktreePath, }, ); diff --git a/apps/desktop/src/renderer/stores/tabs/store.ts b/apps/desktop/src/renderer/stores/tabs/store.ts index b139bf235fd..ee1943fe7a7 100644 --- a/apps/desktop/src/renderer/stores/tabs/store.ts +++ b/apps/desktop/src/renderer/stores/tabs/store.ts @@ -352,20 +352,17 @@ export const useTabsStore = create()( // If no active tab, create a new one (this shouldn't normally happen) if (!activeTab) { const { tabId, paneId } = get().addTab(workspaceId); - // Update the pane to be a file-viewer - const pane = state.panes[paneId]; - if (pane) { - const fileViewerPane = createFileViewerPane(tabId, options); - set((s) => ({ - panes: { - ...s.panes, - [paneId]: { - ...fileViewerPane, - id: paneId, // Keep the original ID - }, + // Update the pane to be a file-viewer (must use set() to get fresh state after addTab) + const fileViewerPane = createFileViewerPane(tabId, options); + set((s) => ({ + panes: { + ...s.panes, + [paneId]: { + ...fileViewerPane, + id: paneId, // Keep the original ID }, - })); - } + }, + })); return paneId; } From 530a423d3e07e601937f519782abee5eabd78e78 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Mon, 29 Dec 2025 18:50:33 +0200 Subject: [PATCH 03/98] fix(desktop): address CodeRabbit review - path traversal security fix and UX improvements - Add validatePathForWrite() to prevent path traversal attacks in saveFile - Add aria-pressed attribute to ViewModeToggle buttons for accessibility - Increase close button touch target in GroupStrip for better UX - Add .mdx file support for rendered view mode --- .../lib/trpc/routers/changes/file-contents.ts | 62 ++++++++++++++++++- .../TabsContent/GroupStrip/GroupStrip.tsx | 4 +- .../ViewModeToggle/ViewModeToggle.tsx | 2 + .../desktop/src/renderer/stores/tabs/store.ts | 3 +- .../desktop/src/renderer/stores/tabs/utils.ts | 3 +- 5 files changed, 67 insertions(+), 7 deletions(-) diff --git a/apps/desktop/src/lib/trpc/routers/changes/file-contents.ts b/apps/desktop/src/lib/trpc/routers/changes/file-contents.ts index 29f035a058f..262a03797f1 100644 --- a/apps/desktop/src/lib/trpc/routers/changes/file-contents.ts +++ b/apps/desktop/src/lib/trpc/routers/changes/file-contents.ts @@ -23,7 +23,8 @@ type ReadWorkingFileResult = }; /** - * Validates that a file path is within the worktree and doesn't escape via symlinks + * Validates that a file path is within the worktree and doesn't escape via symlinks. + * Requires the file to exist (uses realpath). */ async function validatePathInWorktree( worktreePath: string, @@ -60,6 +61,48 @@ async function validatePathInWorktree( } } +/** + * Validates that a file path is safe for writing within the worktree. + * Does not require the file to exist (validates path structure and parent directory). + */ +async function validatePathForWrite( + worktreePath: string, + filePath: string, +): Promise<{ valid: boolean; resolvedPath?: string; reason?: string }> { + // Reject absolute paths + if (isAbsolute(filePath)) { + return { valid: false, reason: "outside-worktree" }; + } + + // Normalize and check for traversal + const normalizedPath = normalize(filePath); + if (normalizedPath.startsWith("..") || normalizedPath.includes("/../")) { + return { valid: false, reason: "outside-worktree" }; + } + + const fullPath = join(worktreePath, normalizedPath); + + // Resolve the worktree path and verify our target path is within it + try { + const realWorktreePath = await realpath(worktreePath); + + // For writes, we can't realpath the file (it may not exist), but we can check + // the normalized path structure is within the worktree + const candidatePath = join(realWorktreePath, normalizedPath); + const relativePath = relative(realWorktreePath, candidatePath); + + // If relative path starts with "..", the file is outside worktree + if (relativePath.startsWith("..") || isAbsolute(relativePath)) { + return { valid: false, reason: "outside-worktree" }; + } + + return { valid: true, resolvedPath: candidatePath }; + } catch { + // Worktree path doesn't exist or isn't accessible + return { valid: false, reason: "not-found" }; + } +} + /** * Detects if a buffer contains binary content by checking for NUL bytes */ @@ -117,8 +160,21 @@ export const createFileContentsRouter = () => { }), ) .mutation(async ({ input }): Promise<{ success: boolean }> => { - const fullPath = join(input.worktreePath, input.filePath); - await writeFile(fullPath, input.content, "utf-8"); + // Validate path is within worktree (prevents path traversal attacks) + const validation = await validatePathForWrite( + input.worktreePath, + input.filePath, + ); + + if (!validation.valid || !validation.resolvedPath) { + throw new Error( + validation.reason === "outside-worktree" + ? "Cannot write to files outside worktree" + : "File path validation failed", + ); + } + + await writeFile(validation.resolvedPath, input.content, "utf-8"); return { success: true }; }), diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx index e4aa4e47352..162114e9687 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx @@ -55,9 +55,9 @@ function GroupItem({ e.stopPropagation(); onClose(); }} - className="absolute -right-1 -top-1 p-0.5 rounded-full bg-muted opacity-0 group-hover:opacity-100 transition-opacity hover:bg-destructive hover:text-destructive-foreground" + className="absolute -right-1.5 -top-1.5 p-1 rounded-full bg-muted opacity-0 group-hover:opacity-100 transition-opacity hover:bg-destructive hover:text-destructive-foreground" > - +
); diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/ViewModeToggle/ViewModeToggle.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/ViewModeToggle/ViewModeToggle.tsx index bce7ecd1289..00b93eaf6dc 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/ViewModeToggle/ViewModeToggle.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/ViewModeToggle/ViewModeToggle.tsx @@ -29,6 +29,7 @@ export function ViewModeToggle() {
); diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index 20a261a4d85..4c67aba85b0 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -5,6 +5,7 @@ import "@xterm/xterm/css/xterm.css"; import debounce from "lodash/debounce"; import { useCallback, useEffect, useRef, useState } from "react"; import { trpc } from "renderer/lib/trpc"; +import { trpcClient } from "renderer/lib/trpc-client"; import { useAppHotkey } from "renderer/stores/hotkeys"; import { useTabsStore } from "renderer/stores/tabs/store"; import { useTerminalCallbacksStore } from "renderer/stores/tabs/terminal-callbacks"; @@ -47,6 +48,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const setTabAutoTitle = useTabsStore((s) => s.setTabAutoTitle); const updatePaneCwd = useTabsStore((s) => s.updatePaneCwd); const focusedPaneIds = useTabsStore((s) => s.focusedPaneIds); + const addFileViewerPane = useTabsStore((s) => s.addFileViewerPane); const terminalTheme = useTerminalTheme(); // Ref for initial theme to avoid recreating terminal on theme change @@ -68,6 +70,41 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const { data: workspaceCwd } = trpc.terminal.getWorkspaceCwd.useQuery(workspaceId); + // Query terminal link behavior setting + const { data: terminalLinkBehavior } = + trpc.settings.getTerminalLinkBehavior.useQuery(); + + // Handler for file link clicks - uses current setting value + const handleFileLinkClick = useCallback( + (path: string, line?: number, column?: number) => { + const behavior = terminalLinkBehavior ?? "external-editor"; + + if (behavior === "file-viewer") { + addFileViewerPane(workspaceId, { filePath: path }); + } else { + trpcClient.external.openFileInEditor + .mutate({ + path, + line, + column, + cwd: workspaceCwd ?? undefined, + }) + .catch((error) => { + console.error( + "[Terminal] Failed to open file in editor:", + path, + error, + ); + }); + } + }, + [terminalLinkBehavior, workspaceId, workspaceCwd, addFileViewerPane], + ); + + // Ref to avoid terminal recreation when callback changes + const handleFileLinkClickRef = useRef(handleFileLinkClick); + handleFileLinkClickRef.current = handleFileLinkClick; + // Seed cwd from initialCwd or workspace path (shell spawns there) // OSC-7 will override if/when the shell reports directory changes useEffect(() => { @@ -197,11 +234,12 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { xterm, fitAddon, cleanup: cleanupQuerySuppression, - } = createTerminalInstance( - container, - workspaceCwd, - initialThemeRef.current, - ); + } = createTerminalInstance(container, { + cwd: workspaceCwd, + initialTheme: initialThemeRef.current, + onFileLinkClick: (path, line, column) => + handleFileLinkClickRef.current(path, line, column), + }); xtermRef.current = xterm; fitAddonRef.current = fitAddon; isExitedRef.current = false; diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/helpers.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/helpers.ts index 6058503b816..89473cdf9d6 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/helpers.ts +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/helpers.ts @@ -92,19 +92,26 @@ function loadRenderer(xterm: XTerm): { dispose: () => void } { }; } +export interface CreateTerminalOptions { + cwd?: string; + initialTheme?: ITheme | null; + onFileLinkClick?: (path: string, line?: number, column?: number) => void; +} + export function createTerminalInstance( container: HTMLDivElement, - cwd?: string, - initialTheme?: ITheme | null, + options: CreateTerminalOptions = {}, ): { xterm: XTerm; fitAddon: FitAddon; cleanup: () => void; } { + const { cwd, initialTheme, onFileLinkClick } = options; + // Use provided theme, or fall back to localStorage-based default to prevent flash const theme = initialTheme ?? getDefaultTerminalTheme(); - const options = { ...TERMINAL_OPTIONS, theme }; - const xterm = new XTerm(options); + const terminalOptions = { ...TERMINAL_OPTIONS, theme }; + const xterm = new XTerm(terminalOptions); const fitAddon = new FitAddon(); const clipboardAddon = new ClipboardAddon(); @@ -142,20 +149,25 @@ export function createTerminalInstance( const filePathLinkProvider = new FilePathLinkProvider( xterm, (_event, path, line, column) => { - trpcClient.external.openFileInEditor - .mutate({ - path, - line, - column, - cwd, - }) - .catch((error) => { - console.error( - "[Terminal] Failed to open file in editor:", + if (onFileLinkClick) { + onFileLinkClick(path, line, column); + } else { + // Fallback to default behavior (external editor) + trpcClient.external.openFileInEditor + .mutate({ path, - error, - ); - }); + line, + column, + cwd, + }) + .catch((error) => { + console.error( + "[Terminal] Failed to open file in editor:", + path, + error, + ); + }); + } }, ); xterm.registerLinkProvider(filePathLinkProvider); diff --git a/apps/desktop/src/shared/constants.ts b/apps/desktop/src/shared/constants.ts index 6bc788cead4..1ec904ae1fc 100644 --- a/apps/desktop/src/shared/constants.ts +++ b/apps/desktop/src/shared/constants.ts @@ -46,3 +46,4 @@ export const NOTIFICATION_EVENTS = { // Default user preference values export const DEFAULT_CONFIRM_ON_QUIT = true; +export const DEFAULT_TERMINAL_LINK_BEHAVIOR = "external-editor" as const; diff --git a/packages/local-db/drizzle/0004_add_terminal_link_behavior_setting.sql b/packages/local-db/drizzle/0004_add_terminal_link_behavior_setting.sql new file mode 100644 index 00000000000..ad70f21f3fe --- /dev/null +++ b/packages/local-db/drizzle/0004_add_terminal_link_behavior_setting.sql @@ -0,0 +1 @@ +ALTER TABLE `settings` ADD `terminal_link_behavior` text; \ No newline at end of file diff --git a/packages/local-db/drizzle/meta/0004_snapshot.json b/packages/local-db/drizzle/meta/0004_snapshot.json new file mode 100644 index 00000000000..991b5469eb5 --- /dev/null +++ b/packages/local-db/drizzle/meta/0004_snapshot.json @@ -0,0 +1,977 @@ +{ + "version": "6", + "dialect": "sqlite", + "id": "bb9f9f85-bcbb-4003-b20f-4c172a1c6fc8", + "prevId": "d5a52ac9-bc1e-4529-89bf-5748d4df5006", + "tables": { + "organization_members": { + "name": "organization_members", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "organization_id": { + "name": "organization_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "user_id": { + "name": "user_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "role": { + "name": "role", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + } + }, + "indexes": { + "organization_members_organization_id_idx": { + "name": "organization_members_organization_id_idx", + "columns": [ + "organization_id" + ], + "isUnique": false + }, + "organization_members_user_id_idx": { + "name": "organization_members_user_id_idx", + "columns": [ + "user_id" + ], + "isUnique": false + } + }, + "foreignKeys": { + "organization_members_organization_id_organizations_id_fk": { + "name": "organization_members_organization_id_organizations_id_fk", + "tableFrom": "organization_members", + "tableTo": "organizations", + "columnsFrom": [ + "organization_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + }, + "organization_members_user_id_users_id_fk": { + "name": "organization_members_user_id_users_id_fk", + "tableFrom": "organization_members", + "tableTo": "users", + "columnsFrom": [ + "user_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "organizations": { + "name": "organizations", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "clerk_org_id": { + "name": "clerk_org_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "name": { + "name": "name", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "slug": { + "name": "slug", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "github_org": { + "name": "github_org", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "avatar_url": { + "name": "avatar_url", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "updated_at": { + "name": "updated_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + } + }, + "indexes": { + "organizations_clerk_org_id_unique": { + "name": "organizations_clerk_org_id_unique", + "columns": [ + "clerk_org_id" + ], + "isUnique": true + }, + "organizations_slug_unique": { + "name": "organizations_slug_unique", + "columns": [ + "slug" + ], + "isUnique": true + }, + "organizations_slug_idx": { + "name": "organizations_slug_idx", + "columns": [ + "slug" + ], + "isUnique": false + }, + "organizations_clerk_org_id_idx": { + "name": "organizations_clerk_org_id_idx", + "columns": [ + "clerk_org_id" + ], + "isUnique": false + } + }, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "projects": { + "name": "projects", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "main_repo_path": { + "name": "main_repo_path", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "name": { + "name": "name", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "color": { + "name": "color", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "tab_order": { + "name": "tab_order", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "last_opened_at": { + "name": "last_opened_at", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "config_toast_dismissed": { + "name": "config_toast_dismissed", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "default_branch": { + "name": "default_branch", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + } + }, + "indexes": { + "projects_main_repo_path_idx": { + "name": "projects_main_repo_path_idx", + "columns": [ + "main_repo_path" + ], + "isUnique": false + }, + "projects_last_opened_at_idx": { + "name": "projects_last_opened_at_idx", + "columns": [ + "last_opened_at" + ], + "isUnique": false + } + }, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "settings": { + "name": "settings", + "columns": { + "id": { + "name": "id", + "type": "integer", + "primaryKey": true, + "notNull": true, + "autoincrement": false, + "default": 1 + }, + "last_active_workspace_id": { + "name": "last_active_workspace_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "last_used_app": { + "name": "last_used_app", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "terminal_presets": { + "name": "terminal_presets", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "terminal_presets_initialized": { + "name": "terminal_presets_initialized", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "selected_ringtone_id": { + "name": "selected_ringtone_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "active_organization_id": { + "name": "active_organization_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "confirm_on_quit": { + "name": "confirm_on_quit", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "terminal_link_behavior": { + "name": "terminal_link_behavior", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + } + }, + "indexes": {}, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "tasks": { + "name": "tasks", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "slug": { + "name": "slug", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "title": { + "name": "title", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "description": { + "name": "description", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "status": { + "name": "status", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "status_color": { + "name": "status_color", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "status_type": { + "name": "status_type", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "status_position": { + "name": "status_position", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "priority": { + "name": "priority", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "organization_id": { + "name": "organization_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "repository_id": { + "name": "repository_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "assignee_id": { + "name": "assignee_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "creator_id": { + "name": "creator_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "estimate": { + "name": "estimate", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "due_date": { + "name": "due_date", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "labels": { + "name": "labels", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "branch": { + "name": "branch", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "pr_url": { + "name": "pr_url", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "external_provider": { + "name": "external_provider", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "external_id": { + "name": "external_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "external_key": { + "name": "external_key", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "external_url": { + "name": "external_url", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "last_synced_at": { + "name": "last_synced_at", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "sync_error": { + "name": "sync_error", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "started_at": { + "name": "started_at", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "completed_at": { + "name": "completed_at", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "deleted_at": { + "name": "deleted_at", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "updated_at": { + "name": "updated_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + } + }, + "indexes": { + "tasks_slug_unique": { + "name": "tasks_slug_unique", + "columns": [ + "slug" + ], + "isUnique": true + }, + "tasks_slug_idx": { + "name": "tasks_slug_idx", + "columns": [ + "slug" + ], + "isUnique": false + }, + "tasks_organization_id_idx": { + "name": "tasks_organization_id_idx", + "columns": [ + "organization_id" + ], + "isUnique": false + }, + "tasks_assignee_id_idx": { + "name": "tasks_assignee_id_idx", + "columns": [ + "assignee_id" + ], + "isUnique": false + }, + "tasks_status_idx": { + "name": "tasks_status_idx", + "columns": [ + "status" + ], + "isUnique": false + }, + "tasks_created_at_idx": { + "name": "tasks_created_at_idx", + "columns": [ + "created_at" + ], + "isUnique": false + } + }, + "foreignKeys": { + "tasks_organization_id_organizations_id_fk": { + "name": "tasks_organization_id_organizations_id_fk", + "tableFrom": "tasks", + "tableTo": "organizations", + "columnsFrom": [ + "organization_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + }, + "tasks_assignee_id_users_id_fk": { + "name": "tasks_assignee_id_users_id_fk", + "tableFrom": "tasks", + "tableTo": "users", + "columnsFrom": [ + "assignee_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "set null", + "onUpdate": "no action" + }, + "tasks_creator_id_users_id_fk": { + "name": "tasks_creator_id_users_id_fk", + "tableFrom": "tasks", + "tableTo": "users", + "columnsFrom": [ + "creator_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "users": { + "name": "users", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "clerk_id": { + "name": "clerk_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "name": { + "name": "name", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "email": { + "name": "email", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "avatar_url": { + "name": "avatar_url", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "deleted_at": { + "name": "deleted_at", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "updated_at": { + "name": "updated_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + } + }, + "indexes": { + "users_clerk_id_unique": { + "name": "users_clerk_id_unique", + "columns": [ + "clerk_id" + ], + "isUnique": true + }, + "users_email_unique": { + "name": "users_email_unique", + "columns": [ + "email" + ], + "isUnique": true + }, + "users_email_idx": { + "name": "users_email_idx", + "columns": [ + "email" + ], + "isUnique": false + }, + "users_clerk_id_idx": { + "name": "users_clerk_id_idx", + "columns": [ + "clerk_id" + ], + "isUnique": false + } + }, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "workspaces": { + "name": "workspaces", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "project_id": { + "name": "project_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "worktree_id": { + "name": "worktree_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "type": { + "name": "type", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "branch": { + "name": "branch", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "name": { + "name": "name", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "tab_order": { + "name": "tab_order", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "updated_at": { + "name": "updated_at", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "last_opened_at": { + "name": "last_opened_at", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + } + }, + "indexes": { + "workspaces_project_id_idx": { + "name": "workspaces_project_id_idx", + "columns": [ + "project_id" + ], + "isUnique": false + }, + "workspaces_worktree_id_idx": { + "name": "workspaces_worktree_id_idx", + "columns": [ + "worktree_id" + ], + "isUnique": false + }, + "workspaces_last_opened_at_idx": { + "name": "workspaces_last_opened_at_idx", + "columns": [ + "last_opened_at" + ], + "isUnique": false + } + }, + "foreignKeys": { + "workspaces_project_id_projects_id_fk": { + "name": "workspaces_project_id_projects_id_fk", + "tableFrom": "workspaces", + "tableTo": "projects", + "columnsFrom": [ + "project_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + }, + "workspaces_worktree_id_worktrees_id_fk": { + "name": "workspaces_worktree_id_worktrees_id_fk", + "tableFrom": "workspaces", + "tableTo": "worktrees", + "columnsFrom": [ + "worktree_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "worktrees": { + "name": "worktrees", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "project_id": { + "name": "project_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "path": { + "name": "path", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "branch": { + "name": "branch", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "base_branch": { + "name": "base_branch", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "git_status": { + "name": "git_status", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "github_status": { + "name": "github_status", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + } + }, + "indexes": { + "worktrees_project_id_idx": { + "name": "worktrees_project_id_idx", + "columns": [ + "project_id" + ], + "isUnique": false + }, + "worktrees_branch_idx": { + "name": "worktrees_branch_idx", + "columns": [ + "branch" + ], + "isUnique": false + } + }, + "foreignKeys": { + "worktrees_project_id_projects_id_fk": { + "name": "worktrees_project_id_projects_id_fk", + "tableFrom": "worktrees", + "tableTo": "projects", + "columnsFrom": [ + "project_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + } + }, + "views": {}, + "enums": {}, + "_meta": { + "schemas": {}, + "tables": {}, + "columns": {} + }, + "internal": { + "indexes": {} + } +} \ No newline at end of file diff --git a/packages/local-db/drizzle/meta/_journal.json b/packages/local-db/drizzle/meta/_journal.json index 3117a6e2266..65dc59e762b 100644 --- a/packages/local-db/drizzle/meta/_journal.json +++ b/packages/local-db/drizzle/meta/_journal.json @@ -29,6 +29,13 @@ "when": 1766932805546, "tag": "0003_add_confirm_on_quit_setting", "breakpoints": true + }, + { + "idx": 4, + "version": "6", + "when": 1767166138761, + "tag": "0004_add_terminal_link_behavior_setting", + "breakpoints": true } ] } \ No newline at end of file diff --git a/packages/local-db/src/schema/schema.ts b/packages/local-db/src/schema/schema.ts index 9b0639805f0..0f98d17ada9 100644 --- a/packages/local-db/src/schema/schema.ts +++ b/packages/local-db/src/schema/schema.ts @@ -5,6 +5,7 @@ import type { ExternalApp, GitHubStatus, GitStatus, + TerminalLinkBehavior, TerminalPreset, WorkspaceType, } from "./zod"; @@ -127,6 +128,9 @@ export const settings = sqliteTable("settings", { selectedRingtoneId: text("selected_ringtone_id"), activeOrganizationId: text("active_organization_id"), confirmOnQuit: integer("confirm_on_quit", { mode: "boolean" }), + terminalLinkBehavior: text( + "terminal_link_behavior", + ).$type(), }); export type InsertSettings = typeof settings.$inferInsert; diff --git a/packages/local-db/src/schema/zod.ts b/packages/local-db/src/schema/zod.ts index bb33e1d1596..ca8221e405d 100644 --- a/packages/local-db/src/schema/zod.ts +++ b/packages/local-db/src/schema/zod.ts @@ -96,3 +96,13 @@ export const EXTERNAL_APPS = [ ] as const; export type ExternalApp = (typeof EXTERNAL_APPS)[number]; + +/** + * Terminal link behavior options + */ +export const TERMINAL_LINK_BEHAVIORS = [ + "external-editor", + "file-viewer", +] as const; + +export type TerminalLinkBehavior = (typeof TERMINAL_LINK_BEHAVIORS)[number]; From 0bfdbe6ee5ef3415c847306933576b7c9ff9d7e3 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Wed, 31 Dec 2025 09:35:50 +0200 Subject: [PATCH 14/98] refactor(desktop): simplify security - remove symlink escape detection Remove async symlink escape detection from path validation since the threat model doesn't justify it: a compromised renderer already has terminal access for arbitrary command execution. Changes: - Replace resolveSecurePath (async) with resolvePathInWorktree (sync) - Remove assertNoSymlinkEscape and checkSymlinks option - Add validateRelativePath for simple path safety checks - Update secure-fs.ts to use new sync functions - Update threat model documentation in path-validation.ts --- .../trpc/routers/changes/security/index.ts | 17 +- .../changes/security/path-validation.ts | 219 ++++++------------ .../routers/changes/security/secure-fs.ts | 62 ++--- 3 files changed, 94 insertions(+), 204 deletions(-) diff --git a/apps/desktop/src/lib/trpc/routers/changes/security/index.ts b/apps/desktop/src/lib/trpc/routers/changes/security/index.ts index b2763809771..8fdb09c9e7a 100644 --- a/apps/desktop/src/lib/trpc/routers/changes/security/index.ts +++ b/apps/desktop/src/lib/trpc/routers/changes/security/index.ts @@ -1,13 +1,11 @@ /** * Security module for changes routers. * - * This module provides: - * - Path validation with symlink escape protection - * - Secure filesystem wrappers - * - Worktree registration checks + * Security model: + * - PRIMARY: Worktree must be registered in localDb + * - SECONDARY: Paths validated for traversal attempts * - * All filesystem operations in the changes routers should go through - * this module to ensure consistent security checks. + * See path-validation.ts header for full threat model. */ export { @@ -18,13 +16,16 @@ export { gitUnstageAll, gitUnstageFile, } from "./git-commands"; + export { assertRegisteredWorktree, assertValidGitPath, getRegisteredWorktree, PathValidationError, type PathValidationErrorCode, - type ResolveSecurePathOptions, - resolveSecurePath, + resolvePathInWorktree, + type ValidatePathOptions, + validateRelativePath, } from "./path-validation"; + export { secureFs } from "./secure-fs"; diff --git a/apps/desktop/src/lib/trpc/routers/changes/security/path-validation.ts b/apps/desktop/src/lib/trpc/routers/changes/security/path-validation.ts index 675f209f030..72292859b02 100644 --- a/apps/desktop/src/lib/trpc/routers/changes/security/path-validation.ts +++ b/apps/desktop/src/lib/trpc/routers/changes/security/path-validation.ts @@ -1,23 +1,40 @@ -import { realpath } from "node:fs/promises"; -import { - dirname, - isAbsolute, - normalize, - relative, - resolve, - sep, -} from "node:path"; +import { isAbsolute, normalize, resolve, sep } from "node:path"; import { worktrees } from "@superset/local-db"; import { eq } from "drizzle-orm"; import { localDb } from "main/lib/local-db"; +/** + * Security model for desktop app filesystem access: + * + * THREAT MODEL ASSUMPTION: + * A compromised renderer can already execute arbitrary commands via + * terminal panes. Therefore, filesystem-level symlink protections + * provide no meaningful security boundary—an attacker with renderer + * access can simply run `cat /etc/passwd` in a terminal. + * + * If your deployment exposes the renderer to untrusted content WITHOUT + * terminal access, this model does NOT apply and symlink escape checks + * should be re-enabled. + * + * PRIMARY BOUNDARY: assertRegisteredWorktree() + * - Only worktree paths registered in localDb are accessible via tRPC + * - Prevents direct filesystem access to unregistered paths + * + * SECONDARY: validateRelativePath() + * - Rejects absolute paths and ".." traversal segments + * - Defense in depth against path manipulation + * + * NOT IMPLEMENTED (intentional, see threat model above): + * - Symlink escape detection + * - Realpath resolution + */ + /** * Security error codes for path validation failures. */ export type PathValidationErrorCode = | "ABSOLUTE_PATH" | "PATH_TRAVERSAL" - | "SYMLINK_ESCAPE" | "UNREGISTERED_WORKTREE" | "INVALID_TARGET"; @@ -37,9 +54,7 @@ export class PathValidationError extends Error { /** * Validates that a worktree path is registered in localDb. - * - * This is THE critical security boundary - prevents arbitrary filesystem access. - * A compromised renderer cannot access files outside registered worktrees. + * This is THE critical security boundary. * * @throws PathValidationError if worktree is not registered */ @@ -59,8 +74,7 @@ export function assertRegisteredWorktree(worktreePath: string): void { } /** - * Gets the worktree record if it exists in localDb. - * Returns the record for additional operations (e.g., updating branch). + * Gets the worktree record if registered. Returns record for updates. * * @throws PathValidationError if worktree is not registered */ @@ -84,86 +98,9 @@ export function getRegisteredWorktree( } /** - * Checks if a relative path escapes its parent directory. - * - * Uses the correct segment-aware check: - * - `..` alone escapes - * - `../anything` escapes - * - `..foo` does NOT escape (legitimate directory name) - */ -function escapesParent(relativePath: string): boolean { - return ( - relativePath === ".." || - relativePath.startsWith(`..${sep}`) || - isAbsolute(relativePath) - ); -} - -/** - * Validates a file path doesn't escape the worktree via symlinks. - * - * Handles new files by walking up to find the first existing ancestor - * and validating that ancestor is within the worktree. - * - * @throws PathValidationError if symlink escape detected or validation fails + * Options for path validation. */ -async function assertNoSymlinkEscape( - worktreePath: string, - fullPath: string, -): Promise { - const realWorktree = await realpath(worktreePath); - - // Walk up to find first existing ancestor - let checkPath = fullPath; - const root = resolve("/"); - - while (checkPath !== root) { - try { - const realPath = await realpath(checkPath); - const rel = relative(realWorktree, realPath); - - if (escapesParent(rel)) { - throw new PathValidationError( - "Path escapes worktree via symlink", - "SYMLINK_ESCAPE", - ); - } - - // Found existing path and validated it - we're done - return; - } catch (e) { - if (e instanceof PathValidationError) { - throw e; - } - - if ((e as NodeJS.ErrnoException).code === "ENOENT") { - // Path doesn't exist, check parent - const parent = dirname(checkPath); - if (parent === checkPath) { - // Hit filesystem root without finding existing path - // This shouldn't happen for valid worktree paths - break; - } - checkPath = parent; - continue; - } - - // For any other error (permissions, etc.), fail closed - throw new PathValidationError( - `Cannot verify path security: ${(e as Error).message}`, - "SYMLINK_ESCAPE", - ); - } - } -} - -export interface ResolveSecurePathOptions { - /** - * Check for symlink escapes. Required for destructive operations. - * Default: true (fail closed) - */ - checkSymlinks?: boolean; - +export interface ValidatePathOptions { /** * Allow empty/root path (resolves to worktree itself). * Default: false (prevents accidental worktree deletion) @@ -172,31 +109,18 @@ export interface ResolveSecurePathOptions { } /** - * Validates and resolves a file path within a worktree. - * - * Security checks: - * 1. Rejects absolute paths - * 2. Rejects path traversal via `..` segments - * 3. Rejects symlink escapes (by default) - * 4. Rejects root path unless explicitly allowed + * Validates a relative file path for safety. + * Rejects absolute paths and path traversal attempts. * - * Uses `path.relative()` containment check - the industry standard pattern - * from VSCode, MCP servers, and security-focused libraries. - * - * @param worktreePath - The registered worktree base path - * @param filePath - The relative file path to validate - * @param options - Validation options - * @returns The resolved full path - * @throws PathValidationError on any validation failure + * @throws PathValidationError if path is invalid */ -export async function resolveSecurePath( - worktreePath: string, +export function validateRelativePath( filePath: string, - options: ResolveSecurePathOptions = {}, -): Promise { - const { checkSymlinks = true, allowRoot = false } = options; + options: ValidatePathOptions = {}, +): void { + const { allowRoot = false } = options; - // 1. Reject absolute paths immediately + // Reject absolute paths if (isAbsolute(filePath)) { throw new PathValidationError( "Absolute paths are not allowed", @@ -204,61 +128,50 @@ export async function resolveSecurePath( ); } - // 2. Normalize and resolve const normalized = normalize(filePath); - const fullPath = resolve(worktreePath, normalized); - - // 3. Containment check via relative path - const relativePath = relative(worktreePath, fullPath); + const segments = normalized.split(sep); - if (escapesParent(relativePath)) { + // Reject ".." as a path segment (allows "..foo" directories) + if (segments.includes("..")) { throw new PathValidationError( - "Path escapes worktree boundary", + "Path traversal not allowed", "PATH_TRAVERSAL", ); } - // 4. Check for root path (empty or ".") - if (!allowRoot && (relativePath === "" || relativePath === ".")) { + // Reject root path unless explicitly allowed + if (!allowRoot && (normalized === "" || normalized === ".")) { throw new PathValidationError( "Cannot target worktree root", "INVALID_TARGET", ); } - - // 5. Symlink escape check (default: enabled for safety) - if (checkSymlinks) { - await assertNoSymlinkEscape(worktreePath, fullPath); - } - - return fullPath; } /** - * Validates a path for use in git commands (pathspec). + * Validates and resolves a path within a worktree. Sync, simple. * - * Lighter validation than resolveSecurePath - just checks for - * obvious escapes. Git itself provides additional sandboxing. + * @param worktreePath - The worktree base path + * @param filePath - The relative file path to validate + * @param options - Validation options + * @returns The resolved full path + * @throws PathValidationError if path is invalid + */ +export function resolvePathInWorktree( + worktreePath: string, + filePath: string, + options: ValidatePathOptions = {}, +): string { + validateRelativePath(filePath, options); + // Use resolve to handle any worktreePath (relative or absolute) + return resolve(worktreePath, normalize(filePath)); +} + +/** + * Validates a path for git commands. Lighter check that allows root. * - * @param filePath - The file path to validate - * @throws PathValidationError if path is suspicious + * @throws PathValidationError if path is invalid */ export function assertValidGitPath(filePath: string): void { - if (isAbsolute(filePath)) { - throw new PathValidationError( - "Absolute paths are not allowed in git operations", - "ABSOLUTE_PATH", - ); - } - - const normalized = normalize(filePath); - const segments = normalized.split(sep); - - // Check for ".." as a segment (not substring - allows "..foo") - if (segments.includes("..")) { - throw new PathValidationError( - "Path traversal not allowed in git operations", - "PATH_TRAVERSAL", - ); - } + validateRelativePath(filePath, { allowRoot: true }); } diff --git a/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts b/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts index 1f4bb0e3d5e..2e461dd731a 100644 --- a/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts +++ b/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts @@ -1,27 +1,23 @@ import type { Stats } from "node:fs"; import { lstat, readFile, rm, stat, writeFile } from "node:fs/promises"; -import { assertRegisteredWorktree, resolveSecurePath } from "./path-validation"; +import { + assertRegisteredWorktree, + resolvePathInWorktree, +} from "./path-validation"; /** - * Secure filesystem operations that enforce validation. + * Secure filesystem operations with built-in validation. * - * Design principle: You cannot perform filesystem operations without - * going through validation. The validation is built into each operation. + * Each operation: + * 1. Validates worktree is registered (security boundary) + * 2. Validates path doesn't escape worktree (defense in depth) + * 3. Performs the filesystem operation * - * All operations: - * 1. Validate worktree is registered in database - * 2. Validate path doesn't escape worktree - * 3. Check for symlink escapes (configurable) - * - * Use Biome's restricted-imports rule to ban direct `node:fs` imports - * in router files - this module should be the only FS access point. + * See path-validation.ts for the full security model and threat assumptions. */ export const secureFs = { /** * Read a file within a worktree. - * - * Validates path and checks for symlink escapes to prevent - * reading files outside the worktree via symlinks. */ async readFile( worktreePath: string, @@ -29,33 +25,24 @@ export const secureFs = { encoding: BufferEncoding = "utf-8", ): Promise { assertRegisteredWorktree(worktreePath); - const fullPath = await resolveSecurePath(worktreePath, filePath, { - checkSymlinks: true, - }); + const fullPath = resolvePathInWorktree(worktreePath, filePath); return readFile(fullPath, encoding); }, /** * Read a file as a Buffer within a worktree. - * - * Validates path and checks for symlink escapes. */ async readFileBuffer( worktreePath: string, filePath: string, ): Promise { assertRegisteredWorktree(worktreePath); - const fullPath = await resolveSecurePath(worktreePath, filePath, { - checkSymlinks: true, - }); + const fullPath = resolvePathInWorktree(worktreePath, filePath); return readFile(fullPath); }, /** * Write content to a file within a worktree. - * - * Validates path and checks for symlink escapes to prevent - * writing files outside the worktree via symlinks. */ async writeFile( worktreePath: string, @@ -63,9 +50,7 @@ export const secureFs = { content: string, ): Promise { assertRegisteredWorktree(worktreePath); - const fullPath = await resolveSecurePath(worktreePath, filePath, { - checkSymlinks: true, - }); + const fullPath = resolvePathInWorktree(worktreePath, filePath); await writeFile(fullPath, content, "utf-8"); }, @@ -73,14 +58,13 @@ export const secureFs = { * Delete a file or directory within a worktree. * * DANGEROUS: Uses recursive + force deletion. - * Validates path and checks for symlink escapes. * Explicitly prevents deleting the worktree root. */ async delete(worktreePath: string, filePath: string): Promise { assertRegisteredWorktree(worktreePath); - const fullPath = await resolveSecurePath(worktreePath, filePath, { - checkSymlinks: true, - allowRoot: false, // Explicitly prevent deleting worktree root + // allowRoot: false prevents deleting the worktree itself + const fullPath = resolvePathInWorktree(worktreePath, filePath, { + allowRoot: false, }); await rm(fullPath, { recursive: true, force: true }); }, @@ -89,14 +73,10 @@ export const secureFs = { * Get file stats within a worktree. * * Uses `stat` (follows symlinks) to get the real file size. - * This is important for size checks - lstat would return - * the symlink size, not the target file size. */ async stat(worktreePath: string, filePath: string): Promise { assertRegisteredWorktree(worktreePath); - const fullPath = await resolveSecurePath(worktreePath, filePath, { - checkSymlinks: true, - }); + const fullPath = resolvePathInWorktree(worktreePath, filePath); return stat(fullPath); }, @@ -108,9 +88,7 @@ export const secureFs = { */ async lstat(worktreePath: string, filePath: string): Promise { assertRegisteredWorktree(worktreePath); - const fullPath = await resolveSecurePath(worktreePath, filePath, { - checkSymlinks: true, - }); + const fullPath = resolvePathInWorktree(worktreePath, filePath); return lstat(fullPath); }, @@ -122,9 +100,7 @@ export const secureFs = { async exists(worktreePath: string, filePath: string): Promise { try { assertRegisteredWorktree(worktreePath); - const fullPath = await resolveSecurePath(worktreePath, filePath, { - checkSymlinks: true, - }); + const fullPath = resolvePathInWorktree(worktreePath, filePath); await stat(fullPath); return true; } catch { From 3d0234b69d450bd93512dfc85b78a6f6fa3f0927 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Wed, 31 Dec 2025 09:36:39 +0200 Subject: [PATCH 15/98] feat(desktop): add configurable workspace navigation style (top-bar vs sidebar) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add a setting to let users choose between displaying workspaces as horizontal tabs in the TopBar (current behavior) or in a dedicated left sidebar (new feature, similar to Linear/GitHub Desktop). Key changes: - Add navigationStyle column to settings table (migration 0005) - Add navigation style dropdown in Behavior Settings - Create WorkspaceSidebar component with collapsible project sections - Create shared useWorkspaceShortcuts hook (⌘1-9 shortcuts, auto-create) - Update TopBar to conditionally render based on navigation style - Add ⌘⇧B hotkey to toggle workspace sidebar 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 --- .agents/commands/create-plan-file.md | 271 +++++ ...51231-1200-workspace-sidebar-navigation.md | 691 ++++++++++++ .../src/lib/trpc/routers/settings/index.ts | 21 + .../renderer/hooks/useWorkspaceShortcuts.ts | 117 +++ .../SettingsView/BehaviorSettings.tsx | 67 +- .../TopBar/WorkspaceSidebarControl.tsx | 40 + .../components/TopBar/WorkspaceTabs/index.tsx | 151 +-- .../screens/main/components/TopBar/index.tsx | 36 +- .../ProjectSection/ProjectHeader.tsx | 42 + .../ProjectSection/ProjectSection.tsx | 76 ++ .../WorkspaceSidebar/ProjectSection/index.ts | 2 + .../ResizableWorkspaceSidebar.tsx | 94 ++ .../WorkspaceListItem/WorkspaceDiffStats.tsx | 16 + .../WorkspaceListItem/WorkspaceListItem.tsx | 104 ++ .../WorkspaceStatusBadge.tsx | 53 + .../WorkspaceListItem/index.ts | 3 + .../WorkspaceSidebar/WorkspaceSidebar.tsx | 45 + .../WorkspaceSidebarFooter.tsx | 62 ++ .../WorkspaceSidebarHeader.tsx | 10 + .../main/components/WorkspaceSidebar/index.ts | 2 + .../src/renderer/screens/main/index.tsx | 22 +- apps/desktop/src/renderer/stores/index.ts | 1 + .../stores/workspace-sidebar-state.ts | 97 ++ apps/desktop/src/shared/constants.ts | 1 + apps/desktop/src/shared/hotkeys.ts | 7 +- .../drizzle/0005_add_navigation_style.sql | 1 + .../local-db/drizzle/meta/0005_snapshot.json | 984 ++++++++++++++++++ packages/local-db/drizzle/meta/_journal.json | 7 + packages/local-db/src/schema/schema.ts | 6 + 29 files changed, 2865 insertions(+), 164 deletions(-) create mode 100644 .agents/commands/create-plan-file.md create mode 100644 apps/desktop/.agents/plans/20251231-1200-workspace-sidebar-navigation.md create mode 100644 apps/desktop/src/renderer/hooks/useWorkspaceShortcuts.ts create mode 100644 apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceSidebarControl.tsx create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/ProjectSection/ProjectHeader.tsx create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/ProjectSection/ProjectSection.tsx create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/ProjectSection/index.ts create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/ResizableWorkspaceSidebar.tsx create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceDiffStats.tsx create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceStatusBadge.tsx create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/index.ts create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceSidebar.tsx create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceSidebarFooter.tsx create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceSidebarHeader.tsx create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/index.ts create mode 100644 apps/desktop/src/renderer/stores/workspace-sidebar-state.ts create mode 100644 packages/local-db/drizzle/0005_add_navigation_style.sql create mode 100644 packages/local-db/drizzle/meta/0005_snapshot.json diff --git a/.agents/commands/create-plan-file.md b/.agents/commands/create-plan-file.md new file mode 100644 index 00000000000..3b092d269ed --- /dev/null +++ b/.agents/commands/create-plan-file.md @@ -0,0 +1,271 @@ +# Superset Execution Plans (ExecPlans): + +> **DO NOT EDIT THIS FILE** +> This file is the ExecPlan template and guide only. +> Create plans in the appropriate location: +> - **App-specific work**: `apps//.agents/plans/-.md` +> - **Package work**: `packages//.agents/plans/-.md` +> - **Cross-app/shared work**: `.agents/plans/-.md` (root) + +This document describes the requirements for an execution plan ("ExecPlan"), a design document that a coding agent can follow to deliver a working feature or system change. Treat the reader as a complete beginner to this repository: they have only the current working tree and the single ExecPlan file you provide. There is no memory of prior plans and no external context. + +## Process + +Steps: +1. Discovery & Orientation: map the repo, name the scope, enumerate unknowns. Capture initial Assumptions and Open Questions in the ExecPlan. +2. Question-driven Clarification: ask focused, acceptance-oriented questions grouped by plan section. Maintain the Open Questions list in the ExecPlan and pre-link each item to a Decision Log placeholder. +3. Draft the Plan: complete the ExecPlan skeleton end-to-end (Purpose, Context, Plan of Work, Validation, Idempotence, etc.), calling out risks and dependencies. +4. Resolve Questions: as answers arrive, immediately update the ExecPlan—move items from Open Questions to the Decision Log with rationale; adjust Plan of Work and Acceptance accordingly. +5. Approval Gate: present the updated ExecPlan for approval. Do not implement until approved. +6. Implementation & Validation: implement per the plan, update Progress with timestamps, and validate via tests and acceptance. Log learnings in Surprises & Discoveries. +7. Closeout: write Outcomes & Retrospective; ensure the plan remains self-contained and accurate. +8. Write your plan to the appropriate location: + - App-specific: `apps//.agents/plans/-.md` + - Package-specific: `packages//.agents/plans/-.md` + - Cross-app: `.agents/plans/-.md` + Use `` in `YYYYMMDD-HHmm` format (e.g., `20240613-1045-my-feature-plan.md`). This ensures plans are sorted from most recent to oldest. +9. Plan Lifecycle: When the plan is complete and a PR is created, move it to the `done/` folder within the same directory. If abandoned, move it to `abandoned/`. + +Example questions: +``` +I reviewed the existing auth implementation in apps/web/src/app/auth/. + +Where should the new OAuth provider live? +a) apps/web/src/lib/auth/providers/ (co-located with auth logic) +b) packages/shared/src/auth/ (shared across apps) +c) Other (specify) + +How should we handle token refresh? +a) Silent refresh via interceptor +b) Explicit refresh on 401 response +c) Other (specify) +``` + +## How to use ExecPlans and PLANS.md + +When authoring an executable specification (ExecPlan), follow this document _to the letter_. Be thorough in reading (and re-reading) source material to produce an accurate specification. When creating a spec, start from the skeleton and flesh it out as you do your research. + +When implementing an executable specification (ExecPlan), do not prompt the user for "next steps"; simply proceed to the next milestone. Keep all sections up to date, add or split entries in the list at every stopping point to affirmatively state the progress made and next steps. Resolve ambiguities autonomously, and commit frequently. + +When discussing an executable specification (ExecPlan), record decisions in a log in the spec for posterity; it should be unambiguously clear why any change to the specification was made. ExecPlans are living documents, and it should always be possible to restart from _only_ the ExecPlan and no other work. + +When researching a design with challenging requirements or significant unknowns, use milestones to implement proof of concepts, "toy implementations", etc., that allow validating whether the user's proposal is feasible. Read the source code of libraries by finding or acquiring them, research deeply, and include prototypes to guide a fuller implementation. + +## Requirements + +NON-NEGOTIABLE REQUIREMENTS: + +* Every ExecPlan must be fully self-contained. Self-contained means that in its current form it contains all knowledge and instructions needed for a novice to succeed. +* Every ExecPlan is a living document. Contributors are required to revise it as progress is made, as discoveries occur, and as design decisions are finalized. Each revision must remain fully self-contained. +* Every ExecPlan must enable a complete novice to implement the feature end-to-end without prior knowledge of this repo. +* Every ExecPlan must produce a demonstrably working behavior, not merely code changes to "meet a definition". +* Every ExecPlan must define every term of art in plain language or do not use it. + +Purpose and intent come first. Begin by explaining, in a few sentences, why the work matters from a user's perspective: what someone can do after this change that they could not do before, and how to see it working. Then guide the reader through the exact steps to achieve that outcome, including what to edit, what to run, and what they should observe. + +The agent executing your plan can list files, read files, search, run the project, and run tests. It does not know any prior context and cannot infer what you meant from earlier milestones. Repeat any assumption you rely on. Do not point to external blogs or docs; if knowledge is required, embed it in the plan itself in your own words. If an ExecPlan builds upon a prior ExecPlan and that file is checked in, incorporate it by reference. If it is not, you must include all relevant context from that plan. + +## Formatting + +Format and envelope are simple and strict. Each ExecPlan must be one single fenced code block labeled as `md` that begins and ends with triple backticks. Do not nest additional triple-backtick code fences inside; when you need to show commands, transcripts, diffs, or code, present them as indented blocks within that single fence. Use indentation for clarity rather than code fences inside an ExecPlan to avoid prematurely closing the ExecPlan's code fence. Use two newlines after every heading, use # and ## and so on, and correct syntax for ordered and unordered lists. + +When writing an ExecPlan to a Markdown (.md) file where the content of the file *is only* the single ExecPlan, you should omit the triple backticks. + +Write in plain prose. Prefer sentences over lists. Avoid checklists, tables, and long enumerations unless brevity would obscure meaning. Checklists are permitted only in the `Progress` section, where they are mandatory. Narrative sections must remain prose-first. + +## Guidelines + +Self-containment and plain language are paramount. If you introduce a phrase that is not ordinary English ("daemon", "middleware", "RPC gateway", "filter graph"), define it immediately and remind the reader how it manifests in this repository (for example, by naming the files or commands where it appears). Do not say "as defined previously" or "according to the architecture doc." Include the needed explanation here, even if you repeat yourself. + +Avoid common failure modes. Do not rely on undefined jargon. Do not describe "the letter of a feature" so narrowly that the resulting code compiles but does nothing meaningful. Do not outsource key decisions to the reader. When ambiguity exists, resolve it in the plan itself and explain why you chose that path. Err on the side of over-explaining user-visible effects and under-specifying incidental implementation details. + +Question discipline and placement: +- Keep each question atomic and acceptance-oriented (what behavior must hold? how will we observe it?). +- Record questions in an Open Questions section of the ExecPlan; tag each with the plan section it affects (e.g., Validation, Plan of Work). +- When a question is answered, create a Decision Log entry with rationale and update the affected sections. Remove the item from Open Questions. +- Prefer at most 3-7 active questions; timebox low-impact ones or convert them into explicit Assumptions. + +Anchor the plan with observable outcomes. State what the user can do after implementation, the commands to run, and the outputs they should see. Acceptance should be phrased as behavior a human can verify ("after starting the server, navigating to http://localhost:3000/health returns HTTP 200 with body OK") rather than internal attributes ("added a HealthCheck struct"). If a change is internal, explain how its impact can still be demonstrated (for example, by running tests that fail before and pass after, and by showing a scenario that uses the new behavior). + +Specify repository context explicitly. Name files with full repository-relative paths, name functions and modules precisely, and describe where new files should be created. If touching multiple areas, include a short orientation paragraph that explains how those parts fit together so a novice can navigate confidently. When running commands, show the working directory and exact command line. When outcomes depend on environment, state the assumptions and provide alternatives when reasonable. + +Be idempotent and safe. Write the steps so they can be run multiple times without causing damage or drift. If a step can fail halfway, include how to retry or adapt. If a migration or destructive operation is necessary, spell out backups or safe fallbacks. Prefer additive, testable changes that can be validated as you go. + +Validation is not optional. Include instructions to run tests, to start the system if applicable, and to observe it doing something useful. Describe comprehensive testing for any new features or capabilities. Include expected outputs and error messages so a novice can tell success from failure. Where possible, show how to prove that the change is effective beyond compilation (for example, through a small end-to-end scenario, a CLI invocation, or an HTTP request/response transcript). State the exact test commands appropriate to the project's toolchain and how to interpret their results. + +## Superset-Specific Context + +This is a Bun + Turborepo monorepo with the following structure: + +**Apps:** +- `apps/web` - Main web application (app.superset.sh) +- `apps/marketing` - Marketing site (superset.sh) +- `apps/admin` - Admin dashboard +- `apps/api` - API backend +- `apps/desktop` - Electron desktop application +- `apps/docs` - Documentation site +- `apps/cli` - CLI tooling + +**Packages:** +- `packages/ui` - Shared UI components (shadcn/ui + TailwindCSS v4) +- `packages/db` - Drizzle ORM database schema +- `packages/local-db` - Local database schema +- `packages/queries` - Shared query logic +- `packages/shared` - Shared constants and utilities +- `packages/trpc` - tRPC configuration + +**Common Commands:** +- `bun dev` - Start all dev servers +- `bun test` - Run tests +- `bun build` - Build all packages +- `bun run lint` - Check for lint issues +- `bun run lint:fix` - Fix auto-fixable lint issues +- `bun run typecheck` - Type check all packages +- `bun run db:push` - Apply schema changes +- `bun run db:migrate` - Run migrations + +Capture evidence. When your steps produce terminal output, short diffs, or logs, include them inside the single fenced block as indented examples. Keep them concise and focused on what proves success. If you need to include a patch, prefer file-scoped diffs or small excerpts that a reader can recreate by following your instructions rather than pasting large blobs. + +## Milestones + +Milestones are narrative, not bureaucracy. If you break the work into milestones, introduce each with a brief paragraph that describes the scope, what will exist at the end of the milestone that did not exist before, the commands to run, and the acceptance you expect to observe. Keep it readable as a story: goal, work, result, proof. Progress and milestones are distinct: milestones tell the story, progress tracks granular work. Both must exist. Never abbreviate a milestone merely for the sake of brevity, do not leave out details that could be crucial to a future implementation. + +Each milestone must be independently verifiable and incrementally implement the overall goal of the execution plan. + +## Living plans and design decisions + +* ExecPlans are living documents. As you make key design decisions, update the plan to record both the decision and the thinking behind it. Record all decisions in the `Decision Log` section. +* ExecPlans must contain and maintain a `Progress` section, a `Surprises & Discoveries` section, a `Decision Log`, and an `Outcomes & Retrospective` section. These are not optional. +* When you discover optimizer behavior, performance tradeoffs, unexpected bugs, or inverse/unapply semantics that shaped your approach, capture those observations in the `Surprises & Discoveries` section with short evidence snippets (test output is ideal). +* If you change course mid-implementation, document why in the `Decision Log` and reflect the implications in `Progress`. Plans are guides for the next contributor as much as checklists for you. +* At completion of a major task or the full plan, write an `Outcomes & Retrospective` entry summarizing what was achieved, what remains, and lessons learned. + +# Prototyping milestones and parallel implementations + +It is acceptable--and often encouraged--to include explicit prototyping milestones when they de-risk a larger change. Examples: adding a low-level operator to a dependency to validate feasibility, or exploring two composition orders while measuring optimizer effects. Keep prototypes additive and testable. Clearly label the scope as "prototyping"; describe how to run and observe results; and state the criteria for promoting or discarding the prototype. + +Prefer additive code changes followed by subtractions that keep tests passing. Parallel implementations (e.g., keeping an adapter alongside an older path during migration) are fine when they reduce risk or enable tests to continue passing during a large migration. Describe how to validate both paths and how to retire one safely with tests. When working with multiple new libraries or feature areas, consider creating spikes that evaluate the feasibility of these features _independently_ of one another, proving that the external library performs as expected and implements the features we need in isolation. + +## Skeleton of a Good ExecPlan + +```md +# + +This ExecPlan is a living document. The sections `Progress`, `Surprises & Discoveries`, `Decision Log`, and `Outcomes & Retrospective` must be kept up to date as work proceeds. + +## Purpose / Big Picture + +Explain in a few sentences what someone gains after this change and how they can see it working. State the user-visible behavior you will enable. + +## Assumptions + +State temporary assumptions that unblock planning. Every assumption must either be confirmed (moved to the Decision Log) or removed by implementation end. + +## Open Questions + +List unresolved, acceptance-oriented questions. For each, note the impacted plan sections (e.g., Validation, Plan of Work) and add a placeholder in the Decision Log for the eventual answer. + +## Progress + +Use a list with checkboxes to summarize granular steps. Every stopping point must be documented here, even if it requires splitting a partially completed task into two ("done" vs. "remaining"). This section must always reflect the actual current state of the work. + +- [x] (2025-10-01 13:00Z) Example completed step. +- [ ] Example incomplete step. +- [ ] Example partially completed step (completed: X; remaining: Y). + +Use timestamps to measure rates of progress. + +## Surprises & Discoveries + +Document unexpected behaviors, bugs, optimizations, or insights discovered during implementation. Provide concise evidence. + +- Observation: ... + Evidence: ... + +## Decision Log + +Record every decision made while working on the plan in the format: + +- Decision: ... + Rationale: ... + Date/Author: ... + +## Outcomes & Retrospective + +Summarize outcomes, gaps, and lessons learned at major milestones or at completion. Compare the result against the original purpose. + +## Context and Orientation + +Describe the current state relevant to this task as if the reader knows nothing. Name the key files and modules by full path. Define any non-obvious term you will use. Do not refer to prior plans. + +## Plan of Work + +Describe, in prose, the sequence of edits and additions. For each edit, name the file and location (function, module) and what to insert or change. Keep it concrete and minimal. + +## Concrete Steps + +State the exact commands to run and where to run them (working directory). When a command generates output, show a short expected transcript so the reader can compare. This section must be updated as work proceeds. + +## Validation and Acceptance + +Describe how to start or exercise the system and what to observe. Phrase acceptance as behavior, with specific inputs and outputs. If tests are involved, say "run `bun test` and expect passed; the new test fails before the change and passes after". + +## Idempotence and Recovery + +If steps can be repeated safely, say so. If a step is risky, provide a safe retry or rollback path. Keep the environment clean after completion. + +## Artifacts and Notes + +Include the most important transcripts, diffs, or snippets as indented examples. Keep them concise and focused on what proves success. + +## Interfaces and Dependencies + +Be prescriptive. Name the libraries, modules, and services to use and why. Specify the types, traits/interfaces, and function signatures that must exist at the end of the milestone. Prefer stable names and paths such as `packages/db/src/schema/users.ts` or `apps/web/src/lib/auth.ts`. E.g.: + +In packages/db/src/schema/users.ts, define: + + export const users = pgTable('users', { + id: text('id').primaryKey(), + email: text('email').notNull().unique(), + createdAt: timestamp('created_at').defaultNow(), + }); +``` + +If you follow the guidance above, a single, stateless agent -- or a human novice -- can read your ExecPlan from top to bottom and produce a working, observable result. That is the bar: SELF-CONTAINED, SELF-SUFFICIENT, NOVICE-GUIDING, OUTCOME-FOCUSED. + +When you revise a plan, you must ensure your changes are comprehensively reflected across all sections, including the living document sections, and you must write a note at the bottom of the plan describing the change and the reason why. ExecPlans must describe not just the what but the why for almost everything. + +## Plan Lifecycle + +ExecPlans have a defined lifecycle that keeps the `.agents/plans/` folder clean and provides a historical record of completed work. + +### Directory Structure + +``` +apps//.agents/plans/ # App-specific plans + .md + done/ + abandoned/ + +packages//.agents/plans/ # Package-specific plans + .md + done/ + abandoned/ + +.agents/plans/ # Cross-app/shared plans + .md + done/ + abandoned/ +``` + +### When to Move Plans + +**To `done/`**: Move the plan to the `done/` folder within the same directory when creating a PR that completes the work. Before moving, ensure the plan's `Outcomes & Retrospective` section is filled in. + +**To `abandoned/`**: Move the plan to the `abandoned/` folder within the same directory if work is stopped without completion. Add a note explaining why (scope changed, approach invalidated, deprioritized, etc.). + +### Edge Cases + +- **PR closed without merging**: The plan stays in `done/`. If work resumes, move it back to the active plans folder and update the `Progress` section. +- **Plan spans multiple PRs**: Keep the plan in the active folder until the final PR. Reference intermediate PRs in the `Progress` section, then move to `done/` on the final PR. +- **Reopening abandoned work**: Move the plan from `abandoned/` back to the active plans folder and update the `Progress` section to reflect the restart. diff --git a/apps/desktop/.agents/plans/20251231-1200-workspace-sidebar-navigation.md b/apps/desktop/.agents/plans/20251231-1200-workspace-sidebar-navigation.md new file mode 100644 index 00000000000..88aba9783e4 --- /dev/null +++ b/apps/desktop/.agents/plans/20251231-1200-workspace-sidebar-navigation.md @@ -0,0 +1,691 @@ +# Configurable Workspace Navigation: Sidebar Mode + +This ExecPlan is a living document. The sections `Progress`, `Surprises & Discoveries`, `Decision Log`, and `Outcomes & Retrospective` must be kept up to date as work proceeds. + +## Purpose / Big Picture + +Currently, workspaces are displayed as horizontal tabs in the TopBar, grouped by project. This change allows users to configure an alternative "sidebar" navigation style where workspaces appear in a dedicated left sidebar panel, matching designs from tools like Linear/GitHub Desktop. + +After this change, users can: +1. Open Settings > Behavior and toggle "Navigation style" between "Top bar" and "Sidebar" +2. In sidebar mode, see a dedicated workspace sidebar with collapsible project sections +3. Switch between workspaces by clicking items in the sidebar +4. See PR status, diff stats, and keyboard shortcuts inline with workspace items +5. Continue using ⌘1-9 shortcuts to switch workspaces regardless of mode + +## Design Reference + +The target design (based on provided mockup): + + ┌─────────────────────────────────────────────────────────────────────┐ + │ [Sidebar Toggle] [Workbench|Review] [Branch ▾] [Open In ▾] [Avatar]│ <- TopBar (sidebar mode) + ├──────────────────────┬──────────────────────────────────────────────┤ + │ ≡ Workspaces │ │ + │ │ │ + │ web │ │ + │ + New workspace ... │ Main Content Area │ + │ ┃ andreasasprou/cebu │ (Workbench or Review mode) │ + │ cebu · PR #144 │ │ + │ Ready to merge ⌘1 │ │ + │ +1850 -301 │ │ + │ │ │ + │ ▸ andreasasprou/feat │ │ + │ harare · PR #107 │ │ + │ Merge conflicts ⌘2 │ │ + │ ├──────────────────────────────────────────────┤ + │ nova │ │ + │ + New workspace ... │ Changes Sidebar │ + │ ┃ andreasasprou/pdf │ (existing ResizableSidebar) │ + │ la-paz-v2 · PR#720 │ │ + │ Uncommitted ⌘3 │ │ + │ +23823 -5 │ │ + │ │ │ + │ frontend │ │ + │ + New workspace ... │ │ + │ │ │ + │──────────────────── │ │ + │ [+] Add project │ │ + └──────────────────────┴──────────────────────────────────────────────┘ + Workspace Changes Content + Sidebar Sidebar (Mosaic Panes) + (NEW) (existing) + +Key visual elements: +- Active workspace: Green/project-colored left border (┃) +- Status badges: "Ready to merge", "Merge conflicts", "Uncommitted changes", "Archive" +- Diff stats: +insertions -deletions (always visible for active, hover for others) +- Keyboard shortcuts: ⌘1-9 displayed inline +- Collapsible project sections with header + "..." context menu +- "+ New workspace" per project section +- "Add project" at bottom footer + +## Assumptions + +1. The existing `WorkspaceHoverCard` already fetches PR status via `workspaces.getGitHubStatus` and can be reused +2. The `feat/desktop-workbench-review-mode` branch changes are the baseline (already rebased) +3. Users will primarily use one mode or the other, not switch frequently +4. The `packages/local-db` migration system handles schema changes on app startup + +## Open Questions + +(All questions resolved - see Decision Log) + +## Progress + +- [ ] Initial plan created and awaiting approval +- [ ] (Pending) Milestone 1: Add navigation style setting +- [ ] (Pending) Milestone 2: Create WorkspaceSidebar component +- [ ] (Pending) Milestone 3: Create sidebar-mode TopBar variant +- [ ] (Pending) Milestone 4: Wire up setting to conditionally render layouts +- [ ] (Pending) Milestone 5: Polish and validation + +## Surprises & Discoveries + +(To be filled during implementation) + +## Decision Log + +- **Decision**: Navigation style setting stored in SQLite settings table via existing tRPC pattern + - Rationale: Matches existing "confirmOnQuit" behavior setting pattern, persists across sessions + - Date: 2025-12-31 / Planning phase + +- **Decision**: Workspace sidebar is a NEW dedicated sidebar, not a mode in existing ModeCarousel + - Rationale: User preference for dedicated panel, keeps workspaces separate from terminal tabs/changes + - Date: 2025-12-31 / Planning phase + +- **Decision**: Both sidebars independently resizable + - Rationale: User may want different widths for workspace nav vs file changes + - Date: 2025-12-31 / Planning phase + +- **Decision**: ⌘1-9 shortcuts work in both navigation modes + - Rationale: Consistency for keyboard users regardless of UI layout preference + - Date: 2025-12-31 / Planning phase + +- **Decision**: Manual testing only, no automated tests for initial release + - Rationale: Feature is primarily UI/layout, visual verification more appropriate + - Date: 2025-12-31 / Planning phase + +- **Decision**: Workspace sidebar width persisted independently from changes sidebar + - Rationale: Users may want different widths for workspace nav vs file changes + - Date: 2025-12-31 / Planning phase + +- **Decision**: Workspace display format is "github-username/branch-name" (e.g., "andreasasprou/cebu") + - Rationale: Matches GitHub PR branch naming, provides author context + - Date: 2025-12-31 / Planning phase + +- **Decision**: Skip "Archive" status badge for initial release + - Rationale: Archive feature doesn't exist in app, can add later if needed + - Date: 2025-12-31 / Planning phase + +- **Decision**: Keep Workbench/Review toggle and Open In in WorkspaceActionBar, not TopBar + - Rationale: Avoids duplicating components, maintains consistent location across navigation modes + - Date: 2025-12-31 / Planning phase (review feedback) + +- **Decision**: Sidebar toggles use distinct naming: "Workspaces" and "Files" with different icons + - Rationale: With two sidebars, "Toggle sidebar" is ambiguous. Clear naming prevents confusion + - Date: 2025-12-31 / Planning phase (review feedback) + +- **Decision**: Workspace sidebar is toggleable (not always-on), default open on first use + - Rationale: Matches changes sidebar pattern, provides flexibility for screen sizes + - Date: 2025-12-31 / Planning phase (review feedback) + +- **Decision**: Use `workspaces.getGitHubStatus` for diff stats, lazy-load on hover + - Rationale: Reuses existing infrastructure, avoids N+1 queries, matches WorkspaceHoverCard + - Date: 2025-12-31 / Planning phase (review feedback) + +- **Decision**: Extract ⌘1-9 shortcuts and auto-create workspace logic into shared hook + - Rationale: These behaviors must work in BOTH navigation modes, avoiding code duplication + - Date: 2025-12-31 / Planning phase (review feedback) + +## Outcomes & Retrospective + +(To be filled at completion) + +--- + +## Context and Orientation + +### Current Architecture + +The desktop app (`apps/desktop/`) uses: + +**Layout Structure** (in `src/renderer/screens/main/`): +- `MainScreen` - Root component, manages view state (workspace/settings/tasks) +- `TopBar` - Contains `WorkspacesTabs` for horizontal workspace navigation +- `WorkspaceView` - Main content area with `ResizableSidebar` (changes) + `ContentView` + +**State Management**: +- `sidebar-state.ts` - Zustand store for changes sidebar (width, visibility, mode) +- `workspace-view-mode.ts` - Zustand store for Workbench/Review mode per workspace +- `app-state.ts` - Current view, settings section, etc. + +**Settings System**: +- Settings stored in SQLite via `packages/local-db/src/schema/schema.ts` +- tRPC routes in `src/lib/trpc/routers/settings/` +- UI in `src/renderer/screens/main/components/SettingsView/BehaviorSettings.tsx` + +**Key Files**: +- `src/renderer/screens/main/components/TopBar/index.tsx` - Current TopBar +- `src/renderer/screens/main/components/TopBar/WorkspaceTabs/index.tsx` - Horizontal tabs +- `src/renderer/screens/main/components/WorkspaceView/index.tsx` - Main workspace layout +- `src/renderer/screens/main/components/WorkspaceView/ResizableSidebar/` - Existing sidebar + +### Terminology + +- **Navigation style**: User preference for workspace display location ("top-bar" or "sidebar") +- **Workspace sidebar**: NEW left panel showing workspaces grouped by project +- **Changes sidebar**: EXISTING left panel showing git changes (file tree) +- **Workbench mode**: Terminal panes + file viewers (mosaic layout) +- **Review mode**: Full-page changes/diff view + +--- + +## Plan of Work + +### Milestone 1: Add Navigation Style Setting + +Add the setting infrastructure following the existing "confirmOnQuit" pattern. + +**1.1 Add setting to database schema** + +In `packages/local-db/src/schema/schema.ts`, add to settings table: + + navigationStyle: text("navigation_style").$type<"top-bar" | "sidebar">(), + +**1.2 Generate local-db migration** + +Run from `packages/local-db`: + + pnpm drizzle-kit generate --name="add_navigation_style" + +This creates a migration file in `packages/local-db/drizzle/`. The migration runs automatically on app startup via `apps/desktop/src/main/lib/local-db/index.ts` migrate logic. + +**IMPORTANT**: Do NOT use `bun run db:push` - that targets packages/db (Neon/Postgres), not local-db. + +**1.3 Add default constant** + +In `apps/desktop/src/shared/constants.ts`: + + export const DEFAULT_NAVIGATION_STYLE = "top-bar" as const; + export type NavigationStyle = "top-bar" | "sidebar"; + +**1.4 Add tRPC routes** + +In `apps/desktop/src/lib/trpc/routers/settings/index.ts`, add: + + getNavigationStyle: publicProcedure.query(async () => { + const row = getSettings(); + return row.navigationStyle ?? DEFAULT_NAVIGATION_STYLE; + }), + + setNavigationStyle: publicProcedure + .input(z.object({ style: z.enum(["top-bar", "sidebar"]) })) + .mutation(async ({ input }) => { + localDb.insert(settings) + .values({ id: 1, navigationStyle: input.style }) + .onConflictDoUpdate({ + target: settings.id, + set: { navigationStyle: input.style } + }) + .run(); + return { success: true }; + }), + +**1.5 Add UI in BehaviorSettings** + +In `apps/desktop/src/renderer/screens/main/components/SettingsView/BehaviorSettings.tsx`, add a toggle/select for "Navigation style" with options "Top bar" and "Sidebar". + +### Milestone 2: Create WorkspaceSidebar Component + +Create the new sidebar component matching the design. + +**2.1 Create store for workspace sidebar state** + +Create `apps/desktop/src/renderer/stores/workspace-sidebar-state.ts`: + + interface WorkspaceSidebarState { + isOpen: boolean; + width: number; + // Use string[] instead of Set for JSON serialization with Zustand persist + collapsedProjectIds: string[]; + toggleOpen: () => void; + setWidth: (width: number) => void; + toggleProjectCollapsed: (projectId: string) => void; + isProjectCollapsed: (projectId: string) => boolean; + } + +**NOTE**: Do NOT use `Set` for `collapsedProjectIds` - Zustand persist uses JSON serialization which drops Sets. Use `string[]` and provide helper methods. + +**2.2 Create component structure** + +Create folder: `apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/` + +Files to create: +- `index.tsx` - Main component +- `WorkspaceSidebarHeader.tsx` - "Workspaces" header with icon +- `ProjectSection/ProjectSection.tsx` - Collapsible project group +- `ProjectSection/ProjectHeader.tsx` - Project name + actions +- `WorkspaceListItem/WorkspaceListItem.tsx` - Individual workspace row +- `WorkspaceListItem/WorkspaceStatusBadge.tsx` - Status badges +- `WorkspaceListItem/WorkspaceDiffStats.tsx` - +/- diff display +- `WorkspaceSidebarFooter.tsx` - "Add project" button + +**2.3 WorkspaceListItem design** + +Each workspace item displays: +- Left border (project color when active) +- Branch icon (git-branch, git-pull-request, etc. based on type) +- Author/branch: "andreasasprou/feature-name" +- Worktree name + PR info: "worktree-city · PR #123" +- Status badge: "Ready to merge" / "Merge conflicts" / "Uncommitted changes" / "Archive" +- Keyboard shortcut badge: "⌘1" +- Diff stats (for active): "+1850 -301" + +**2.4 Data fetching** + +Reuse existing queries: +- `trpc.workspaces.getAllGrouped.useQuery()` for project/workspace list +- `trpc.workspaces.getActive.useQuery()` for active workspace + +**Diff stats source**: Use `workspaces.getGitHubStatus` (already used by WorkspaceHoverCard) for PR additions/deletions. This is the authoritative source. Do NOT add a new git diff endpoint. For workspaces without PRs, show local uncommitted changes count from the changes router as fallback. + +**Performance consideration**: Avoid N+1 `getGitHubStatus` calls per workspace row. Options: +1. Extend `getAllGrouped` to include a summary `githubStatus` field (batched) +2. Reuse cached data from `worktrees.githubStatus` if already fetched +3. Lazy-load status on hover only (simplest, matches current WorkspaceHoverCard behavior) + +Recommended: Start with option 3 (lazy-load on hover) to match existing patterns, then optimize with batching if performance is an issue. + +**2.5 Extract shared workspace behaviors** + +Currently `WorkspacesTabs/index.tsx` owns critical behaviors that must work in BOTH navigation modes: +- ⌘1-9 workspace switching shortcuts +- Auto-create main workspace for new projects effect + +Create a shared hook: `apps/desktop/src/renderer/hooks/useWorkspaceShortcuts.ts` + + export function useWorkspaceShortcuts() { + const { data: groups = [] } = trpc.workspaces.getAllGrouped.useQuery(); + const setActiveWorkspace = useSetActiveWorkspace(); + const createBranchWorkspace = useCreateBranchWorkspace(); + + // Flatten workspaces for ⌘1-9 navigation + const allWorkspaces = groups.flatMap((group) => group.workspaces); + + // ⌘1-9 shortcuts + useHotkeys(workspaceKeys, handleWorkspaceSwitch); + useHotkeys(HOTKEYS.PREV_WORKSPACE.keys, handlePrevWorkspace); + useHotkeys(HOTKEYS.NEXT_WORKSPACE.keys, handleNextWorkspace); + + // Auto-create main workspace for new projects + useEffect(() => { /* existing logic */ }, [groups]); + + return { allWorkspaces }; + } + +Then use this hook in BOTH: +- `WorkspaceSidebar/index.tsx` (sidebar mode) +- `WorkspacesTabs/index.tsx` (top-bar mode) + +This ensures shortcuts work regardless of navigation style. + +### Milestone 3: Create Sidebar-Mode TopBar Variant + +When navigation style is "sidebar", the TopBar should show a unified bar without workspace tabs. + +**3.1 Decide on control placement** + +Currently, `WorkspaceActionBar` contains: +- ViewModeToggle (Workbench/Review) +- Branch selector +- Open In dropdown + +**Decision needed**: In sidebar mode, do these controls: +A) Stay in WorkspaceActionBar (below TopBar) - no duplication, consistent location +B) Move to TopBarSidebarMode - more prominent, frees up vertical space + +**Recommendation**: Keep controls in WorkspaceActionBar (option A). This: +- Avoids duplicating components +- Maintains consistent location across modes +- Keeps TopBar focused on navigation + +TopBarSidebarMode then only needs: +- Changes sidebar toggle (existing SidebarControl, renamed for clarity) +- Workspace sidebar toggle (new) +- Avatar/user menu + +**3.2 Sidebar toggle disambiguation** + +With two sidebars, we need clear naming: +- **"Files" / file icon**: Toggle changes sidebar (existing, currently just "sidebar") +- **"Workspaces" / layers icon**: Toggle workspace sidebar (new) + +Update tooltips and potentially add labels on hover. Both toggles live in TopBar. + +**3.3 Create TopBarSidebarMode component** + +Create `apps/desktop/src/renderer/screens/main/components/TopBar/TopBarSidebarMode.tsx`: + +Layout (left to right): +- Workspace sidebar toggle (new, tooltip: "Toggle workspaces") +- Changes sidebar toggle (existing SidebarControl, tooltip: "Toggle files") +- [Spacer] +- [Right] Avatar dropdown + +The Workbench/Review toggle, branch selector, and Open In dropdown remain in WorkspaceActionBar. + +**3.4 Workspace sidebar always-on vs toggleable** + +The workspace sidebar should be toggleable (not always-on) because: +- Users may want full-width content when not switching workspaces +- Matches the existing changes sidebar pattern +- Provides flexibility for different screen sizes + +Default state: Open (on first use), then persisted via Zustand. + +**3.5 Conditional rendering in TopBar** + +Modify `apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx`: + + const { data: navigationStyle } = trpc.settings.getNavigationStyle.useQuery(); + + if (navigationStyle === "sidebar") { + return ; + } + + return ; // Rename current implementation + +### Milestone 4: Wire Up Layout Switching + +Connect the setting to conditionally render the appropriate layout. + +**4.1 Modify MainScreen layout** + +In `apps/desktop/src/renderer/screens/main/index.tsx`, when rendering workspace view: + + const { data: navigationStyle } = trpc.settings.getNavigationStyle.useQuery(); + + // In render: + {navigationStyle === "sidebar" && } + + +**4.2 Modify WorkspaceView** + +The `WorkspaceView` component remains largely unchanged - it already has the ResizableSidebar (changes) and ContentView. The WorkspaceSidebar sits to its left. + +**4.3 Layout structure in sidebar mode** + +
+ {/* NEW - workspace navigation */} + {/* EXISTING - contains changes sidebar + content */} +
+ +### Milestone 5: Polish and Validation + +**5.1 Keyboard shortcuts** + +Ensure ⌘1-9 workspace switching works in both modes. The existing `useHotkeys` in `WorkspacesTabs/index.tsx` should be moved/shared. + +**5.2 Hover preview** + +Implement hover preview showing branch + PR status. Can reuse `WorkspaceHoverCard` component or adapt it. + +**5.3 Animations** + +- Smooth sidebar show/hide with Framer Motion +- Collapse/expand project sections with animation +- Active workspace indicator transition + +**5.4 Persistence** + +- Workspace sidebar width persists (Zustand + localStorage) +- Collapsed project sections persist +- Navigation style persists (SQLite) + +--- + +## Concrete Steps + +All commands run from repository root: `/Users/andreasasprou/.superset/worktrees/superset/workspace-sidebar` + +**Step 1: Verify current state** + + cd apps/desktop + bun run typecheck + +Expected: No type errors (baseline) + +**Step 2: Add database schema field and generate migration** + +Edit `packages/local-db/src/schema/schema.ts` to add `navigationStyle` column. + + cd packages/local-db + pnpm drizzle-kit generate --name="add_navigation_style" + +Expected: Migration file created in `packages/local-db/drizzle/` + +The migration runs automatically on app startup. Do NOT use `bun run db:push` (that's for Neon/Postgres). + +**Step 3: Add setting routes** + +Edit `apps/desktop/src/lib/trpc/routers/settings/index.ts` + + bun run typecheck + +Expected: Types pass with new routes + +**Step 4: Create WorkspaceSidebar component** + +Create component files as specified in Milestone 2. + +**Step 5: Add to layout** + +Wire up conditional rendering in MainScreen. + + bun dev + +Expected: App starts, can toggle setting, layout switches + +**Step 6: Full validation** + + bun run lint:fix + bun run typecheck + bun test + +Expected: All pass + +--- + +## Validation and Acceptance + +### Manual Testing Checklist + +1. **Setting toggle works** + - Open Settings > Behavior + - See "Navigation style" option + - Toggle between "Top bar" and "Sidebar" + - Layout changes immediately (or after brief transition) + +2. **Sidebar mode displays correctly** + - WorkspaceSidebar appears on left + - Projects shown as collapsible sections + - Workspaces listed under each project + - Active workspace has colored left border + - Status badges visible + - Diff stats visible for active workspace + - ⌘1-9 shortcuts displayed + +3. **Interactions work** + - Click workspace to switch + - Click project header to collapse/expand + - Hover shows preview card + - ⌘1-9 switches workspaces + - "+ New workspace" opens creation dialog + - "Add project" opens project creation + +4. **TopBar adapts** + - In sidebar mode: No workspace tabs, unified bar with Workbench/Review toggle + - In top-bar mode: Original layout preserved + +5. **Persistence** + - Close and reopen app + - Navigation style preserved + - Sidebar widths preserved + - Collapsed projects preserved + +6. **Both sidebars coexist** + - Workspace sidebar (left) + - Changes sidebar (right of workspace sidebar) + - Both independently resizable + - Both can be toggled independently + +--- + +## Idempotence and Recovery + +- Database schema changes are additive (new nullable column) +- Running `db:push` multiple times is safe +- Component files are new additions, no destructive changes +- Setting defaults to "top-bar" if not set (backwards compatible) +- If implementation fails partway, the existing top-bar mode continues working + +--- + +## Artifacts and Notes + +### Component File Structure + + apps/desktop/src/renderer/ + ├── hooks/ + │ └── useWorkspaceShortcuts.ts (new - shared ⌘1-9 + auto-create logic) + ├── screens/main/components/ + │ ├── WorkspaceSidebar/ + │ │ ├── index.tsx + │ │ ├── WorkspaceSidebarHeader.tsx + │ │ ├── WorkspaceSidebarFooter.tsx + │ │ ├── ResizableWorkspaceSidebar.tsx (wrapper with resize handle) + │ │ ├── ProjectSection/ + │ │ │ ├── ProjectSection.tsx + │ │ │ ├── ProjectHeader.tsx + │ │ │ └── index.ts + │ │ └── WorkspaceListItem/ + │ │ ├── WorkspaceListItem.tsx + │ │ ├── WorkspaceStatusBadge.tsx + │ │ ├── WorkspaceDiffStats.tsx + │ │ └── index.ts + │ └── TopBar/ + │ ├── index.tsx (modified - conditional render) + │ ├── TopBarSidebarMode.tsx (new) + │ ├── TopBarDefault.tsx (renamed from inline JSX) + │ ├── SidebarControl.tsx (updated tooltip: "Toggle files") + │ ├── WorkspaceSidebarControl.tsx (new - "Toggle workspaces") + │ └── ... (existing files) + └── stores/ + └── workspace-sidebar-state.ts (new) + +### State Structure + + // workspace-sidebar-state.ts (Zustand + persist) + { + isOpen: true, + width: 280, // pixels + collapsedProjectIds: ["project-id-1", "project-id-2"], // string[] NOT Set + } + + // settings table (SQLite via local-db) + { + navigationStyle: "sidebar" | "top-bar" + } + +**Important**: Use `string[]` for `collapsedProjectIds`, not `Set`. Zustand persist uses JSON serialization which drops Sets. + +--- + +## Interfaces and Dependencies + +### New tRPC Routes + +In `apps/desktop/src/lib/trpc/routers/settings/index.ts`: + + getNavigationStyle: publicProcedure.query(() => NavigationStyle) + setNavigationStyle: publicProcedure.input({ style: NavigationStyle }).mutation() + +### New Zustand Store + +In `apps/desktop/src/renderer/stores/workspace-sidebar-state.ts`: + + export const useWorkspaceSidebarStore = create()( + devtools( + persist( + (set, get) => ({ + isOpen: true, + width: 280, + collapsedProjectIds: [], // string[] for JSON serialization + + toggleOpen: () => set((s) => ({ isOpen: !s.isOpen })), + + setWidth: (width) => set({ width }), + + toggleProjectCollapsed: (projectId) => + set((s) => ({ + collapsedProjectIds: s.collapsedProjectIds.includes(projectId) + ? s.collapsedProjectIds.filter((id) => id !== projectId) + : [...s.collapsedProjectIds, projectId], + })), + + isProjectCollapsed: (projectId) => + get().collapsedProjectIds.includes(projectId), + }), + { name: "workspace-sidebar-store" } + ) + ) + ); + +### New Shared Hook + +In `apps/desktop/src/renderer/hooks/useWorkspaceShortcuts.ts`: + + export function useWorkspaceShortcuts() { + // Extract from WorkspacesTabs: ⌘1-9 shortcuts + auto-create logic + // Used by BOTH WorkspaceSidebar and WorkspacesTabs + } + +### Component Props + + interface WorkspaceListItemProps { + workspace: { + id: string; + name: string; + branch: string; + worktreePath: string; + type: "worktree" | "branch"; + projectId: string; + }; + project: { + id: string; + name: string; + color: string; + }; + isActive: boolean; + index: number; // for ⌘N shortcut display + onSelect: () => void; + onHover: () => void; + } + +--- + +## Dependencies on External Data + +The following data is needed for full feature parity with the design: + +1. **PR Status + Diff Stats** - Available via `workspaces.getGitHubStatus` (already used by WorkspaceHoverCard) + - This is the authoritative source for PR additions/deletions + - Do NOT add a new git diff endpoint + +2. **Workspace Status** (uncommitted changes) - Available via changes router + - Fallback for workspaces without PRs + +3. **GitHub Author/Branch** - Extract from PR branch name or remote tracking branch + - Already available in workspace data + +**Performance strategy**: Lazy-load status on hover (matching WorkspaceHoverCard behavior). If batching is needed later, extend `getAllGrouped` to include summary status. diff --git a/apps/desktop/src/lib/trpc/routers/settings/index.ts b/apps/desktop/src/lib/trpc/routers/settings/index.ts index 8c2e5ed6e83..abc5cd8f903 100644 --- a/apps/desktop/src/lib/trpc/routers/settings/index.ts +++ b/apps/desktop/src/lib/trpc/routers/settings/index.ts @@ -6,6 +6,7 @@ import { import { localDb } from "main/lib/local-db"; import { DEFAULT_CONFIRM_ON_QUIT, + DEFAULT_NAVIGATION_STYLE, DEFAULT_TERMINAL_LINK_BEHAVIOR, } from "shared/constants"; import { DEFAULT_RINGTONE_ID, RINGTONES } from "shared/ringtones"; @@ -207,5 +208,25 @@ export const createSettingsRouter = () => { return { success: true }; }), + + getNavigationStyle: publicProcedure.query(() => { + const row = getSettings(); + return row.navigationStyle ?? DEFAULT_NAVIGATION_STYLE; + }), + + setNavigationStyle: publicProcedure + .input(z.object({ style: z.enum(["top-bar", "sidebar"]) })) + .mutation(({ input }) => { + localDb + .insert(settings) + .values({ id: 1, navigationStyle: input.style }) + .onConflictDoUpdate({ + target: settings.id, + set: { navigationStyle: input.style }, + }) + .run(); + + return { success: true }; + }), }); }; diff --git a/apps/desktop/src/renderer/hooks/useWorkspaceShortcuts.ts b/apps/desktop/src/renderer/hooks/useWorkspaceShortcuts.ts new file mode 100644 index 00000000000..cd222045883 --- /dev/null +++ b/apps/desktop/src/renderer/hooks/useWorkspaceShortcuts.ts @@ -0,0 +1,117 @@ +import { useCallback, useEffect, useRef, useState } from "react"; +import { useHotkeys } from "react-hotkeys-hook"; +import { trpc } from "renderer/lib/trpc"; +import { + useCreateBranchWorkspace, + useSetActiveWorkspace, +} from "renderer/react-query/workspaces"; +import { HOTKEYS } from "shared/hotkeys"; + +/** + * Shared hook for workspace keyboard shortcuts and auto-creation logic. + * This hook should be used in both: + * - WorkspacesTabs (top-bar mode) + * - WorkspaceSidebar (sidebar mode) + * + * It handles: + * - ⌘1-9 workspace switching shortcuts + * - Previous/next workspace shortcuts + * - Auto-create main workspace for new projects + */ +export function useWorkspaceShortcuts() { + const { data: groups = [] } = trpc.workspaces.getAllGrouped.useQuery(); + const { data: activeWorkspace } = trpc.workspaces.getActive.useQuery(); + const activeWorkspaceId = activeWorkspace?.id || null; + const setActiveWorkspace = useSetActiveWorkspace(); + const createBranchWorkspace = useCreateBranchWorkspace(); + + // Track projects we've attempted to create workspaces for (persists across renders) + const attemptedProjectsRef = useRef>(new Set()); + const [isCreating, setIsCreating] = useState(false); + + // Auto-create main workspace for new projects (one-time per project) + useEffect(() => { + if (isCreating) return; + + for (const group of groups) { + const projectId = group.project.id; + const hasMainWorkspace = group.workspaces.some( + (w) => w.type === "branch", + ); + + // Skip if already has main workspace or we've already attempted this project + if (hasMainWorkspace || attemptedProjectsRef.current.has(projectId)) { + continue; + } + + // Mark as attempted before creating (prevents retries) + attemptedProjectsRef.current.add(projectId); + setIsCreating(true); + + // Auto-create fails silently - this is a background convenience feature + createBranchWorkspace.mutate( + { projectId }, + { + onSettled: () => { + setIsCreating(false); + }, + }, + ); + // Only create one at a time + break; + } + }, [groups, isCreating, createBranchWorkspace]); + + // Flatten workspaces for keyboard navigation + const allWorkspaces = groups.flatMap((group) => group.workspaces); + + // Workspace switching shortcuts (⌘+1-9) + const workspaceKeys = Array.from( + { length: 9 }, + (_, i) => `meta+${i + 1}`, + ).join(", "); + + const handleWorkspaceSwitch = useCallback( + (event: KeyboardEvent) => { + const num = Number(event.key); + if (num >= 1 && num <= 9) { + const workspace = allWorkspaces[num - 1]; + if (workspace) { + setActiveWorkspace.mutate({ id: workspace.id }); + } + } + }, + [allWorkspaces, setActiveWorkspace], + ); + + const handlePrevWorkspace = useCallback(() => { + if (!activeWorkspaceId) return; + const currentIndex = allWorkspaces.findIndex( + (w) => w.id === activeWorkspaceId, + ); + if (currentIndex > 0) { + setActiveWorkspace.mutate({ id: allWorkspaces[currentIndex - 1].id }); + } + }, [activeWorkspaceId, allWorkspaces, setActiveWorkspace]); + + const handleNextWorkspace = useCallback(() => { + if (!activeWorkspaceId) return; + const currentIndex = allWorkspaces.findIndex( + (w) => w.id === activeWorkspaceId, + ); + if (currentIndex < allWorkspaces.length - 1) { + setActiveWorkspace.mutate({ id: allWorkspaces[currentIndex + 1].id }); + } + }, [activeWorkspaceId, allWorkspaces, setActiveWorkspace]); + + useHotkeys(workspaceKeys, handleWorkspaceSwitch); + useHotkeys(HOTKEYS.PREV_WORKSPACE.keys, handlePrevWorkspace); + useHotkeys(HOTKEYS.NEXT_WORKSPACE.keys, handleNextWorkspace); + + return { + groups, + allWorkspaces, + activeWorkspaceId, + setActiveWorkspace, + }; +} diff --git a/apps/desktop/src/renderer/screens/main/components/SettingsView/BehaviorSettings.tsx b/apps/desktop/src/renderer/screens/main/components/SettingsView/BehaviorSettings.tsx index bdc930ec4f0..bbcd9c9d80f 100644 --- a/apps/desktop/src/renderer/screens/main/components/SettingsView/BehaviorSettings.tsx +++ b/apps/desktop/src/renderer/screens/main/components/SettingsView/BehaviorSettings.tsx @@ -10,33 +10,52 @@ import { import { Switch } from "@superset/ui/switch"; import { trpc } from "renderer/lib/trpc"; +type NavigationStyle = "top-bar" | "sidebar"; + export function BehaviorSettings() { const utils = trpc.useUtils(); - const { data: confirmOnQuit, isLoading } = + + // Confirm on quit setting + const { data: confirmOnQuit, isLoading: isConfirmLoading } = trpc.settings.getConfirmOnQuit.useQuery(); const setConfirmOnQuit = trpc.settings.setConfirmOnQuit.useMutation({ onMutate: async ({ enabled }) => { - // Cancel outgoing fetches await utils.settings.getConfirmOnQuit.cancel(); - // Snapshot previous value const previous = utils.settings.getConfirmOnQuit.getData(); - // Optimistically update utils.settings.getConfirmOnQuit.setData(undefined, enabled); return { previous }; }, onError: (_err, _vars, context) => { - // Rollback on error if (context?.previous !== undefined) { utils.settings.getConfirmOnQuit.setData(undefined, context.previous); } }, onSettled: () => { - // Refetch to ensure sync with server utils.settings.getConfirmOnQuit.invalidate(); }, }); - const handleToggle = (enabled: boolean) => { + // Navigation style setting + const { data: navigationStyle, isLoading: isNavLoading } = + trpc.settings.getNavigationStyle.useQuery(); + const setNavigationStyle = trpc.settings.setNavigationStyle.useMutation({ + onMutate: async ({ style }) => { + await utils.settings.getNavigationStyle.cancel(); + const previous = utils.settings.getNavigationStyle.getData(); + utils.settings.getNavigationStyle.setData(undefined, style); + return { previous }; + }, + onError: (_err, _vars, context) => { + if (context?.previous !== undefined) { + utils.settings.getNavigationStyle.setData(undefined, context.previous); + } + }, + onSettled: () => { + utils.settings.getNavigationStyle.invalidate(); + }, + }); + + const handleConfirmToggle = (enabled: boolean) => { setConfirmOnQuit.mutate({ enabled }); }; @@ -71,6 +90,10 @@ export function BehaviorSettings() { }); }; + const handleNavigationStyleChange = (style: NavigationStyle) => { + setNavigationStyle.mutate({ style }); + }; + return (
@@ -81,6 +104,32 @@ export function BehaviorSettings() {
+ {/* Navigation Style */} +
+
+ +

+ Choose how workspaces are displayed +

+
+ +
+ + {/* Confirm on Quit */}
diff --git a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceSidebarControl.tsx b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceSidebarControl.tsx new file mode 100644 index 00000000000..9f73f0e465b --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceSidebarControl.tsx @@ -0,0 +1,40 @@ +import { Button } from "@superset/ui/button"; +import { Kbd, KbdGroup } from "@superset/ui/kbd"; +import { Tooltip, TooltipContent, TooltipTrigger } from "@superset/ui/tooltip"; +import { LuPanelLeft, LuPanelLeftClose } from "react-icons/lu"; +import { useWorkspaceSidebarStore } from "renderer/stores"; +import { HOTKEYS } from "shared/hotkeys"; + +export function WorkspaceSidebarControl() { + const { isOpen, toggleOpen } = useWorkspaceSidebarStore(); + + return ( + + + + + + + Toggle Workspaces + + {HOTKEYS.TOGGLE_WORKSPACE_SIDEBAR.display.map((key) => ( + {key} + ))} + + + + + ); +} diff --git a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/index.tsx b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/index.tsx index 27c58551259..8c8455c85ad 100644 --- a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/index.tsx +++ b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/index.tsx @@ -1,14 +1,9 @@ -import { Fragment, useCallback, useEffect, useRef, useState } from "react"; -import { trpc } from "renderer/lib/trpc"; -import { - useCreateBranchWorkspace, - useSetActiveWorkspace, -} from "renderer/react-query/workspaces"; +import { Fragment, useEffect, useRef, useState } from "react"; +import { useWorkspaceShortcuts } from "renderer/hooks/useWorkspaceShortcuts"; import { useCurrentView, useIsSettingsTabOpen, } from "renderer/stores/app-state"; -import { useAppHotkey } from "renderer/stores/hotkeys"; import { CreateWorkspaceButton } from "./CreateWorkspaceButton"; import { SettingsTab } from "./SettingsTab"; import { WorkspaceGroup } from "./WorkspaceGroup"; @@ -18,11 +13,9 @@ const MAX_WORKSPACE_WIDTH = 160; const ADD_BUTTON_WIDTH = 40; export function WorkspacesTabs() { - const { data: groups = [] } = trpc.workspaces.getAllGrouped.useQuery(); - const { data: activeWorkspace } = trpc.workspaces.getActive.useQuery(); - const activeWorkspaceId = activeWorkspace?.id || null; - const setActiveWorkspace = useSetActiveWorkspace(); - const createBranchWorkspace = useCreateBranchWorkspace(); + // Use shared hook for workspace shortcuts and auto-create logic + const { groups, allWorkspaces, activeWorkspaceId } = useWorkspaceShortcuts(); + const currentView = useCurrentView(); const isSettingsTabOpen = useIsSettingsTabOpen(); const isSettingsActive = currentView === "settings"; @@ -35,140 +28,6 @@ export function WorkspacesTabs() { null, ); - // Track projects we've attempted to create workspaces for (persists across renders) - // Using ref to avoid re-triggering the effect - const attemptedProjectsRef = useRef>(new Set()); - const [isCreating, setIsCreating] = useState(false); - - // Auto-create main workspace for new projects (one-time per project) - // This only runs for projects we haven't attempted yet - useEffect(() => { - if (isCreating) return; - - for (const group of groups) { - const projectId = group.project.id; - const hasMainWorkspace = group.workspaces.some( - (w) => w.type === "branch", - ); - - // Skip if already has main workspace or we've already attempted this project - if (hasMainWorkspace || attemptedProjectsRef.current.has(projectId)) { - continue; - } - - // Mark as attempted before creating (prevents retries) - attemptedProjectsRef.current.add(projectId); - setIsCreating(true); - - // Auto-create fails silently - this is a background convenience feature - // Users can manually create the workspace via the dropdown if needed - createBranchWorkspace.mutate( - { projectId }, - { - onSettled: () => { - setIsCreating(false); - }, - }, - ); - // Only create one at a time - break; - } - }, [groups, isCreating, createBranchWorkspace]); - - // Flatten workspaces for keyboard navigation - const allWorkspaces = groups.flatMap((group) => group.workspaces); - - const handleWorkspaceSwitch = useCallback( - (index: number) => { - const workspace = allWorkspaces[index]; - if (workspace) { - setActiveWorkspace.mutate({ id: workspace.id }); - } - }, - [allWorkspaces, setActiveWorkspace], - ); - - const handlePrevWorkspace = useCallback(() => { - if (!activeWorkspaceId) return; - const currentIndex = allWorkspaces.findIndex( - (w) => w.id === activeWorkspaceId, - ); - if (currentIndex > 0) { - setActiveWorkspace.mutate({ id: allWorkspaces[currentIndex - 1].id }); - } - }, [activeWorkspaceId, allWorkspaces, setActiveWorkspace]); - - const handleNextWorkspace = useCallback(() => { - if (!activeWorkspaceId) return; - const currentIndex = allWorkspaces.findIndex( - (w) => w.id === activeWorkspaceId, - ); - if (currentIndex < allWorkspaces.length - 1) { - setActiveWorkspace.mutate({ id: allWorkspaces[currentIndex + 1].id }); - } - }, [activeWorkspaceId, allWorkspaces, setActiveWorkspace]); - - useAppHotkey( - "JUMP_TO_WORKSPACE_1", - () => handleWorkspaceSwitch(0), - undefined, - [handleWorkspaceSwitch], - ); - useAppHotkey( - "JUMP_TO_WORKSPACE_2", - () => handleWorkspaceSwitch(1), - undefined, - [handleWorkspaceSwitch], - ); - useAppHotkey( - "JUMP_TO_WORKSPACE_3", - () => handleWorkspaceSwitch(2), - undefined, - [handleWorkspaceSwitch], - ); - useAppHotkey( - "JUMP_TO_WORKSPACE_4", - () => handleWorkspaceSwitch(3), - undefined, - [handleWorkspaceSwitch], - ); - useAppHotkey( - "JUMP_TO_WORKSPACE_5", - () => handleWorkspaceSwitch(4), - undefined, - [handleWorkspaceSwitch], - ); - useAppHotkey( - "JUMP_TO_WORKSPACE_6", - () => handleWorkspaceSwitch(5), - undefined, - [handleWorkspaceSwitch], - ); - useAppHotkey( - "JUMP_TO_WORKSPACE_7", - () => handleWorkspaceSwitch(6), - undefined, - [handleWorkspaceSwitch], - ); - useAppHotkey( - "JUMP_TO_WORKSPACE_8", - () => handleWorkspaceSwitch(7), - undefined, - [handleWorkspaceSwitch], - ); - useAppHotkey( - "JUMP_TO_WORKSPACE_9", - () => handleWorkspaceSwitch(8), - undefined, - [handleWorkspaceSwitch], - ); - useAppHotkey("PREV_WORKSPACE", handlePrevWorkspace, undefined, [ - handlePrevWorkspace, - ]); - useAppHotkey("NEXT_WORKSPACE", handleNextWorkspace, undefined, [ - handleNextWorkspace, - ]); - useEffect(() => { const checkScroll = () => { if (!scrollRef.current) return; diff --git a/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx b/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx index d5f1132cc2d..2441e996563 100644 --- a/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx +++ b/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx @@ -1,25 +1,49 @@ +import type { NavigationStyle } from "@superset/local-db"; import { trpc } from "renderer/lib/trpc"; import { AvatarDropdown } from "../AvatarDropdown"; import { SidebarControl } from "./SidebarControl"; import { WindowControls } from "./WindowControls"; +import { WorkspaceSidebarControl } from "./WorkspaceSidebarControl"; import { WorkspacesTabs } from "./WorkspaceTabs"; -export function TopBar() { +interface TopBarProps { + navigationStyle?: NavigationStyle; +} + +export function TopBar({ navigationStyle = "top-bar" }: TopBarProps) { const { data: platform } = trpc.window.getPlatform.useQuery(); + const { data: activeWorkspace } = trpc.workspaces.getActive.useQuery(); const isMac = platform === "darwin"; + const isSidebarMode = navigationStyle === "sidebar"; + return ( -
+
+ {isSidebarMode && }
-
- -
+ + {isSidebarMode ? ( +
+ {activeWorkspace && ( + + {activeWorkspace.project?.name ?? "Workspace"} + / + {activeWorkspace.name} + + )} +
+ ) : ( +
+ +
+ )} +
{!isMac && } diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/ProjectSection/ProjectHeader.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/ProjectSection/ProjectHeader.tsx new file mode 100644 index 00000000000..85a1fe3d72a --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/ProjectSection/ProjectHeader.tsx @@ -0,0 +1,42 @@ +import { cn } from "@superset/ui/utils"; +import { LuChevronDown, LuChevronRight } from "react-icons/lu"; + +interface ProjectHeaderProps { + projectName: string; + projectColor: string; + isCollapsed: boolean; + onToggleCollapse: () => void; + workspaceCount: number; +} + +export function ProjectHeader({ + projectName, + projectColor, + isCollapsed, + onToggleCollapse, + workspaceCount, +}: ProjectHeaderProps) { + return ( + + ); +} diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/ProjectSection/ProjectSection.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/ProjectSection/ProjectSection.tsx new file mode 100644 index 00000000000..41a5e5f9e20 --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/ProjectSection/ProjectSection.tsx @@ -0,0 +1,76 @@ +import { AnimatePresence, motion } from "framer-motion"; +import { useWorkspaceSidebarStore } from "renderer/stores"; +import { WorkspaceListItem } from "../WorkspaceListItem"; +import { ProjectHeader } from "./ProjectHeader"; + +interface Workspace { + id: string; + projectId: string; + worktreePath: string; + type: "worktree" | "branch"; + branch: string; + name: string; + tabOrder: number; +} + +interface ProjectSectionProps { + projectId: string; + projectName: string; + projectColor: string; + workspaces: Workspace[]; + activeWorkspaceId: string | null; + /** Base index for keyboard shortcuts (0-based) */ + shortcutBaseIndex: number; +} + +export function ProjectSection({ + projectId, + projectName, + projectColor, + workspaces, + activeWorkspaceId, + shortcutBaseIndex, +}: ProjectSectionProps) { + const { isProjectCollapsed, toggleProjectCollapsed } = + useWorkspaceSidebarStore(); + + const isCollapsed = isProjectCollapsed(projectId); + + return ( +
+ toggleProjectCollapsed(projectId)} + workspaceCount={workspaces.length} + /> + + + {!isCollapsed && ( + +
+ {workspaces.map((workspace, index) => ( + + ))} +
+ + )} + +
+ ); +} diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/ProjectSection/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/ProjectSection/index.ts new file mode 100644 index 00000000000..2111af01d6b --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/ProjectSection/index.ts @@ -0,0 +1,2 @@ +export { ProjectHeader } from "./ProjectHeader"; +export { ProjectSection } from "./ProjectSection"; diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/ResizableWorkspaceSidebar.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/ResizableWorkspaceSidebar.tsx new file mode 100644 index 00000000000..526fa283d2c --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/ResizableWorkspaceSidebar.tsx @@ -0,0 +1,94 @@ +import { cn } from "@superset/ui/utils"; +import { useCallback, useEffect, useRef } from "react"; +import { + MAX_WORKSPACE_SIDEBAR_WIDTH, + MIN_WORKSPACE_SIDEBAR_WIDTH, + useWorkspaceSidebarStore, +} from "renderer/stores"; +import { WorkspaceSidebar } from "./WorkspaceSidebar"; + +export function ResizableWorkspaceSidebar() { + const { isOpen, width, setWidth, isResizing, setIsResizing } = + useWorkspaceSidebarStore(); + + const startXRef = useRef(0); + const startWidthRef = useRef(0); + + const handleMouseDown = useCallback( + (e: React.MouseEvent) => { + e.preventDefault(); + startXRef.current = e.clientX; + startWidthRef.current = width; + setIsResizing(true); + }, + [width, setIsResizing], + ); + + const handleMouseMove = useCallback( + (e: MouseEvent) => { + if (!isResizing) return; + + const delta = e.clientX - startXRef.current; + const newWidth = startWidthRef.current + delta; + const clampedWidth = Math.max( + MIN_WORKSPACE_SIDEBAR_WIDTH, + Math.min(MAX_WORKSPACE_SIDEBAR_WIDTH, newWidth), + ); + setWidth(clampedWidth); + }, + [isResizing, setWidth], + ); + + const handleMouseUp = useCallback(() => { + if (isResizing) { + setIsResizing(false); + } + }, [isResizing, setIsResizing]); + + useEffect(() => { + if (isResizing) { + document.addEventListener("mousemove", handleMouseMove); + document.addEventListener("mouseup", handleMouseUp); + document.body.style.userSelect = "none"; + document.body.style.cursor = "col-resize"; + } + + return () => { + document.removeEventListener("mousemove", handleMouseMove); + document.removeEventListener("mouseup", handleMouseUp); + document.body.style.userSelect = ""; + document.body.style.cursor = ""; + }; + }, [isResizing, handleMouseMove, handleMouseUp]); + + if (!isOpen) { + return null; + } + + return ( +
+ + + {/* Resize handle */} + {/* biome-ignore lint/a11y/useSemanticElements:
is not appropriate for interactive resize handles */} +
+
+ ); +} diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceDiffStats.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceDiffStats.tsx new file mode 100644 index 00000000000..a2758d40b01 --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceDiffStats.tsx @@ -0,0 +1,16 @@ +interface WorkspaceDiffStatsProps { + additions: number; + deletions: number; +} + +export function WorkspaceDiffStats({ + additions, + deletions, +}: WorkspaceDiffStatsProps) { + return ( +
+ +{additions} + -{deletions} +
+ ); +} diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx new file mode 100644 index 00000000000..a819fbb3413 --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx @@ -0,0 +1,104 @@ +import { cn } from "@superset/ui/utils"; +import { useState } from "react"; +import { LuGitBranch } from "react-icons/lu"; +import { trpc } from "renderer/lib/trpc"; +import { useSetActiveWorkspace } from "renderer/react-query/workspaces"; +import { WorkspaceDiffStats } from "./WorkspaceDiffStats"; +import { WorkspaceStatusBadge } from "./WorkspaceStatusBadge"; + +interface WorkspaceListItemProps { + id: string; + name: string; + branch: string; + type: "worktree" | "branch"; + isActive: boolean; + shortcutIndex?: number; +} + +export function WorkspaceListItem({ + id, + name, + branch, + type, + isActive, + shortcutIndex, +}: WorkspaceListItemProps) { + const setActiveWorkspace = useSetActiveWorkspace(); + const [hasHovered, setHasHovered] = useState(false); + + // Lazy-load GitHub status on hover to avoid N+1 queries + const { data: githubStatus } = trpc.workspaces.getGitHubStatus.useQuery( + { workspaceId: id }, + { + enabled: hasHovered && type === "worktree", + staleTime: 30_000, + }, + ); + + const handleClick = () => { + setActiveWorkspace.mutate({ id }); + }; + + const handleMouseEnter = () => { + if (!hasHovered) { + setHasHovered(true); + } + }; + + const pr = githubStatus?.pr; + const showDiffStats = pr && (pr.additions > 0 || pr.deletions > 0); + + return ( + + ); +} diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceStatusBadge.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceStatusBadge.tsx new file mode 100644 index 00000000000..d6eb509d730 --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceStatusBadge.tsx @@ -0,0 +1,53 @@ +import { cn } from "@superset/ui/utils"; +import { LuCircleDot, LuGitMerge, LuGitPullRequest } from "react-icons/lu"; + +type PRState = "open" | "merged" | "closed" | "draft"; + +interface WorkspaceStatusBadgeProps { + state: PRState; + prNumber?: number; +} + +export function WorkspaceStatusBadge({ + state, + prNumber, +}: WorkspaceStatusBadgeProps) { + const iconClass = "w-3 h-3"; + + const config = { + open: { + icon: , + bgColor: "bg-emerald-500/10", + }, + merged: { + icon: , + bgColor: "bg-purple-500/10", + }, + closed: { + icon: , + bgColor: "bg-destructive/10", + }, + draft: { + icon: ( + + ), + bgColor: "bg-muted", + }, + }; + + const { icon, bgColor } = config[state]; + + return ( +
+ {icon} + {prNumber && ( + #{prNumber} + )} +
+ ); +} diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/index.ts new file mode 100644 index 00000000000..4dd9ef18a6e --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/index.ts @@ -0,0 +1,3 @@ +export { WorkspaceDiffStats } from "./WorkspaceDiffStats"; +export { WorkspaceListItem } from "./WorkspaceListItem"; +export { WorkspaceStatusBadge } from "./WorkspaceStatusBadge"; diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceSidebar.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceSidebar.tsx new file mode 100644 index 00000000000..c4d68290bfb --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceSidebar.tsx @@ -0,0 +1,45 @@ +import { useWorkspaceShortcuts } from "renderer/hooks/useWorkspaceShortcuts"; +import { ProjectSection } from "./ProjectSection"; +import { WorkspaceSidebarFooter } from "./WorkspaceSidebarFooter"; +import { WorkspaceSidebarHeader } from "./WorkspaceSidebarHeader"; + +export function WorkspaceSidebar() { + const { groups, activeWorkspaceId } = useWorkspaceShortcuts(); + + // Calculate shortcut base indices for each project group + let shortcutIndex = 0; + const projectShortcutIndices = groups.map((group) => { + const baseIndex = shortcutIndex; + shortcutIndex += group.workspaces.length; + return baseIndex; + }); + + return ( +
+ + +
+ {groups.map((group, index) => ( + + ))} + + {groups.length === 0 && ( +
+ No workspaces yet + Add a project to get started +
+ )} +
+ + +
+ ); +} diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceSidebarFooter.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceSidebarFooter.tsx new file mode 100644 index 00000000000..99c4117a96d --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceSidebarFooter.tsx @@ -0,0 +1,62 @@ +import { Button } from "@superset/ui/button"; +import { toast } from "@superset/ui/sonner"; +import { LuFolderPlus } from "react-icons/lu"; +import { useOpenNew } from "renderer/react-query/projects"; +import { useCreateBranchWorkspace } from "renderer/react-query/workspaces"; + +export function WorkspaceSidebarFooter() { + const openNew = useOpenNew(); + const createBranchWorkspace = useCreateBranchWorkspace(); + + const handleOpenNewProject = async () => { + try { + const result = await openNew.mutateAsync(undefined); + if (result.canceled) { + return; + } + if ("error" in result) { + toast.error("Failed to open project", { + description: result.error, + }); + return; + } + if ("needsGitInit" in result) { + toast.error("Selected folder is not a git repository", { + description: + "Please use 'Open project' from the start view to initialize git.", + }); + return; + } + // Create a main workspace on the current branch for the new project + toast.promise( + createBranchWorkspace.mutateAsync({ projectId: result.project.id }), + { + loading: "Opening project...", + success: "Project opened", + error: (err) => + err instanceof Error ? err.message : "Failed to open project", + }, + ); + } catch (error) { + toast.error("Failed to open project", { + description: + error instanceof Error ? error.message : "An unknown error occurred", + }); + } + }; + + return ( +
+ +
+ ); +} diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceSidebarHeader.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceSidebarHeader.tsx new file mode 100644 index 00000000000..bc54cd8e98b --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceSidebarHeader.tsx @@ -0,0 +1,10 @@ +import { LuLayers } from "react-icons/lu"; + +export function WorkspaceSidebarHeader() { + return ( +
+ + Workspaces +
+ ); +} diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/index.ts new file mode 100644 index 00000000000..d8dc226739d --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/index.ts @@ -0,0 +1,2 @@ +export { ResizableWorkspaceSidebar } from "./ResizableWorkspaceSidebar"; +export { WorkspaceSidebar } from "./WorkspaceSidebar"; diff --git a/apps/desktop/src/renderer/screens/main/index.tsx b/apps/desktop/src/renderer/screens/main/index.tsx index 98f2cc947a2..0e3ebeb0996 100644 --- a/apps/desktop/src/renderer/screens/main/index.tsx +++ b/apps/desktop/src/renderer/screens/main/index.tsx @@ -2,6 +2,7 @@ import { FEATURE_FLAGS } from "@superset/shared/constants"; import { Button } from "@superset/ui/button"; import { useFeatureFlagEnabled } from "posthog-js/react"; import { useCallback, useState } from "react"; +import { useHotkeys } from "react-hotkeys-hook"; import { DndProvider } from "react-dnd"; import { HiArrowPath } from "react-icons/hi2"; import { NewWorkspaceModal } from "renderer/components/NewWorkspaceModal"; @@ -19,6 +20,9 @@ import { useTabsStore } from "renderer/stores/tabs/store"; import type { Tab } from "renderer/stores/tabs/types"; import { useAgentHookListener } from "renderer/stores/tabs/useAgentHookListener"; import { findPanePath, getFirstPaneId } from "renderer/stores/tabs/utils"; +import { useWorkspaceSidebarStore } from "renderer/stores/workspace-sidebar-state"; +import { DEFAULT_NAVIGATION_STYLE } from "shared/constants"; +import { HOTKEYS } from "shared/hotkeys"; import { dragDropManager } from "../../lib/dnd"; import { AppFrame } from "./components/AppFrame"; import { Background } from "./components/Background"; @@ -26,6 +30,7 @@ import { SettingsView } from "./components/SettingsView"; import { StartView } from "./components/StartView"; import { TasksView } from "./components/TasksView"; import { TopBar } from "./components/TopBar"; +import { ResizableWorkspaceSidebar } from "./components/WorkspaceSidebar"; import { WorkspaceView } from "./components/WorkspaceView"; function LoadingSpinner() { @@ -57,9 +62,15 @@ export function MainScreen() { const currentView = useCurrentView(); const openSettings = useOpenSettings(); const { toggleSidebar } = useSidebarStore(); + const { toggleOpen: toggleWorkspaceSidebar } = useWorkspaceSidebarStore(); const hasTasksAccess = useFeatureFlagEnabled( FEATURE_FLAGS.ELECTRIC_TASKS_ACCESS, ); + + // Navigation style setting + const { data: navigationStyle } = trpc.settings.getNavigationStyle.useQuery(); + const effectiveNavigationStyle = navigationStyle ?? DEFAULT_NAVIGATION_STYLE; + const isSidebarMode = effectiveNavigationStyle === "sidebar"; const { data: activeWorkspace, isLoading: isWorkspaceLoading, @@ -111,6 +122,10 @@ export function MainScreen() { [toggleSidebar, isWorkspaceView], ); + useHotkeys(HOTKEYS.TOGGLE_WORKSPACE_SIDEBAR.keys, () => { + if (isSidebarMode) toggleWorkspaceSidebar(); + }, [toggleWorkspaceSidebar, isSidebarMode]); + /** * Resolves the target pane for split operations. * If the focused pane is desynced from layout (e.g., was removed), @@ -336,8 +351,11 @@ export function MainScreen() { ) : (
- -
{renderContent()}
+ +
+ {isSidebarMode && } + {renderContent()} +
)} diff --git a/apps/desktop/src/renderer/stores/index.ts b/apps/desktop/src/renderer/stores/index.ts index 886d0523e00..8d3726bd2c1 100644 --- a/apps/desktop/src/renderer/stores/index.ts +++ b/apps/desktop/src/renderer/stores/index.ts @@ -6,4 +6,5 @@ export * from "./ringtone"; export * from "./sidebar-state"; export * from "./tabs"; export * from "./theme"; +export * from "./workspace-sidebar-state"; export * from "./workspace-view-mode"; diff --git a/apps/desktop/src/renderer/stores/workspace-sidebar-state.ts b/apps/desktop/src/renderer/stores/workspace-sidebar-state.ts new file mode 100644 index 00000000000..5093f7d3997 --- /dev/null +++ b/apps/desktop/src/renderer/stores/workspace-sidebar-state.ts @@ -0,0 +1,97 @@ +import { create } from "zustand"; +import { devtools, persist } from "zustand/middleware"; + +const DEFAULT_WORKSPACE_SIDEBAR_WIDTH = 280; +export const MIN_WORKSPACE_SIDEBAR_WIDTH = 220; +export const MAX_WORKSPACE_SIDEBAR_WIDTH = 400; + +interface WorkspaceSidebarState { + isOpen: boolean; + width: number; + lastOpenWidth: number; + // Use string[] instead of Set for JSON serialization with Zustand persist + collapsedProjectIds: string[]; + isResizing: boolean; + + toggleOpen: () => void; + setOpen: (open: boolean) => void; + setWidth: (width: number) => void; + setIsResizing: (isResizing: boolean) => void; + toggleProjectCollapsed: (projectId: string) => void; + isProjectCollapsed: (projectId: string) => boolean; +} + +export const useWorkspaceSidebarStore = create()( + devtools( + persist( + (set, get) => ({ + isOpen: true, + width: DEFAULT_WORKSPACE_SIDEBAR_WIDTH, + lastOpenWidth: DEFAULT_WORKSPACE_SIDEBAR_WIDTH, + collapsedProjectIds: [], + isResizing: false, + + toggleOpen: () => { + const { isOpen, lastOpenWidth } = get(); + if (isOpen) { + set({ isOpen: false, width: 0 }); + } else { + set({ + isOpen: true, + width: lastOpenWidth, + }); + } + }, + + setOpen: (open) => { + const { lastOpenWidth } = get(); + set({ + isOpen: open, + width: open ? lastOpenWidth : 0, + }); + }, + + setWidth: (width) => { + const clampedWidth = Math.max( + MIN_WORKSPACE_SIDEBAR_WIDTH, + Math.min(MAX_WORKSPACE_SIDEBAR_WIDTH, width), + ); + + if (width > 0) { + set({ + width: clampedWidth, + lastOpenWidth: clampedWidth, + isOpen: true, + }); + } else { + set({ + width: 0, + isOpen: false, + }); + } + }, + + setIsResizing: (isResizing) => { + set({ isResizing }); + }, + + toggleProjectCollapsed: (projectId) => { + set((state) => ({ + collapsedProjectIds: state.collapsedProjectIds.includes(projectId) + ? state.collapsedProjectIds.filter((id) => id !== projectId) + : [...state.collapsedProjectIds, projectId], + })); + }, + + isProjectCollapsed: (projectId) => { + return get().collapsedProjectIds.includes(projectId); + }, + }), + { + name: "workspace-sidebar-store", + version: 1, + }, + ), + { name: "WorkspaceSidebarStore" }, + ), +); diff --git a/apps/desktop/src/shared/constants.ts b/apps/desktop/src/shared/constants.ts index 1ec904ae1fc..35c6207de41 100644 --- a/apps/desktop/src/shared/constants.ts +++ b/apps/desktop/src/shared/constants.ts @@ -47,3 +47,4 @@ export const NOTIFICATION_EVENTS = { // Default user preference values export const DEFAULT_CONFIRM_ON_QUIT = true; export const DEFAULT_TERMINAL_LINK_BEHAVIOR = "external-editor" as const; +export const DEFAULT_NAVIGATION_STYLE = "top-bar" as const; diff --git a/apps/desktop/src/shared/hotkeys.ts b/apps/desktop/src/shared/hotkeys.ts index c4e38007bbe..b650d06d791 100644 --- a/apps/desktop/src/shared/hotkeys.ts +++ b/apps/desktop/src/shared/hotkeys.ts @@ -423,7 +423,12 @@ export const HOTKEYS = { // Layout TOGGLE_SIDEBAR: defineHotkey({ keys: "meta+b", - label: "Toggle Sidebar", + label: "Toggle Files Sidebar", + category: "Layout", + }), + TOGGLE_WORKSPACE_SIDEBAR: hotkey({ + keys: "meta+shift+b", + label: "Toggle Workspaces Sidebar", category: "Layout", }), SPLIT_RIGHT: defineHotkey({ diff --git a/packages/local-db/drizzle/0005_add_navigation_style.sql b/packages/local-db/drizzle/0005_add_navigation_style.sql new file mode 100644 index 00000000000..c3c175a0327 --- /dev/null +++ b/packages/local-db/drizzle/0005_add_navigation_style.sql @@ -0,0 +1 @@ +ALTER TABLE `settings` ADD `navigation_style` text; \ No newline at end of file diff --git a/packages/local-db/drizzle/meta/0005_snapshot.json b/packages/local-db/drizzle/meta/0005_snapshot.json new file mode 100644 index 00000000000..14c02c328fd --- /dev/null +++ b/packages/local-db/drizzle/meta/0005_snapshot.json @@ -0,0 +1,984 @@ +{ + "version": "6", + "dialect": "sqlite", + "id": "ac200b80-657f-4cd7-b338-2d6adeb925e7", + "prevId": "bb9f9f85-bcbb-4003-b20f-4c172a1c6fc8", + "tables": { + "organization_members": { + "name": "organization_members", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "organization_id": { + "name": "organization_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "user_id": { + "name": "user_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "role": { + "name": "role", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + } + }, + "indexes": { + "organization_members_organization_id_idx": { + "name": "organization_members_organization_id_idx", + "columns": [ + "organization_id" + ], + "isUnique": false + }, + "organization_members_user_id_idx": { + "name": "organization_members_user_id_idx", + "columns": [ + "user_id" + ], + "isUnique": false + } + }, + "foreignKeys": { + "organization_members_organization_id_organizations_id_fk": { + "name": "organization_members_organization_id_organizations_id_fk", + "tableFrom": "organization_members", + "tableTo": "organizations", + "columnsFrom": [ + "organization_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + }, + "organization_members_user_id_users_id_fk": { + "name": "organization_members_user_id_users_id_fk", + "tableFrom": "organization_members", + "tableTo": "users", + "columnsFrom": [ + "user_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "organizations": { + "name": "organizations", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "clerk_org_id": { + "name": "clerk_org_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "name": { + "name": "name", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "slug": { + "name": "slug", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "github_org": { + "name": "github_org", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "avatar_url": { + "name": "avatar_url", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "updated_at": { + "name": "updated_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + } + }, + "indexes": { + "organizations_clerk_org_id_unique": { + "name": "organizations_clerk_org_id_unique", + "columns": [ + "clerk_org_id" + ], + "isUnique": true + }, + "organizations_slug_unique": { + "name": "organizations_slug_unique", + "columns": [ + "slug" + ], + "isUnique": true + }, + "organizations_slug_idx": { + "name": "organizations_slug_idx", + "columns": [ + "slug" + ], + "isUnique": false + }, + "organizations_clerk_org_id_idx": { + "name": "organizations_clerk_org_id_idx", + "columns": [ + "clerk_org_id" + ], + "isUnique": false + } + }, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "projects": { + "name": "projects", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "main_repo_path": { + "name": "main_repo_path", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "name": { + "name": "name", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "color": { + "name": "color", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "tab_order": { + "name": "tab_order", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "last_opened_at": { + "name": "last_opened_at", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "config_toast_dismissed": { + "name": "config_toast_dismissed", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "default_branch": { + "name": "default_branch", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + } + }, + "indexes": { + "projects_main_repo_path_idx": { + "name": "projects_main_repo_path_idx", + "columns": [ + "main_repo_path" + ], + "isUnique": false + }, + "projects_last_opened_at_idx": { + "name": "projects_last_opened_at_idx", + "columns": [ + "last_opened_at" + ], + "isUnique": false + } + }, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "settings": { + "name": "settings", + "columns": { + "id": { + "name": "id", + "type": "integer", + "primaryKey": true, + "notNull": true, + "autoincrement": false, + "default": 1 + }, + "last_active_workspace_id": { + "name": "last_active_workspace_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "last_used_app": { + "name": "last_used_app", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "terminal_presets": { + "name": "terminal_presets", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "terminal_presets_initialized": { + "name": "terminal_presets_initialized", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "selected_ringtone_id": { + "name": "selected_ringtone_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "active_organization_id": { + "name": "active_organization_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "confirm_on_quit": { + "name": "confirm_on_quit", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "terminal_link_behavior": { + "name": "terminal_link_behavior", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "navigation_style": { + "name": "navigation_style", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + } + }, + "indexes": {}, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "tasks": { + "name": "tasks", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "slug": { + "name": "slug", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "title": { + "name": "title", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "description": { + "name": "description", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "status": { + "name": "status", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "status_color": { + "name": "status_color", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "status_type": { + "name": "status_type", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "status_position": { + "name": "status_position", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "priority": { + "name": "priority", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "organization_id": { + "name": "organization_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "repository_id": { + "name": "repository_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "assignee_id": { + "name": "assignee_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "creator_id": { + "name": "creator_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "estimate": { + "name": "estimate", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "due_date": { + "name": "due_date", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "labels": { + "name": "labels", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "branch": { + "name": "branch", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "pr_url": { + "name": "pr_url", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "external_provider": { + "name": "external_provider", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "external_id": { + "name": "external_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "external_key": { + "name": "external_key", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "external_url": { + "name": "external_url", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "last_synced_at": { + "name": "last_synced_at", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "sync_error": { + "name": "sync_error", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "started_at": { + "name": "started_at", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "completed_at": { + "name": "completed_at", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "deleted_at": { + "name": "deleted_at", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "updated_at": { + "name": "updated_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + } + }, + "indexes": { + "tasks_slug_unique": { + "name": "tasks_slug_unique", + "columns": [ + "slug" + ], + "isUnique": true + }, + "tasks_slug_idx": { + "name": "tasks_slug_idx", + "columns": [ + "slug" + ], + "isUnique": false + }, + "tasks_organization_id_idx": { + "name": "tasks_organization_id_idx", + "columns": [ + "organization_id" + ], + "isUnique": false + }, + "tasks_assignee_id_idx": { + "name": "tasks_assignee_id_idx", + "columns": [ + "assignee_id" + ], + "isUnique": false + }, + "tasks_status_idx": { + "name": "tasks_status_idx", + "columns": [ + "status" + ], + "isUnique": false + }, + "tasks_created_at_idx": { + "name": "tasks_created_at_idx", + "columns": [ + "created_at" + ], + "isUnique": false + } + }, + "foreignKeys": { + "tasks_organization_id_organizations_id_fk": { + "name": "tasks_organization_id_organizations_id_fk", + "tableFrom": "tasks", + "tableTo": "organizations", + "columnsFrom": [ + "organization_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + }, + "tasks_assignee_id_users_id_fk": { + "name": "tasks_assignee_id_users_id_fk", + "tableFrom": "tasks", + "tableTo": "users", + "columnsFrom": [ + "assignee_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "set null", + "onUpdate": "no action" + }, + "tasks_creator_id_users_id_fk": { + "name": "tasks_creator_id_users_id_fk", + "tableFrom": "tasks", + "tableTo": "users", + "columnsFrom": [ + "creator_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "users": { + "name": "users", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "clerk_id": { + "name": "clerk_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "name": { + "name": "name", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "email": { + "name": "email", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "avatar_url": { + "name": "avatar_url", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "deleted_at": { + "name": "deleted_at", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "updated_at": { + "name": "updated_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + } + }, + "indexes": { + "users_clerk_id_unique": { + "name": "users_clerk_id_unique", + "columns": [ + "clerk_id" + ], + "isUnique": true + }, + "users_email_unique": { + "name": "users_email_unique", + "columns": [ + "email" + ], + "isUnique": true + }, + "users_email_idx": { + "name": "users_email_idx", + "columns": [ + "email" + ], + "isUnique": false + }, + "users_clerk_id_idx": { + "name": "users_clerk_id_idx", + "columns": [ + "clerk_id" + ], + "isUnique": false + } + }, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "workspaces": { + "name": "workspaces", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "project_id": { + "name": "project_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "worktree_id": { + "name": "worktree_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "type": { + "name": "type", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "branch": { + "name": "branch", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "name": { + "name": "name", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "tab_order": { + "name": "tab_order", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "updated_at": { + "name": "updated_at", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "last_opened_at": { + "name": "last_opened_at", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + } + }, + "indexes": { + "workspaces_project_id_idx": { + "name": "workspaces_project_id_idx", + "columns": [ + "project_id" + ], + "isUnique": false + }, + "workspaces_worktree_id_idx": { + "name": "workspaces_worktree_id_idx", + "columns": [ + "worktree_id" + ], + "isUnique": false + }, + "workspaces_last_opened_at_idx": { + "name": "workspaces_last_opened_at_idx", + "columns": [ + "last_opened_at" + ], + "isUnique": false + } + }, + "foreignKeys": { + "workspaces_project_id_projects_id_fk": { + "name": "workspaces_project_id_projects_id_fk", + "tableFrom": "workspaces", + "tableTo": "projects", + "columnsFrom": [ + "project_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + }, + "workspaces_worktree_id_worktrees_id_fk": { + "name": "workspaces_worktree_id_worktrees_id_fk", + "tableFrom": "workspaces", + "tableTo": "worktrees", + "columnsFrom": [ + "worktree_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "worktrees": { + "name": "worktrees", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "project_id": { + "name": "project_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "path": { + "name": "path", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "branch": { + "name": "branch", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "base_branch": { + "name": "base_branch", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "git_status": { + "name": "git_status", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "github_status": { + "name": "github_status", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + } + }, + "indexes": { + "worktrees_project_id_idx": { + "name": "worktrees_project_id_idx", + "columns": [ + "project_id" + ], + "isUnique": false + }, + "worktrees_branch_idx": { + "name": "worktrees_branch_idx", + "columns": [ + "branch" + ], + "isUnique": false + } + }, + "foreignKeys": { + "worktrees_project_id_projects_id_fk": { + "name": "worktrees_project_id_projects_id_fk", + "tableFrom": "worktrees", + "tableTo": "projects", + "columnsFrom": [ + "project_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + } + }, + "views": {}, + "enums": {}, + "_meta": { + "schemas": {}, + "tables": {}, + "columns": {} + }, + "internal": { + "indexes": {} + } +} \ No newline at end of file diff --git a/packages/local-db/drizzle/meta/_journal.json b/packages/local-db/drizzle/meta/_journal.json index 65dc59e762b..ee8d7e16496 100644 --- a/packages/local-db/drizzle/meta/_journal.json +++ b/packages/local-db/drizzle/meta/_journal.json @@ -36,6 +36,13 @@ "when": 1767166138761, "tag": "0004_add_terminal_link_behavior_setting", "breakpoints": true + }, + { + "idx": 5, + "version": "6", + "when": 1767166547886, + "tag": "0005_add_navigation_style", + "breakpoints": true } ] } \ No newline at end of file diff --git a/packages/local-db/src/schema/schema.ts b/packages/local-db/src/schema/schema.ts index 0f98d17ada9..c708a32964f 100644 --- a/packages/local-db/src/schema/schema.ts +++ b/packages/local-db/src/schema/schema.ts @@ -112,6 +112,11 @@ export const workspaces = sqliteTable( export type InsertWorkspace = typeof workspaces.$inferInsert; export type SelectWorkspace = typeof workspaces.$inferSelect; +/** + * Navigation style for workspace display + */ +export type NavigationStyle = "top-bar" | "sidebar"; + /** * Settings table - single row with typed columns */ @@ -131,6 +136,7 @@ export const settings = sqliteTable("settings", { terminalLinkBehavior: text( "terminal_link_behavior", ).$type(), + navigationStyle: text("navigation_style").$type(), }); export type InsertSettings = typeof settings.$inferInsert; From dcd61250511dc8693e68e1c1bf1bcc0df68c1cb9 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Wed, 31 Dec 2025 10:32:08 +0200 Subject: [PATCH 16/98] fix(desktop): P0 CreateWorkspaceButton in sidebar mode + P1 race condition MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit P0: Add CreateWorkspaceButton to TopBar when in sidebar mode - Button was previously only rendered via WorkspaceTabs - Now renders in top-right section when navigationStyle is sidebar P1: Fix race condition in createBranchWorkspace - Add unique partial index on (projectId) WHERE type='branch' - Use INSERT ON CONFLICT DO NOTHING to handle concurrent calls - If conflict, fetch the existing workspace instead of failing 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 --- .../lib/trpc/routers/workspaces/workspaces.ts | 87 +++++++++------ .../screens/main/components/TopBar/index.tsx | 2 + .../TabsContent/GroupStrip/GroupStrip.tsx | 104 ++++++++++++++++-- ...0006_add_unique_branch_workspace_index.sql | 1 + packages/local-db/drizzle/meta/_journal.json | 7 ++ 5 files changed, 159 insertions(+), 42 deletions(-) create mode 100644 packages/local-db/drizzle/0006_add_unique_branch_workspace_index.sql diff --git a/apps/desktop/src/lib/trpc/routers/workspaces/workspaces.ts b/apps/desktop/src/lib/trpc/routers/workspaces/workspaces.ts index 670b8e41b11..ee0aa14c8a6 100644 --- a/apps/desktop/src/lib/trpc/routers/workspaces/workspaces.ts +++ b/apps/desktop/src/lib/trpc/routers/workspaces/workspaces.ts @@ -319,8 +319,9 @@ export const createWorkspacesRouter = () => { .run(); } - // Insert new workspace - const workspace = localDb + // Insert new workspace with conflict handling for race conditions + // The unique partial index (projectId WHERE type='branch') prevents duplicates + const insertResult = localDb .insert(workspaces) .values({ projectId: input.projectId, @@ -329,8 +330,30 @@ export const createWorkspacesRouter = () => { name: branch, tabOrder: 0, }) + .onConflictDoNothing() .returning() - .get(); + .all(); + + // If insert returned nothing, another concurrent call won the race + // Fetch the existing workspace instead + const workspace = + insertResult[0] ?? + localDb + .select() + .from(workspaces) + .where( + and( + eq(workspaces.projectId, input.projectId), + eq(workspaces.type, "branch"), + ), + ) + .get(); + + if (!workspace) { + throw new Error("Failed to create or find branch workspace"); + } + + const wasExisting = insertResult.length === 0; // Update settings localDb @@ -342,41 +365,43 @@ export const createWorkspacesRouter = () => { }) .run(); - // Update project - const activeProjects = localDb - .select() - .from(projects) - .where(isNotNull(projects.tabOrder)) - .all(); - const maxProjectTabOrder = - activeProjects.length > 0 - ? Math.max(...activeProjects.map((p) => p.tabOrder ?? 0)) - : -1; + // Update project (only if we actually inserted a new workspace) + if (!wasExisting) { + const activeProjects = localDb + .select() + .from(projects) + .where(isNotNull(projects.tabOrder)) + .all(); + const maxProjectTabOrder = + activeProjects.length > 0 + ? Math.max(...activeProjects.map((p) => p.tabOrder ?? 0)) + : -1; - localDb - .update(projects) - .set({ - lastOpenedAt: Date.now(), - tabOrder: - project.tabOrder === null - ? maxProjectTabOrder + 1 - : project.tabOrder, - }) - .where(eq(projects.id, input.projectId)) - .run(); + localDb + .update(projects) + .set({ + lastOpenedAt: Date.now(), + tabOrder: + project.tabOrder === null + ? maxProjectTabOrder + 1 + : project.tabOrder, + }) + .where(eq(projects.id, input.projectId)) + .run(); - track("workspace_opened", { - workspace_id: workspace.id, - project_id: project.id, - type: "branch", - was_existing: false, - }); + track("workspace_opened", { + workspace_id: workspace.id, + project_id: project.id, + type: "branch", + was_existing: false, + }); + } return { workspace, worktreePath: project.mainRepoPath, projectId: project.id, - wasExisting: false, + wasExisting, }; }), diff --git a/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx b/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx index 2441e996563..aec8802e03b 100644 --- a/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx +++ b/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx @@ -5,6 +5,7 @@ import { SidebarControl } from "./SidebarControl"; import { WindowControls } from "./WindowControls"; import { WorkspaceSidebarControl } from "./WorkspaceSidebarControl"; import { WorkspacesTabs } from "./WorkspaceTabs"; +import { CreateWorkspaceButton } from "./WorkspaceTabs/CreateWorkspaceButton"; interface TopBarProps { navigationStyle?: NavigationStyle; @@ -45,6 +46,7 @@ export function TopBar({ navigationStyle = "top-bar" }: TopBarProps) { )}
+ {isSidebarMode && } {!isMac && }
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx index 28b4abd9996..61b7b7f8e3f 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx @@ -1,5 +1,6 @@ import { Button } from "@superset/ui/button"; import { Tooltip, TooltipContent, TooltipTrigger } from "@superset/ui/tooltip"; +import { cn } from "@superset/ui/utils"; import { useMemo } from "react"; import { HiMiniPlus, HiMiniXMark } from "react-icons/hi2"; import { trpc } from "renderer/lib/trpc"; @@ -11,6 +12,7 @@ interface GroupItemProps { tab: Tab; isActive: boolean; needsAttention: boolean; + isSidebarMode: boolean; onSelect: () => void; onClose: () => void; } @@ -19,11 +21,71 @@ function GroupItem({ tab, isActive, needsAttention, + isSidebarMode, onSelect, onClose, }: GroupItemProps) { const displayName = getTabDisplayName(tab); + if (isSidebarMode) { + // Sidebar mode: browser-tab style matching workspace tabs + return ( +
+ + + + + + {displayName} + + + + + + + + Close group + + +
+ ); + } + + // Top-bar mode: original pill style return (
@@ -65,6 +127,8 @@ function GroupItem({ export function GroupStrip() { const { data: activeWorkspace } = trpc.workspaces.getActive.useQuery(); + const { data: navigationStyle } = trpc.settings.getNavigationStyle.useQuery(); + const isSidebarMode = navigationStyle === "sidebar"; const activeWorkspaceId = activeWorkspace?.id; const allTabs = useTabsStore((s) => s.tabs); @@ -114,18 +178,36 @@ export function GroupStrip() { }; return ( -
+
{tabs.length > 0 && ( -
+
{tabs.map((tab) => ( - handleSelectGroup(tab.id)} - onClose={() => handleCloseGroup(tab.id)} - /> + className={isSidebarMode ? "h-full shrink-0" : undefined} + style={isSidebarMode ? { width: "120px" } : undefined} + > + handleSelectGroup(tab.id)} + onClose={() => handleCloseGroup(tab.id)} + /> +
))}
)} @@ -134,10 +216,10 @@ export function GroupStrip() { diff --git a/packages/local-db/drizzle/0006_add_unique_branch_workspace_index.sql b/packages/local-db/drizzle/0006_add_unique_branch_workspace_index.sql new file mode 100644 index 00000000000..b38893a9abb --- /dev/null +++ b/packages/local-db/drizzle/0006_add_unique_branch_workspace_index.sql @@ -0,0 +1 @@ +CREATE UNIQUE INDEX IF NOT EXISTS `workspaces_unique_branch_per_project` ON `workspaces` (`project_id`) WHERE `type` = 'branch'; diff --git a/packages/local-db/drizzle/meta/_journal.json b/packages/local-db/drizzle/meta/_journal.json index ee8d7e16496..d72a8fe1e80 100644 --- a/packages/local-db/drizzle/meta/_journal.json +++ b/packages/local-db/drizzle/meta/_journal.json @@ -43,6 +43,13 @@ "when": 1767166547886, "tag": "0005_add_navigation_style", "breakpoints": true + }, + { + "idx": 6, + "version": "6", + "when": 1767230000000, + "tag": "0006_add_unique_branch_workspace_index", + "breakpoints": true } ] } \ No newline at end of file From 0627835d74df72c894a12d8d5a3f13eea288cef5 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Wed, 31 Dec 2025 11:36:31 +0200 Subject: [PATCH 17/98] feat(desktop): workspace sidebar 1-1 feature parity with top-bar tabs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit WorkspaceListItem now has full feature parity: - Close/delete button with confirmation dialog - Context menu (Rename, Open in Finder) - Hover card with PR details, checks, reviews - Needs attention indicator (red pulse) - Inline rename (double-click) - Drag & drop reordering - BranchSwitcher for branch workspaces Other changes: - Remove CreateWorkspaceButton from TopBar in sidebar mode - Add per-project "Add workspace" dropdown (New Workspace, Quick Create) - Add preSelectedProjectId to modal store for pre-selecting project - Simplify GroupStrip to use consistent browser-tab style 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 --- .../NewWorkspaceModal/NewWorkspaceModal.tsx | 13 +- .../screens/main/components/TopBar/index.tsx | 2 - .../ProjectSection/ProjectSection.tsx | 65 ++++ .../WorkspaceListItem/WorkspaceListItem.tsx | 311 ++++++++++++++++-- .../TabsContent/GroupStrip/GroupStrip.tsx | 141 +++----- .../renderer/stores/new-workspace-modal.ts | 12 +- 6 files changed, 413 insertions(+), 131 deletions(-) diff --git a/apps/desktop/src/renderer/components/NewWorkspaceModal/NewWorkspaceModal.tsx b/apps/desktop/src/renderer/components/NewWorkspaceModal/NewWorkspaceModal.tsx index 98d08f1af40..17f02c2718b 100644 --- a/apps/desktop/src/renderer/components/NewWorkspaceModal/NewWorkspaceModal.tsx +++ b/apps/desktop/src/renderer/components/NewWorkspaceModal/NewWorkspaceModal.tsx @@ -36,6 +36,7 @@ import { useCreateWorkspace } from "renderer/react-query/workspaces"; import { useCloseNewWorkspaceModal, useNewWorkspaceModalOpen, + usePreSelectedProjectId, } from "renderer/stores/new-workspace-modal"; import { ExistingWorktreesList } from "./components/ExistingWorktreesList"; @@ -57,6 +58,7 @@ type Mode = "existing" | "new"; export function NewWorkspaceModal() { const isOpen = useNewWorkspaceModalOpen(); const closeModal = useCloseNewWorkspaceModal(); + const preSelectedProjectId = usePreSelectedProjectId(); const [selectedProjectId, setSelectedProjectId] = useState( null, ); @@ -94,12 +96,15 @@ export function NewWorkspaceModal() { ); }, [branchData?.branches, branchSearch]); - // Auto-select current project when modal opens + // Auto-select project when modal opens (prioritize pre-selected, then current) useEffect(() => { - if (isOpen && currentProjectId && !selectedProjectId) { - setSelectedProjectId(currentProjectId); + if (isOpen && !selectedProjectId) { + const projectToSelect = preSelectedProjectId ?? currentProjectId; + if (projectToSelect) { + setSelectedProjectId(projectToSelect); + } } - }, [isOpen, currentProjectId, selectedProjectId]); + }, [isOpen, currentProjectId, selectedProjectId, preSelectedProjectId]); // Effective base branch - use explicit selection or fall back to default const effectiveBaseBranch = baseBranch ?? branchData?.defaultBranch ?? null; diff --git a/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx b/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx index aec8802e03b..2441e996563 100644 --- a/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx +++ b/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx @@ -5,7 +5,6 @@ import { SidebarControl } from "./SidebarControl"; import { WindowControls } from "./WindowControls"; import { WorkspaceSidebarControl } from "./WorkspaceSidebarControl"; import { WorkspacesTabs } from "./WorkspaceTabs"; -import { CreateWorkspaceButton } from "./WorkspaceTabs/CreateWorkspaceButton"; interface TopBarProps { navigationStyle?: NavigationStyle; @@ -46,7 +45,6 @@ export function TopBar({ navigationStyle = "top-bar" }: TopBarProps) { )}
- {isSidebarMode && } {!isMac && }
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/ProjectSection/ProjectSection.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/ProjectSection/ProjectSection.tsx index 41a5e5f9e20..0f52fec1a79 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/ProjectSection/ProjectSection.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/ProjectSection/ProjectSection.tsx @@ -1,5 +1,16 @@ +import { + DropdownMenu, + DropdownMenuContent, + DropdownMenuItem, + DropdownMenuTrigger, +} from "@superset/ui/dropdown-menu"; +import { toast } from "@superset/ui/sonner"; import { AnimatePresence, motion } from "framer-motion"; +import { useState } from "react"; +import { HiMiniPlus, HiOutlineBolt } from "react-icons/hi2"; +import { useCreateWorkspace } from "renderer/react-query/workspaces"; import { useWorkspaceSidebarStore } from "renderer/stores"; +import { useOpenNewWorkspaceModal } from "renderer/stores/new-workspace-modal"; import { WorkspaceListItem } from "../WorkspaceListItem"; import { ProjectHeader } from "./ProjectHeader"; @@ -31,11 +42,29 @@ export function ProjectSection({ activeWorkspaceId, shortcutBaseIndex, }: ProjectSectionProps) { + const [dropdownOpen, setDropdownOpen] = useState(false); const { isProjectCollapsed, toggleProjectCollapsed } = useWorkspaceSidebarStore(); + const createWorkspace = useCreateWorkspace(); + const openModal = useOpenNewWorkspaceModal(); const isCollapsed = isProjectCollapsed(projectId); + const handleQuickCreate = () => { + setDropdownOpen(false); + toast.promise(createWorkspace.mutateAsync({ projectId }), { + loading: "Creating workspace...", + success: "Workspace created", + error: (err) => + err instanceof Error ? err.message : "Failed to create workspace", + }); + }; + + const handleNewWorkspace = () => { + setDropdownOpen(false); + openModal(projectId); + }; + return (
))} + + + + + + + + New Workspace + + + + Quick Create + + +
)} diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx index a819fbb3413..fc8dbf5e45f 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx @@ -1,30 +1,79 @@ +import { Button } from "@superset/ui/button"; +import { + ContextMenu, + ContextMenuContent, + ContextMenuItem, + ContextMenuSeparator, + ContextMenuTrigger, +} from "@superset/ui/context-menu"; +import { + HoverCard, + HoverCardContent, + HoverCardTrigger, +} from "@superset/ui/hover-card"; +import { Input } from "@superset/ui/input"; +import { toast } from "@superset/ui/sonner"; +import { Tooltip, TooltipContent, TooltipTrigger } from "@superset/ui/tooltip"; import { cn } from "@superset/ui/utils"; import { useState } from "react"; +import { useDrag, useDrop } from "react-dnd"; +import { HiMiniXMark } from "react-icons/hi2"; import { LuGitBranch } from "react-icons/lu"; import { trpc } from "renderer/lib/trpc"; -import { useSetActiveWorkspace } from "renderer/react-query/workspaces"; +import { + useDeleteWorkspace, + useReorderWorkspaces, + useSetActiveWorkspace, +} from "renderer/react-query/workspaces"; +import { BranchSwitcher } from "renderer/screens/main/components/TopBar/WorkspaceTabs/BranchSwitcher"; +import { DeleteWorkspaceDialog } from "renderer/screens/main/components/TopBar/WorkspaceTabs/DeleteWorkspaceDialog"; +import { useWorkspaceRename } from "renderer/screens/main/components/TopBar/WorkspaceTabs/useWorkspaceRename"; +import { WorkspaceHoverCardContent } from "renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceHoverCard"; +import { useTabsStore } from "renderer/stores/tabs/store"; import { WorkspaceDiffStats } from "./WorkspaceDiffStats"; import { WorkspaceStatusBadge } from "./WorkspaceStatusBadge"; +const WORKSPACE_TYPE = "WORKSPACE"; + interface WorkspaceListItemProps { id: string; + projectId: string; + worktreePath: string; name: string; branch: string; type: "worktree" | "branch"; isActive: boolean; + index: number; shortcutIndex?: number; } export function WorkspaceListItem({ id, + projectId, + worktreePath, name, branch, type, isActive, + index, shortcutIndex, }: WorkspaceListItemProps) { + const isBranchWorkspace = type === "branch"; const setActiveWorkspace = useSetActiveWorkspace(); + const reorderWorkspaces = useReorderWorkspaces(); + const deleteWorkspace = useDeleteWorkspace(); const [hasHovered, setHasHovered] = useState(false); + const [showDeleteDialog, setShowDeleteDialog] = useState(false); + const rename = useWorkspaceRename(id, name); + const tabs = useTabsStore((s) => s.tabs); + const panes = useTabsStore((s) => s.panes); + const openInFinder = trpc.external.openInFinder.useMutation(); + + // Query to check if workspace can be deleted + const canDeleteQuery = trpc.workspaces.canDelete.useQuery( + { id }, + { enabled: false }, + ); // Lazy-load GitHub status on hover to avoid N+1 queries const { data: githubStatus } = trpc.workspaces.getGitHubStatus.useQuery( @@ -35,8 +84,34 @@ export function WorkspaceListItem({ }, ); + // Check if any pane in tabs belonging to this workspace needs attention + const workspaceTabs = tabs.filter((t) => t.workspaceId === id); + const workspacePaneIds = new Set( + workspaceTabs.flatMap((t) => { + const collectPaneIds = (node: unknown): string[] => { + if (typeof node === "string") return [node]; + if ( + node && + typeof node === "object" && + "first" in node && + "second" in node + ) { + const b = node as { first: unknown; second: unknown }; + return [...collectPaneIds(b.first), ...collectPaneIds(b.second)]; + } + return []; + }; + return collectPaneIds(t.layout); + }), + ); + const needsAttention = Object.values(panes) + .filter((p) => workspacePaneIds.has(p.id)) + .some((p) => p.needsAttention); + const handleClick = () => { - setActiveWorkspace.mutate({ id }); + if (!rename.isRenaming) { + setActiveWorkspace.mutate({ id }); + } }; const handleMouseEnter = () => { @@ -45,20 +120,108 @@ export function WorkspaceListItem({ } }; + const handleOpenInFinder = () => { + if (worktreePath) { + openInFinder.mutate(worktreePath); + } + }; + + const handleDeleteClick = async (e: React.MouseEvent) => { + e.stopPropagation(); + if (deleteWorkspace.isPending || canDeleteQuery.isFetching) return; + + try { + const { data: canDeleteData } = await canDeleteQuery.refetch(); + + if (isBranchWorkspace) { + if ( + canDeleteData?.activeTerminalCount && + canDeleteData.activeTerminalCount > 0 + ) { + setShowDeleteDialog(true); + } else { + toast.promise(deleteWorkspace.mutateAsync({ id }), { + loading: `Closing "${name}"...`, + success: `Workspace "${name}" closed`, + error: (error) => + error instanceof Error + ? `Failed to close workspace: ${error.message}` + : "Failed to close workspace", + }); + } + return; + } + + const isEmpty = + canDeleteData?.canDelete && + canDeleteData.activeTerminalCount === 0 && + !canDeleteData.warning && + !canDeleteData.hasChanges && + !canDeleteData.hasUnpushedCommits; + + if (isEmpty) { + toast.promise(deleteWorkspace.mutateAsync({ id }), { + loading: `Deleting "${name}"...`, + success: `Workspace "${name}" deleted`, + error: (error) => + error instanceof Error + ? `Failed to delete workspace: ${error.message}` + : "Failed to delete workspace", + }); + } else { + setShowDeleteDialog(true); + } + } catch { + setShowDeleteDialog(true); + } + }; + + // Drag and drop + const [{ isDragging }, drag] = useDrag( + () => ({ + type: WORKSPACE_TYPE, + item: { id, projectId, index }, + collect: (monitor) => ({ + isDragging: monitor.isDragging(), + }), + }), + [id, projectId, index], + ); + + const [, drop] = useDrop({ + accept: WORKSPACE_TYPE, + hover: (item: { id: string; projectId: string; index: number }) => { + if (item.projectId === projectId && item.index !== index) { + reorderWorkspaces.mutate({ + projectId, + fromIndex: item.index, + toIndex: index, + }); + item.index = index; + } + }, + }); + const pr = githubStatus?.pr; const showDiffStats = pr && (pr.additions > 0 || pr.deletions > 0); - return ( + const content = ( + + + Delete workspace + + + )} ); + + // Wrap with context menu and hover card + if (isBranchWorkspace) { + return ( + <> + + {content} + + + Open in Finder + + + + + + ); + } + + return ( + <> + + + + {content} + + + + Rename + + + + Open in Finder + + + + + + + + + + ); } diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx index 61b7b7f8e3f..e6f271b53a4 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx @@ -12,7 +12,6 @@ interface GroupItemProps { tab: Tab; isActive: boolean; needsAttention: boolean; - isSidebarMode: boolean; onSelect: () => void; onClose: () => void; } @@ -21,88 +20,32 @@ function GroupItem({ tab, isActive, needsAttention, - isSidebarMode, onSelect, onClose, }: GroupItemProps) { const displayName = getTabDisplayName(tab); - if (isSidebarMode) { - // Sidebar mode: browser-tab style matching workspace tabs - return ( -
- - - - - - {displayName} - - - - - - - - Close group - - -
- ); - } - - // Top-bar mode: original pill style return ( -
+
@@ -111,24 +54,35 @@ function GroupItem({ {displayName} - + + + + + + Close group + +
); } export function GroupStrip() { const { data: activeWorkspace } = trpc.workspaces.getActive.useQuery(); - const { data: navigationStyle } = trpc.settings.getNavigationStyle.useQuery(); - const isSidebarMode = navigationStyle === "sidebar"; const activeWorkspaceId = activeWorkspace?.id; const allTabs = useTabsStore((s) => s.tabs); @@ -178,32 +132,19 @@ export function GroupStrip() { }; return ( -
+
{tabs.length > 0 && ( -
+
{tabs.map((tab) => (
handleSelectGroup(tab.id)} onClose={() => handleCloseGroup(tab.id)} /> @@ -216,10 +157,10 @@ export function GroupStrip() { diff --git a/apps/desktop/src/renderer/stores/new-workspace-modal.ts b/apps/desktop/src/renderer/stores/new-workspace-modal.ts index 0890c7797e4..38b18916b32 100644 --- a/apps/desktop/src/renderer/stores/new-workspace-modal.ts +++ b/apps/desktop/src/renderer/stores/new-workspace-modal.ts @@ -3,7 +3,8 @@ import { devtools } from "zustand/middleware"; interface NewWorkspaceModalState { isOpen: boolean; - openModal: () => void; + preSelectedProjectId: string | null; + openModal: (projectId?: string) => void; closeModal: () => void; } @@ -11,13 +12,14 @@ export const useNewWorkspaceModalStore = create()( devtools( (set) => ({ isOpen: false, + preSelectedProjectId: null, - openModal: () => { - set({ isOpen: true }); + openModal: (projectId?: string) => { + set({ isOpen: true, preSelectedProjectId: projectId ?? null }); }, closeModal: () => { - set({ isOpen: false }); + set({ isOpen: false, preSelectedProjectId: null }); }, }), { name: "NewWorkspaceModalStore" }, @@ -31,3 +33,5 @@ export const useOpenNewWorkspaceModal = () => useNewWorkspaceModalStore((state) => state.openModal); export const useCloseNewWorkspaceModal = () => useNewWorkspaceModalStore((state) => state.closeModal); +export const usePreSelectedProjectId = () => + useNewWorkspaceModalStore((state) => state.preSelectedProjectId); From c721e57ec606f6a5bf490554d50b23b35c7fc901 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Wed, 31 Dec 2025 11:50:56 +0200 Subject: [PATCH 18/98] refactor(desktop): extract shared utilities for workspace components MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Extract useWorkspaceDeleteHandler hook for shared delete logic - Use existing extractPaneIdsFromLayout from tabs/utils instead of inline collectPaneIds - Add named constants for magic numbers (staleTime, delays, shortcut index) - Reduces code duplication between WorkspaceItem and WorkspaceListItem 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 --- .../renderer/react-query/workspaces/index.ts | 1 + .../workspaces/useWorkspaceDeleteHandler.ts | 101 +++++++++++++++++ .../TopBar/WorkspaceTabs/WorkspaceItem.tsx | 100 ++--------------- .../TopBar/WorkspaceTabs/constants.ts | 9 ++ .../WorkspaceListItem/WorkspaceListItem.tsx | 105 ++++-------------- .../WorkspaceListItem/constants.ts | 15 +++ 6 files changed, 158 insertions(+), 173 deletions(-) create mode 100644 apps/desktop/src/renderer/react-query/workspaces/useWorkspaceDeleteHandler.ts create mode 100644 apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/constants.ts create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/constants.ts diff --git a/apps/desktop/src/renderer/react-query/workspaces/index.ts b/apps/desktop/src/renderer/react-query/workspaces/index.ts index 60a9c29b75d..438ba849573 100644 --- a/apps/desktop/src/renderer/react-query/workspaces/index.ts +++ b/apps/desktop/src/renderer/react-query/workspaces/index.ts @@ -6,3 +6,4 @@ export { useOpenWorktree } from "./useOpenWorktree"; export { useReorderWorkspaces } from "./useReorderWorkspaces"; export { useSetActiveWorkspace } from "./useSetActiveWorkspace"; export { useUpdateWorkspace } from "./useUpdateWorkspace"; +export { useWorkspaceDeleteHandler } from "./useWorkspaceDeleteHandler"; diff --git a/apps/desktop/src/renderer/react-query/workspaces/useWorkspaceDeleteHandler.ts b/apps/desktop/src/renderer/react-query/workspaces/useWorkspaceDeleteHandler.ts new file mode 100644 index 00000000000..9acf1b37401 --- /dev/null +++ b/apps/desktop/src/renderer/react-query/workspaces/useWorkspaceDeleteHandler.ts @@ -0,0 +1,101 @@ +import { toast } from "@superset/ui/sonner"; +import { useState } from "react"; +import { trpc } from "renderer/lib/trpc"; +import { useDeleteWorkspace } from "./useDeleteWorkspace"; + +interface UseWorkspaceDeleteHandlerParams { + id: string; + name: string; + type: "worktree" | "branch"; +} + +interface UseWorkspaceDeleteHandlerResult { + /** Whether the delete dialog should be shown */ + showDeleteDialog: boolean; + /** Set whether the delete dialog should be shown */ + setShowDeleteDialog: (show: boolean) => void; + /** Handle delete click - checks conditions and either deletes directly or shows dialog */ + handleDeleteClick: (e?: React.MouseEvent) => Promise; + /** Whether a delete operation is pending */ + isPending: boolean; +} + +/** + * Shared hook for workspace delete logic. + * Handles the decision of whether to show confirmation dialog or delete directly. + * + * For branch workspaces: Shows dialog only if there are active terminals + * For worktree workspaces: Shows dialog if there are changes, unpushed commits, or terminals + */ +export function useWorkspaceDeleteHandler({ + id, + name, + type, +}: UseWorkspaceDeleteHandlerParams): UseWorkspaceDeleteHandlerResult { + const [showDeleteDialog, setShowDeleteDialog] = useState(false); + const deleteWorkspace = useDeleteWorkspace(); + const isBranchWorkspace = type === "branch"; + + const canDeleteQuery = trpc.workspaces.canDelete.useQuery( + { id }, + { enabled: false }, + ); + + const handleDeleteClick = async (e?: React.MouseEvent) => { + e?.stopPropagation(); + + if (deleteWorkspace.isPending || canDeleteQuery.isFetching) return; + + try { + const { data: canDeleteData } = await canDeleteQuery.refetch(); + + if (isBranchWorkspace) { + if ( + canDeleteData?.activeTerminalCount && + canDeleteData.activeTerminalCount > 0 + ) { + setShowDeleteDialog(true); + } else { + toast.promise(deleteWorkspace.mutateAsync({ id }), { + loading: `Closing "${name}"...`, + success: `Workspace "${name}" closed`, + error: (error) => + error instanceof Error + ? `Failed to close workspace: ${error.message}` + : "Failed to close workspace", + }); + } + return; + } + + const isEmpty = + canDeleteData?.canDelete && + canDeleteData.activeTerminalCount === 0 && + !canDeleteData.warning && + !canDeleteData.hasChanges && + !canDeleteData.hasUnpushedCommits; + + if (isEmpty) { + toast.promise(deleteWorkspace.mutateAsync({ id }), { + loading: `Deleting "${name}"...`, + success: `Workspace "${name}" deleted`, + error: (error) => + error instanceof Error + ? `Failed to delete workspace: ${error.message}` + : "Failed to delete workspace", + }); + } else { + setShowDeleteDialog(true); + } + } catch { + setShowDeleteDialog(true); + } + }; + + return { + showDeleteDialog, + setShowDeleteDialog, + handleDeleteClick, + isPending: deleteWorkspace.isPending || canDeleteQuery.isFetching, + }; +} diff --git a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx index 089d3487e88..3187e763dc1 100644 --- a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx +++ b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx @@ -1,21 +1,20 @@ import { Button } from "@superset/ui/button"; import { Input } from "@superset/ui/input"; -import { toast } from "@superset/ui/sonner"; import { Tooltip, TooltipContent, TooltipTrigger } from "@superset/ui/tooltip"; import { cn } from "@superset/ui/utils"; -import { useState } from "react"; import { useDrag, useDrop } from "react-dnd"; import { HiMiniXMark } from "react-icons/hi2"; import { LuGitBranch } from "react-icons/lu"; -import { trpc } from "renderer/lib/trpc"; import { - useDeleteWorkspace, useReorderWorkspaces, useSetActiveWorkspace, + useWorkspaceDeleteHandler, } from "renderer/react-query/workspaces"; import { useCloseSettings } from "renderer/stores/app-state"; import { useTabsStore } from "renderer/stores/tabs/store"; +import { extractPaneIdsFromLayout } from "renderer/stores/tabs/utils"; import { BranchSwitcher } from "./BranchSwitcher"; +import { DELETE_TOOLTIP_DELAY, WORKSPACE_TOOLTIP_DELAY } from "./constants"; import { DeleteWorkspaceDialog } from "./DeleteWorkspaceDialog"; import { useWorkspaceRename } from "./useWorkspaceRename"; import { WorkspaceItemContextMenu } from "./WorkspaceItemContextMenu"; @@ -52,100 +51,19 @@ export function WorkspaceItem({ const isBranchWorkspace = workspaceType === "branch"; const setActive = useSetActiveWorkspace(); const reorderWorkspaces = useReorderWorkspaces(); - const deleteWorkspace = useDeleteWorkspace(); const closeSettings = useCloseSettings(); - const [showDeleteDialog, setShowDeleteDialog] = useState(false); const tabs = useTabsStore((s) => s.tabs); const panes = useTabsStore((s) => s.panes); const rename = useWorkspaceRename(id, title); - // Query to check if workspace is empty - only enabled when needed - const canDeleteQuery = trpc.workspaces.canDelete.useQuery( - { id }, - { enabled: false }, - ); - - const handleDeleteClick = async () => { - // Prevent double-clicks and race conditions - if (deleteWorkspace.isPending || canDeleteQuery.isFetching) return; - - try { - // Always fetch fresh data before deciding - const { data: canDeleteData } = await canDeleteQuery.refetch(); - - // For branch workspaces, only show dialog if there are active terminals - // (no destructive action - branch stays in repo) - if (isBranchWorkspace) { - if ( - canDeleteData?.activeTerminalCount && - canDeleteData.activeTerminalCount > 0 - ) { - setShowDeleteDialog(true); - } else { - // Close directly without confirmation - toast.promise(deleteWorkspace.mutateAsync({ id }), { - loading: `Closing "${title}"...`, - success: `Workspace "${title}" closed`, - error: (error) => - error instanceof Error - ? `Failed to close workspace: ${error.message}` - : "Failed to close workspace", - }); - } - return; - } - - // For worktree workspaces, check all conditions - const isEmpty = - canDeleteData?.canDelete && - canDeleteData.activeTerminalCount === 0 && - !canDeleteData.warning && - !canDeleteData.hasChanges && - !canDeleteData.hasUnpushedCommits; - - if (isEmpty) { - // Delete directly without confirmation - toast.promise(deleteWorkspace.mutateAsync({ id }), { - loading: `Deleting "${title}"...`, - success: `Workspace "${title}" deleted`, - error: (error) => - error instanceof Error - ? `Failed to delete workspace: ${error.message}` - : "Failed to delete workspace", - }); - } else { - // Show confirmation dialog - setShowDeleteDialog(true); - } - } catch { - // On error checking status, show dialog for user to decide - setShowDeleteDialog(true); - } - }; + // Shared delete logic + const { showDeleteDialog, setShowDeleteDialog, handleDeleteClick } = + useWorkspaceDeleteHandler({ id, name: title, type: workspaceType }); // Check if any pane in tabs belonging to this workspace needs attention const workspaceTabs = tabs.filter((t) => t.workspaceId === id); const workspacePaneIds = new Set( - workspaceTabs.flatMap((t) => { - // Extract pane IDs from the layout (which is a MosaicNode) - const collectPaneIds = (node: unknown): string[] => { - if (typeof node === "string") return [node]; - if ( - node && - typeof node === "object" && - "first" in node && - "second" in node - ) { - const branch = node as { first: unknown; second: unknown }; - return [ - ...collectPaneIds(branch.first), - ...collectPaneIds(branch.second), - ]; - } - return []; - }; - return collectPaneIds(t.layout); - }), + workspaceTabs.flatMap((t) => extractPaneIdsFromLayout(t.layout)), ); const needsAttention = Object.values(panes) .filter((p) => workspacePaneIds.has(p.id)) @@ -230,7 +148,7 @@ export function WorkspaceItem({ /> ) : isBranchWorkspace ? (
- +
@@ -292,7 +210,7 @@ export function WorkspaceItem({ {/* Only show close button for worktree workspaces */} {!isBranchWorkspace && ( - +
{isSidebarMode ? ( diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/WorkspaceActionBar.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/WorkspaceActionBar.tsx index 526bca55e10..97bf9abdda1 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/WorkspaceActionBar.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/WorkspaceActionBar.tsx @@ -1,17 +1,26 @@ +import type { NavigationStyle } from "@superset/local-db"; +import { SidebarControl } from "../../SidebarControl"; import { ViewModeToggle } from "./components/ViewModeToggle"; import { WorkspaceActionBarLeft } from "./components/WorkspaceActionBarLeft"; import { WorkspaceActionBarRight } from "./components/WorkspaceActionBarRight"; interface WorkspaceActionBarProps { worktreePath: string | undefined; + navigationStyle?: NavigationStyle; } -export function WorkspaceActionBar({ worktreePath }: WorkspaceActionBarProps) { +export function WorkspaceActionBar({ + worktreePath, + navigationStyle = "top-bar", +}: WorkspaceActionBarProps) { if (!worktreePath) return null; + const isSidebarMode = navigationStyle === "sidebar"; + return (
+ {isSidebarMode && }
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/index.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/index.tsx index a1d61bf3e53..3c44c7f0a20 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/index.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/index.tsx @@ -1,15 +1,19 @@ import { useMemo } from "react"; +import { useHotkeys } from "react-hotkeys-hook"; import { trpc } from "renderer/lib/trpc"; -import { useAppHotkey } from "renderer/stores/hotkeys"; import { useTabsStore } from "renderer/stores/tabs/store"; import { getNextPaneId, getPreviousPaneId } from "renderer/stores/tabs/utils"; import { useWorkspaceViewModeStore } from "renderer/stores/workspace-view-mode"; +import { DEFAULT_NAVIGATION_STYLE } from "shared/constants"; +import { HOTKEYS } from "shared/hotkeys"; import { ContentView } from "./ContentView"; import { ResizableSidebar } from "./ResizableSidebar"; import { WorkspaceActionBar } from "./WorkspaceActionBar"; export function WorkspaceView() { const { data: activeWorkspace } = trpc.workspaces.getActive.useQuery(); + const { data: navigationStyle } = trpc.settings.getNavigationStyle.useQuery(); + const effectiveNavigationStyle = navigationStyle ?? DEFAULT_NAVIGATION_STYLE; const activeWorkspaceId = activeWorkspace?.id; const allTabs = useTabsStore((s) => s.tabs); const activeTabIds = useTabsStore((s) => s.activeTabIds); @@ -52,124 +56,87 @@ export function WorkspaceView() { : "workbench"; // Tab management shortcuts - useAppHotkey( - "NEW_TERMINAL", - () => { - if (activeWorkspaceId) { - // If in Review mode, switch to Workbench first - if (viewMode === "review") { - setWorkspaceViewMode(activeWorkspaceId, "workbench"); - } - addTab(activeWorkspaceId); + useHotkeys(HOTKEYS.NEW_TERMINAL.keys, () => { + if (activeWorkspaceId) { + // If in Review mode, switch to Workbench first + if (viewMode === "review") { + setWorkspaceViewMode(activeWorkspaceId, "workbench"); } - }, - undefined, - [activeWorkspaceId, addTab, viewMode, setWorkspaceViewMode], - ); + addTab(activeWorkspaceId); + } + }, [activeWorkspaceId, addTab, viewMode, setWorkspaceViewMode]); - useAppHotkey( - "CLOSE_TERMINAL", - () => { - // Close focused pane (which may close the tab if it's the last pane) - if (focusedPaneId) { - removePane(focusedPaneId); - } - }, - undefined, - [focusedPaneId, removePane], - ); + useHotkeys(HOTKEYS.CLOSE_TERMINAL.keys, () => { + // Close focused pane (which may close the tab if it's the last pane) + if (focusedPaneId) { + removePane(focusedPaneId); + } + }, [focusedPaneId, removePane]); - // Switch between tabs (configurable shortcut) - useAppHotkey( - "PREV_TERMINAL", - () => { - if (!activeWorkspaceId || !activeTabId) return; - const index = tabs.findIndex((t) => t.id === activeTabId); - if (index > 0) { - setActiveTab(activeWorkspaceId, tabs[index - 1].id); - } - }, - undefined, - [activeWorkspaceId, activeTabId, tabs, setActiveTab], - ); + // Switch between tabs (⌘+Up/Down) + useHotkeys(HOTKEYS.PREV_TERMINAL.keys, () => { + if (!activeWorkspaceId || !activeTabId) return; + const index = tabs.findIndex((t) => t.id === activeTabId); + if (index > 0) { + setActiveTab(activeWorkspaceId, tabs[index - 1].id); + } + }, [activeWorkspaceId, activeTabId, tabs, setActiveTab]); - useAppHotkey( - "NEXT_TERMINAL", - () => { - if (!activeWorkspaceId || !activeTabId) return; - const index = tabs.findIndex((t) => t.id === activeTabId); - if (index < tabs.length - 1) { - setActiveTab(activeWorkspaceId, tabs[index + 1].id); - } - }, - undefined, - [activeWorkspaceId, activeTabId, tabs, setActiveTab], - ); + useHotkeys(HOTKEYS.NEXT_TERMINAL.keys, () => { + if (!activeWorkspaceId || !activeTabId) return; + const index = tabs.findIndex((t) => t.id === activeTabId); + if (index < tabs.length - 1) { + setActiveTab(activeWorkspaceId, tabs[index + 1].id); + } + }, [activeWorkspaceId, activeTabId, tabs, setActiveTab]); - // Switch between panes within a tab (configurable shortcut) - useAppHotkey( - "PREV_PANE", - () => { - if (!activeTabId || !activeTab?.layout || !focusedPaneId) return; - const prevPaneId = getPreviousPaneId(activeTab.layout, focusedPaneId); - if (prevPaneId) { - setFocusedPane(activeTabId, prevPaneId); - } - }, - undefined, - [activeTabId, activeTab?.layout, focusedPaneId, setFocusedPane], - ); + // Switch between panes within a tab (⌘+⌥+Left/Right) + useHotkeys(HOTKEYS.PREV_PANE.keys, () => { + if (!activeTabId || !activeTab?.layout || !focusedPaneId) return; + const prevPaneId = getPreviousPaneId(activeTab.layout, focusedPaneId); + if (prevPaneId) { + setFocusedPane(activeTabId, prevPaneId); + } + }, [activeTabId, activeTab?.layout, focusedPaneId, setFocusedPane]); - useAppHotkey( - "NEXT_PANE", - () => { - if (!activeTabId || !activeTab?.layout || !focusedPaneId) return; - const nextPaneId = getNextPaneId(activeTab.layout, focusedPaneId); - if (nextPaneId) { - setFocusedPane(activeTabId, nextPaneId); - } - }, - undefined, - [activeTabId, activeTab?.layout, focusedPaneId, setFocusedPane], - ); + useHotkeys(HOTKEYS.NEXT_PANE.keys, () => { + if (!activeTabId || !activeTab?.layout || !focusedPaneId) return; + const nextPaneId = getNextPaneId(activeTab.layout, focusedPaneId); + if (nextPaneId) { + setFocusedPane(activeTabId, nextPaneId); + } + }, [activeTabId, activeTab?.layout, focusedPaneId, setFocusedPane]); // Open in last used app shortcut const { data: lastUsedApp = "cursor" } = trpc.settings.getLastUsedApp.useQuery(); const openInApp = trpc.external.openInApp.useMutation(); - useAppHotkey( - "OPEN_IN_APP", - () => { - if (activeWorkspace?.worktreePath) { - openInApp.mutate({ - path: activeWorkspace.worktreePath, - app: lastUsedApp, - }); - } - }, - undefined, - [activeWorkspace?.worktreePath, lastUsedApp], - ); + useHotkeys("meta+o", () => { + if (activeWorkspace?.worktreePath) { + openInApp.mutate({ + path: activeWorkspace.worktreePath, + app: lastUsedApp, + }); + } + }, [activeWorkspace?.worktreePath, lastUsedApp]); // Copy path shortcut const copyPath = trpc.external.copyPath.useMutation(); - useAppHotkey( - "COPY_PATH", - () => { - if (activeWorkspace?.worktreePath) { - copyPath.mutate(activeWorkspace.worktreePath); - } - }, - undefined, - [activeWorkspace?.worktreePath], - ); + useHotkeys("meta+shift+c", () => { + if (activeWorkspace?.worktreePath) { + copyPath.mutate(activeWorkspace.worktreePath); + } + }, [activeWorkspace?.worktreePath]); return (
- +
From 36aff257a1d9d57f3e8f3dded7985f28fecd9d6c Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Wed, 31 Dec 2025 12:13:53 +0200 Subject: [PATCH 20/98] fix(desktop): prevent TopBar overlap with Mac traffic lights during load Default to Mac layout (80px padding) while platform query is loading, since undefined === 'darwin' evaluates to false, causing 16px padding to be used initially on Mac before the query resolves. --- .../src/renderer/screens/main/components/TopBar/index.tsx | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx b/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx index 89a29bea1ea..fe809d43385 100644 --- a/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx +++ b/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx @@ -13,7 +13,8 @@ interface TopBarProps { export function TopBar({ navigationStyle = "top-bar" }: TopBarProps) { const { data: platform } = trpc.window.getPlatform.useQuery(); const { data: activeWorkspace } = trpc.workspaces.getActive.useQuery(); - const isMac = platform === "darwin"; + // Default to Mac layout while loading to avoid overlap with traffic lights + const isMac = platform === undefined || platform === "darwin"; const isSidebarMode = navigationStyle === "sidebar"; return ( From aa1204369e47fd50c39dd5a9e40425e202c09113 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Wed, 31 Dec 2025 12:15:09 +0200 Subject: [PATCH 21/98] fix(desktop): increase Mac traffic light padding for better spacing --- .../src/renderer/screens/main/components/TopBar/index.tsx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx b/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx index fe809d43385..f58e33f967f 100644 --- a/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx +++ b/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx @@ -22,7 +22,7 @@ export function TopBar({ navigationStyle = "top-bar" }: TopBarProps) {
{isSidebarMode && } From 484be79d87a2406763396d6ab4d4e6cf6cd60916 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Wed, 31 Dec 2025 13:00:19 +0200 Subject: [PATCH 22/98] fix(desktop): address PR review feedback for changes security and terminal links P0: Fix branch workspace support in assertRegisteredWorktree - Extended validation to check both worktrees.path AND projects.mainRepoPath - Branch workspaces use mainRepoPath which wasn't being validated P1: Fix terminal file-viewer links for absolute paths - Normalize absolute paths to worktree-relative before opening file viewer - File viewer expects relative paths but terminal links can be absolute P2: Fix misleading security comments - Removed claims about symlink checks that aren't implemented - Comments now accurately describe worktree registration + path traversal validation --- .../lib/trpc/routers/changes/file-contents.ts | 2 +- .../changes/security/path-validation.ts | 41 ++++++++++++++----- .../src/lib/trpc/routers/changes/staging.ts | 2 +- .../TabsContent/Terminal/Terminal.tsx | 15 ++++++- 4 files changed, 46 insertions(+), 14 deletions(-) diff --git a/apps/desktop/src/lib/trpc/routers/changes/file-contents.ts b/apps/desktop/src/lib/trpc/routers/changes/file-contents.ts index b0edb575149..dc4aba8f4e5 100644 --- a/apps/desktop/src/lib/trpc/routers/changes/file-contents.ts +++ b/apps/desktop/src/lib/trpc/routers/changes/file-contents.ts @@ -84,7 +84,7 @@ export const createFileContentsRouter = () => { }), ) .mutation(async ({ input }): Promise<{ success: boolean }> => { - // secureFs.writeFile handles all validation including symlink checks + // secureFs.writeFile validates worktree registration and path traversal await secureFs.writeFile( input.worktreePath, input.filePath, diff --git a/apps/desktop/src/lib/trpc/routers/changes/security/path-validation.ts b/apps/desktop/src/lib/trpc/routers/changes/security/path-validation.ts index 72292859b02..9d6ad55706b 100644 --- a/apps/desktop/src/lib/trpc/routers/changes/security/path-validation.ts +++ b/apps/desktop/src/lib/trpc/routers/changes/security/path-validation.ts @@ -1,5 +1,5 @@ import { isAbsolute, normalize, resolve, sep } from "node:path"; -import { worktrees } from "@superset/local-db"; +import { projects, worktrees } from "@superset/local-db"; import { eq } from "drizzle-orm"; import { localDb } from "main/lib/local-db"; @@ -53,28 +53,47 @@ export class PathValidationError extends Error { } /** - * Validates that a worktree path is registered in localDb. + * Validates that a workspace path is registered in localDb. * This is THE critical security boundary. * - * @throws PathValidationError if worktree is not registered + * Accepts: + * - Worktree paths (from worktrees table) + * - Project mainRepoPath (for branch workspaces that work on the main repo) + * + * @throws PathValidationError if path is not registered */ -export function assertRegisteredWorktree(worktreePath: string): void { - const exists = localDb +export function assertRegisteredWorktree(workspacePath: string): void { + // Check worktrees table first (most common case) + const worktreeExists = localDb .select() .from(worktrees) - .where(eq(worktrees.path, worktreePath)) + .where(eq(worktrees.path, workspacePath)) .get(); - if (!exists) { - throw new PathValidationError( - "Worktree not registered in database", - "UNREGISTERED_WORKTREE", - ); + if (worktreeExists) { + return; } + + // Check projects.mainRepoPath for branch workspaces + const projectExists = localDb + .select() + .from(projects) + .where(eq(projects.mainRepoPath, workspacePath)) + .get(); + + if (projectExists) { + return; + } + + throw new PathValidationError( + "Workspace path not registered in database", + "UNREGISTERED_WORKTREE", + ); } /** * Gets the worktree record if registered. Returns record for updates. + * Only works for actual worktrees, not project mainRepoPath. * * @throws PathValidationError if worktree is not registered */ diff --git a/apps/desktop/src/lib/trpc/routers/changes/staging.ts b/apps/desktop/src/lib/trpc/routers/changes/staging.ts index 83c06a489ec..037227fa4f8 100644 --- a/apps/desktop/src/lib/trpc/routers/changes/staging.ts +++ b/apps/desktop/src/lib/trpc/routers/changes/staging.ts @@ -69,7 +69,7 @@ export const createStagingRouter = () => { }), ) .mutation(async ({ input }): Promise<{ success: boolean }> => { - // secureFs.delete validates path and checks for symlink escapes + // secureFs.delete validates worktree registration and path traversal await secureFs.delete(input.worktreePath, input.filePath); return { success: true }; }), diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index 4c67aba85b0..c8c3de63890 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -80,7 +80,20 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const behavior = terminalLinkBehavior ?? "external-editor"; if (behavior === "file-viewer") { - addFileViewerPane(workspaceId, { filePath: path }); + // Normalize absolute paths to worktree-relative paths for file viewer + // File viewer expects relative paths, but terminal links can be absolute + let filePath = path; + if (workspaceCwd && path.startsWith(workspaceCwd)) { + filePath = path.slice(workspaceCwd.length).replace(/^\//, ""); + } else if (path.startsWith("/")) { + // Absolute path outside workspace - still try to open it + // but warn in console as it may fail validation + console.warn( + "[Terminal] Opening absolute path outside workspace:", + path, + ); + } + addFileViewerPane(workspaceId, { filePath }); } else { trpcClient.external.openFileInEditor .mutate({ From e6ab9818c150b671d346bb1cf80e6fca028e8951 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Wed, 31 Dec 2025 13:25:54 +0200 Subject: [PATCH 23/98] feat(desktop): add 'Mark as Unread' context menu option for workspaces - Add markWorkspaceAsUnread action to tabs store that sets needsAttention=true for all panes in a workspace - Add context menu item with LuEyeOff icon to: - WorkspaceItemContextMenu (top bar tabs) - WorkspaceListItem (sidebar) for both branch and worktree workspaces - Leverages existing needsAttention indicator system (red pulsing dot) - Logs when no panes exist in workspace (empty workspace edge case) --- .../WorkspaceItemContextMenu.tsx | 17 ++++++++++++ .../WorkspaceListItem/WorkspaceListItem.tsx | 17 +++++++++++- .../desktop/src/renderer/stores/tabs/store.ts | 27 +++++++++++++++++++ .../desktop/src/renderer/stores/tabs/types.ts | 1 + 4 files changed, 61 insertions(+), 1 deletion(-) diff --git a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItemContextMenu.tsx b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItemContextMenu.tsx index 142b12651dc..e514e552b8f 100644 --- a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItemContextMenu.tsx +++ b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItemContextMenu.tsx @@ -11,7 +11,9 @@ import { HoverCardTrigger, } from "@superset/ui/hover-card"; import type { ReactNode } from "react"; +import { LuEyeOff } from "react-icons/lu"; import { trpc } from "renderer/lib/trpc"; +import { useTabsStore } from "renderer/stores/tabs/store"; import { WorkspaceHoverCardContent } from "./WorkspaceHoverCard"; interface WorkspaceItemContextMenuProps { @@ -34,6 +36,7 @@ export function WorkspaceItemContextMenu({ showHoverCard = true, }: WorkspaceItemContextMenuProps) { const openInFinder = trpc.external.openInFinder.useMutation(); + const markWorkspaceAsUnread = useTabsStore((s) => s.markWorkspaceAsUnread); const handleOpenInFinder = () => { if (worktreePath) { @@ -41,6 +44,10 @@ export function WorkspaceItemContextMenu({ } }; + const handleMarkAsUnread = () => { + markWorkspaceAsUnread(workspaceId); + }; + // For branch workspaces, just show context menu without hover card if (!showHoverCard) { return ( @@ -56,6 +63,11 @@ export function WorkspaceItemContextMenu({ Open in Finder + + + + Mark as Unread + ); @@ -77,6 +89,11 @@ export function WorkspaceItemContextMenu({ Open in Finder + + + + Mark as Unread + diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx index 2a2dc858ccd..4e0407a49a3 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx @@ -17,7 +17,7 @@ import { cn } from "@superset/ui/utils"; import { useState } from "react"; import { useDrag, useDrop } from "react-dnd"; import { HiMiniXMark } from "react-icons/hi2"; -import { LuGitBranch } from "react-icons/lu"; +import { LuEyeOff, LuGitBranch } from "react-icons/lu"; import { trpc } from "renderer/lib/trpc"; import { useReorderWorkspaces, @@ -71,6 +71,7 @@ export function WorkspaceListItem({ const rename = useWorkspaceRename(id, name); const tabs = useTabsStore((s) => s.tabs); const panes = useTabsStore((s) => s.panes); + const markWorkspaceAsUnread = useTabsStore((s) => s.markWorkspaceAsUnread); const openInFinder = trpc.external.openInFinder.useMutation(); // Shared delete logic @@ -113,6 +114,10 @@ export function WorkspaceListItem({ } }; + const handleMarkAsUnread = () => { + markWorkspaceAsUnread(id); + }; + // Drag and drop const [{ isDragging }, drag] = useDrag( () => ({ @@ -265,6 +270,11 @@ export function WorkspaceListItem({ Open in Finder + + + + Mark as Unread + Open in Finder + + + + Mark as Unread + diff --git a/apps/desktop/src/renderer/stores/tabs/store.ts b/apps/desktop/src/renderer/stores/tabs/store.ts index f577db7d00b..4c7a9441d7f 100644 --- a/apps/desktop/src/renderer/stores/tabs/store.ts +++ b/apps/desktop/src/renderer/stores/tabs/store.ts @@ -543,6 +543,33 @@ export const useTabsStore = create()( })); }, + markWorkspaceAsUnread: (workspaceId) => { + const state = get(); + const workspaceTabs = state.tabs.filter( + (t) => t.workspaceId === workspaceId, + ); + const workspacePaneIds = workspaceTabs.flatMap((t) => + extractPaneIdsFromLayout(t.layout), + ); + + if (workspacePaneIds.length === 0) { + console.log( + "[tabs/markUnread] No panes to mark for workspace:", + workspaceId, + ); + return; + } + + const newPanes = { ...state.panes }; + for (const paneId of workspacePaneIds) { + if (newPanes[paneId]) { + newPanes[paneId] = { ...newPanes[paneId], needsAttention: true }; + } + } + + set({ panes: newPanes }); + }, + updatePaneCwd: (paneId, cwd, confirmed) => { set((state) => ({ panes: { diff --git a/apps/desktop/src/renderer/stores/tabs/types.ts b/apps/desktop/src/renderer/stores/tabs/types.ts index 03fc45d921b..c5c82fa985c 100644 --- a/apps/desktop/src/renderer/stores/tabs/types.ts +++ b/apps/desktop/src/renderer/stores/tabs/types.ts @@ -70,6 +70,7 @@ export interface TabsStore extends TabsState { setFocusedPane: (tabId: string, paneId: string) => void; markPaneAsUsed: (paneId: string) => void; setNeedsAttention: (paneId: string, needsAttention: boolean) => void; + markWorkspaceAsUnread: (workspaceId: string) => void; updatePaneCwd: ( paneId: string, cwd: string | null, From 14294ec6116755d20b3e5d40029a61e34710f029 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Wed, 31 Dec 2025 13:37:58 +0200 Subject: [PATCH 24/98] fix(desktop): clear workspace attention when clicking workspace Previously, clicking a workspace only set it as active but didn't clear the needsAttention state on panes. This meant 'Mark as Unread' worked but clicking the workspace didn't mark it as read. Added clearWorkspaceAttention action that clears needsAttention for all panes in a workspace, called when clicking workspace in both top bar and sidebar. --- .../TopBar/WorkspaceTabs/WorkspaceItem.tsx | 4 +++ .../WorkspaceListItem/WorkspaceListItem.tsx | 4 +++ .../desktop/src/renderer/stores/tabs/store.ts | 27 +++++++++++++++++++ .../desktop/src/renderer/stores/tabs/types.ts | 1 + 4 files changed, 36 insertions(+) diff --git a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx index 3187e763dc1..2f91dbcbb9c 100644 --- a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx +++ b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx @@ -54,6 +54,9 @@ export function WorkspaceItem({ const closeSettings = useCloseSettings(); const tabs = useTabsStore((s) => s.tabs); const panes = useTabsStore((s) => s.panes); + const clearWorkspaceAttention = useTabsStore( + (s) => s.clearWorkspaceAttention, + ); const rename = useWorkspaceRename(id, title); // Shared delete logic @@ -119,6 +122,7 @@ export function WorkspaceItem({ if (!rename.isRenaming) { closeSettings(); setActive.mutate({ id }); + clearWorkspaceAttention(id); } }} onDoubleClick={isBranchWorkspace ? undefined : rename.startRename} diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx index 4e0407a49a3..a955e51a65d 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx @@ -72,6 +72,9 @@ export function WorkspaceListItem({ const tabs = useTabsStore((s) => s.tabs); const panes = useTabsStore((s) => s.panes); const markWorkspaceAsUnread = useTabsStore((s) => s.markWorkspaceAsUnread); + const clearWorkspaceAttention = useTabsStore( + (s) => s.clearWorkspaceAttention, + ); const openInFinder = trpc.external.openInFinder.useMutation(); // Shared delete logic @@ -99,6 +102,7 @@ export function WorkspaceListItem({ const handleClick = () => { if (!rename.isRenaming) { setActiveWorkspace.mutate({ id }); + clearWorkspaceAttention(id); } }; diff --git a/apps/desktop/src/renderer/stores/tabs/store.ts b/apps/desktop/src/renderer/stores/tabs/store.ts index 4c7a9441d7f..9347c4d1b21 100644 --- a/apps/desktop/src/renderer/stores/tabs/store.ts +++ b/apps/desktop/src/renderer/stores/tabs/store.ts @@ -570,6 +570,33 @@ export const useTabsStore = create()( set({ panes: newPanes }); }, + clearWorkspaceAttention: (workspaceId) => { + const state = get(); + const workspaceTabs = state.tabs.filter( + (t) => t.workspaceId === workspaceId, + ); + const workspacePaneIds = workspaceTabs.flatMap((t) => + extractPaneIdsFromLayout(t.layout), + ); + + if (workspacePaneIds.length === 0) { + return; + } + + const newPanes = { ...state.panes }; + let hasChanges = false; + for (const paneId of workspacePaneIds) { + if (newPanes[paneId]?.needsAttention) { + newPanes[paneId] = { ...newPanes[paneId], needsAttention: false }; + hasChanges = true; + } + } + + if (hasChanges) { + set({ panes: newPanes }); + } + }, + updatePaneCwd: (paneId, cwd, confirmed) => { set((state) => ({ panes: { diff --git a/apps/desktop/src/renderer/stores/tabs/types.ts b/apps/desktop/src/renderer/stores/tabs/types.ts index c5c82fa985c..d6f43ab6e00 100644 --- a/apps/desktop/src/renderer/stores/tabs/types.ts +++ b/apps/desktop/src/renderer/stores/tabs/types.ts @@ -71,6 +71,7 @@ export interface TabsStore extends TabsState { markPaneAsUsed: (paneId: string) => void; setNeedsAttention: (paneId: string, needsAttention: boolean) => void; markWorkspaceAsUnread: (workspaceId: string) => void; + clearWorkspaceAttention: (workspaceId: string) => void; updatePaneCwd: ( paneId: string, cwd: string | null, From 2dcad38095fb53dfe642a0fb9180eb0b1a19ec08 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Wed, 31 Dec 2025 14:27:32 +0200 Subject: [PATCH 25/98] fix(desktop): address second round of PR review feedback P0: Make unique branch workspace migration resilient to existing duplicates - Dedupe existing duplicate branch workspaces before creating unique index - Update settings.last_active_workspace_id if it points to deleted workspace P1: Fix isResizing persistence and store selector usage - Exclude ephemeral isResizing from Zustand persistence via partialize - Use selector pattern in MainScreen to avoid unnecessary re-renders P1: Fix delete handler to show dialog when canDeleteData is undefined - Safe default: show confirmation when query fails P2: Fix path boundary check in terminal file links - Use path.startsWith(cwd + '/') to avoid false prefix matches P2: Add missing drizzle migration snapshot - Created 0006_snapshot.json for consistency --- .../workspaces/useWorkspaceDeleteHandler.ts | 10 +- .../TabsContent/Terminal/Terminal.tsx | 24 +- .../src/renderer/screens/main/index.tsx | 4 +- .../stores/workspace-sidebar-state.ts | 8 + ...0006_add_unique_branch_workspace_index.sql | 32 + .../local-db/drizzle/meta/0006_snapshot.json | 984 ++++++++++++++++++ 6 files changed, 1048 insertions(+), 14 deletions(-) create mode 100644 packages/local-db/drizzle/meta/0006_snapshot.json diff --git a/apps/desktop/src/renderer/react-query/workspaces/useWorkspaceDeleteHandler.ts b/apps/desktop/src/renderer/react-query/workspaces/useWorkspaceDeleteHandler.ts index 9acf1b37401..b7100f5a753 100644 --- a/apps/desktop/src/renderer/react-query/workspaces/useWorkspaceDeleteHandler.ts +++ b/apps/desktop/src/renderer/react-query/workspaces/useWorkspaceDeleteHandler.ts @@ -50,9 +50,11 @@ export function useWorkspaceDeleteHandler({ const { data: canDeleteData } = await canDeleteQuery.refetch(); if (isBranchWorkspace) { + // Show dialog if we couldn't get data (safe default) or there are active terminals if ( - canDeleteData?.activeTerminalCount && - canDeleteData.activeTerminalCount > 0 + !canDeleteData || + (canDeleteData.activeTerminalCount && + canDeleteData.activeTerminalCount > 0) ) { setShowDeleteDialog(true); } else { @@ -68,8 +70,10 @@ export function useWorkspaceDeleteHandler({ return; } + // Only skip dialog if we have data confirming it's safe to delete const isEmpty = - canDeleteData?.canDelete && + canDeleteData && + canDeleteData.canDelete && canDeleteData.activeTerminalCount === 0 && !canDeleteData.warning && !canDeleteData.hasChanges && diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index c8c3de63890..0294049054a 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -83,15 +83,21 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { // Normalize absolute paths to worktree-relative paths for file viewer // File viewer expects relative paths, but terminal links can be absolute let filePath = path; - if (workspaceCwd && path.startsWith(workspaceCwd)) { - filePath = path.slice(workspaceCwd.length).replace(/^\//, ""); - } else if (path.startsWith("/")) { - // Absolute path outside workspace - still try to open it - // but warn in console as it may fail validation - console.warn( - "[Terminal] Opening absolute path outside workspace:", - path, - ); + if (workspaceCwd) { + // Use path boundary check to avoid incorrect prefix stripping + // e.g., /repo vs /repo-other should not match + if (path === workspaceCwd) { + filePath = "."; + } else if (path.startsWith(workspaceCwd + "/")) { + filePath = path.slice(workspaceCwd.length + 1); + } else if (path.startsWith("/")) { + // Absolute path outside workspace - still try to open it + // but warn in console as it may fail validation + console.warn( + "[Terminal] Opening absolute path outside workspace:", + path, + ); + } } addFileViewerPane(workspaceId, { filePath }); } else { diff --git a/apps/desktop/src/renderer/screens/main/index.tsx b/apps/desktop/src/renderer/screens/main/index.tsx index 0e3ebeb0996..2d5f5543392 100644 --- a/apps/desktop/src/renderer/screens/main/index.tsx +++ b/apps/desktop/src/renderer/screens/main/index.tsx @@ -61,8 +61,8 @@ export function MainScreen() { const currentView = useCurrentView(); const openSettings = useOpenSettings(); - const { toggleSidebar } = useSidebarStore(); - const { toggleOpen: toggleWorkspaceSidebar } = useWorkspaceSidebarStore(); + const toggleSidebar = useSidebarStore((s) => s.toggleSidebar); + const toggleWorkspaceSidebar = useWorkspaceSidebarStore((s) => s.toggleOpen); const hasTasksAccess = useFeatureFlagEnabled( FEATURE_FLAGS.ELECTRIC_TASKS_ACCESS, ); diff --git a/apps/desktop/src/renderer/stores/workspace-sidebar-state.ts b/apps/desktop/src/renderer/stores/workspace-sidebar-state.ts index 5093f7d3997..adb12801ebe 100644 --- a/apps/desktop/src/renderer/stores/workspace-sidebar-state.ts +++ b/apps/desktop/src/renderer/stores/workspace-sidebar-state.ts @@ -90,6 +90,14 @@ export const useWorkspaceSidebarStore = create()( { name: "workspace-sidebar-store", version: 1, + // Exclude ephemeral state from persistence + partialize: (state) => ({ + isOpen: state.isOpen, + width: state.width, + lastOpenWidth: state.lastOpenWidth, + collapsedProjectIds: state.collapsedProjectIds, + // isResizing intentionally excluded - ephemeral UI state + }), }, ), { name: "WorkspaceSidebarStore" }, diff --git a/packages/local-db/drizzle/0006_add_unique_branch_workspace_index.sql b/packages/local-db/drizzle/0006_add_unique_branch_workspace_index.sql index b38893a9abb..769ddfb436c 100644 --- a/packages/local-db/drizzle/0006_add_unique_branch_workspace_index.sql +++ b/packages/local-db/drizzle/0006_add_unique_branch_workspace_index.sql @@ -1 +1,33 @@ +-- Dedupe existing duplicate branch workspaces before creating unique index. +-- Keep the oldest one (smallest id) as the deterministic winner. +-- First, update settings.last_active_workspace_id if it points to a workspace we're about to delete +UPDATE settings +SET last_active_workspace_id = ( + SELECT w1.id FROM workspaces w1 + WHERE w1.type = 'branch' + AND w1.project_id = ( + SELECT w2.project_id FROM workspaces w2 WHERE w2.id = settings.last_active_workspace_id + ) + ORDER BY w1.id ASC + LIMIT 1 +) +WHERE last_active_workspace_id IN ( + SELECT w1.id FROM workspaces w1 + WHERE w1.type = 'branch' + AND EXISTS ( + SELECT 1 FROM workspaces w2 + WHERE w2.type = 'branch' + AND w2.project_id = w1.project_id + AND w2.id < w1.id + ) +); + +-- Delete duplicate branch workspaces, keeping the oldest (smallest id) per project +DELETE FROM workspaces +WHERE type = 'branch' +AND id NOT IN ( + SELECT MIN(id) FROM workspaces WHERE type = 'branch' GROUP BY project_id +); + +-- Now safe to create the unique index CREATE UNIQUE INDEX IF NOT EXISTS `workspaces_unique_branch_per_project` ON `workspaces` (`project_id`) WHERE `type` = 'branch'; diff --git a/packages/local-db/drizzle/meta/0006_snapshot.json b/packages/local-db/drizzle/meta/0006_snapshot.json new file mode 100644 index 00000000000..5362480f6e2 --- /dev/null +++ b/packages/local-db/drizzle/meta/0006_snapshot.json @@ -0,0 +1,984 @@ +{ + "version": "6", + "dialect": "sqlite", + "id": "f1e2d3c4-b5a6-7890-abcd-ef1234567890", + "prevId": "ac200b80-657f-4cd7-b338-2d6adeb925e7", + "tables": { + "organization_members": { + "name": "organization_members", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "organization_id": { + "name": "organization_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "user_id": { + "name": "user_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "role": { + "name": "role", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + } + }, + "indexes": { + "organization_members_organization_id_idx": { + "name": "organization_members_organization_id_idx", + "columns": [ + "organization_id" + ], + "isUnique": false + }, + "organization_members_user_id_idx": { + "name": "organization_members_user_id_idx", + "columns": [ + "user_id" + ], + "isUnique": false + } + }, + "foreignKeys": { + "organization_members_organization_id_organizations_id_fk": { + "name": "organization_members_organization_id_organizations_id_fk", + "tableFrom": "organization_members", + "tableTo": "organizations", + "columnsFrom": [ + "organization_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + }, + "organization_members_user_id_users_id_fk": { + "name": "organization_members_user_id_users_id_fk", + "tableFrom": "organization_members", + "tableTo": "users", + "columnsFrom": [ + "user_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "organizations": { + "name": "organizations", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "clerk_org_id": { + "name": "clerk_org_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "name": { + "name": "name", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "slug": { + "name": "slug", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "github_org": { + "name": "github_org", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "avatar_url": { + "name": "avatar_url", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "updated_at": { + "name": "updated_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + } + }, + "indexes": { + "organizations_clerk_org_id_unique": { + "name": "organizations_clerk_org_id_unique", + "columns": [ + "clerk_org_id" + ], + "isUnique": true + }, + "organizations_slug_unique": { + "name": "organizations_slug_unique", + "columns": [ + "slug" + ], + "isUnique": true + }, + "organizations_slug_idx": { + "name": "organizations_slug_idx", + "columns": [ + "slug" + ], + "isUnique": false + }, + "organizations_clerk_org_id_idx": { + "name": "organizations_clerk_org_id_idx", + "columns": [ + "clerk_org_id" + ], + "isUnique": false + } + }, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "projects": { + "name": "projects", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "main_repo_path": { + "name": "main_repo_path", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "name": { + "name": "name", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "color": { + "name": "color", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "tab_order": { + "name": "tab_order", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "last_opened_at": { + "name": "last_opened_at", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "config_toast_dismissed": { + "name": "config_toast_dismissed", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "default_branch": { + "name": "default_branch", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + } + }, + "indexes": { + "projects_main_repo_path_idx": { + "name": "projects_main_repo_path_idx", + "columns": [ + "main_repo_path" + ], + "isUnique": false + }, + "projects_last_opened_at_idx": { + "name": "projects_last_opened_at_idx", + "columns": [ + "last_opened_at" + ], + "isUnique": false + } + }, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "settings": { + "name": "settings", + "columns": { + "id": { + "name": "id", + "type": "integer", + "primaryKey": true, + "notNull": true, + "autoincrement": false, + "default": 1 + }, + "last_active_workspace_id": { + "name": "last_active_workspace_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "last_used_app": { + "name": "last_used_app", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "terminal_presets": { + "name": "terminal_presets", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "terminal_presets_initialized": { + "name": "terminal_presets_initialized", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "selected_ringtone_id": { + "name": "selected_ringtone_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "active_organization_id": { + "name": "active_organization_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "confirm_on_quit": { + "name": "confirm_on_quit", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "terminal_link_behavior": { + "name": "terminal_link_behavior", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "navigation_style": { + "name": "navigation_style", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + } + }, + "indexes": {}, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "tasks": { + "name": "tasks", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "slug": { + "name": "slug", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "title": { + "name": "title", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "description": { + "name": "description", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "status": { + "name": "status", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "status_color": { + "name": "status_color", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "status_type": { + "name": "status_type", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "status_position": { + "name": "status_position", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "priority": { + "name": "priority", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "organization_id": { + "name": "organization_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "repository_id": { + "name": "repository_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "assignee_id": { + "name": "assignee_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "creator_id": { + "name": "creator_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "estimate": { + "name": "estimate", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "due_date": { + "name": "due_date", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "labels": { + "name": "labels", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "branch": { + "name": "branch", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "pr_url": { + "name": "pr_url", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "external_provider": { + "name": "external_provider", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "external_id": { + "name": "external_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "external_key": { + "name": "external_key", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "external_url": { + "name": "external_url", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "last_synced_at": { + "name": "last_synced_at", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "sync_error": { + "name": "sync_error", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "started_at": { + "name": "started_at", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "completed_at": { + "name": "completed_at", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "deleted_at": { + "name": "deleted_at", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "updated_at": { + "name": "updated_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + } + }, + "indexes": { + "tasks_slug_unique": { + "name": "tasks_slug_unique", + "columns": [ + "slug" + ], + "isUnique": true + }, + "tasks_slug_idx": { + "name": "tasks_slug_idx", + "columns": [ + "slug" + ], + "isUnique": false + }, + "tasks_organization_id_idx": { + "name": "tasks_organization_id_idx", + "columns": [ + "organization_id" + ], + "isUnique": false + }, + "tasks_assignee_id_idx": { + "name": "tasks_assignee_id_idx", + "columns": [ + "assignee_id" + ], + "isUnique": false + }, + "tasks_status_idx": { + "name": "tasks_status_idx", + "columns": [ + "status" + ], + "isUnique": false + }, + "tasks_created_at_idx": { + "name": "tasks_created_at_idx", + "columns": [ + "created_at" + ], + "isUnique": false + } + }, + "foreignKeys": { + "tasks_organization_id_organizations_id_fk": { + "name": "tasks_organization_id_organizations_id_fk", + "tableFrom": "tasks", + "tableTo": "organizations", + "columnsFrom": [ + "organization_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + }, + "tasks_assignee_id_users_id_fk": { + "name": "tasks_assignee_id_users_id_fk", + "tableFrom": "tasks", + "tableTo": "users", + "columnsFrom": [ + "assignee_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "set null", + "onUpdate": "no action" + }, + "tasks_creator_id_users_id_fk": { + "name": "tasks_creator_id_users_id_fk", + "tableFrom": "tasks", + "tableTo": "users", + "columnsFrom": [ + "creator_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "users": { + "name": "users", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "clerk_id": { + "name": "clerk_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "name": { + "name": "name", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "email": { + "name": "email", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "avatar_url": { + "name": "avatar_url", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "deleted_at": { + "name": "deleted_at", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "updated_at": { + "name": "updated_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + } + }, + "indexes": { + "users_clerk_id_unique": { + "name": "users_clerk_id_unique", + "columns": [ + "clerk_id" + ], + "isUnique": true + }, + "users_email_unique": { + "name": "users_email_unique", + "columns": [ + "email" + ], + "isUnique": true + }, + "users_email_idx": { + "name": "users_email_idx", + "columns": [ + "email" + ], + "isUnique": false + }, + "users_clerk_id_idx": { + "name": "users_clerk_id_idx", + "columns": [ + "clerk_id" + ], + "isUnique": false + } + }, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "workspaces": { + "name": "workspaces", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "project_id": { + "name": "project_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "worktree_id": { + "name": "worktree_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "type": { + "name": "type", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "branch": { + "name": "branch", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "name": { + "name": "name", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "tab_order": { + "name": "tab_order", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "updated_at": { + "name": "updated_at", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "last_opened_at": { + "name": "last_opened_at", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + } + }, + "indexes": { + "workspaces_project_id_idx": { + "name": "workspaces_project_id_idx", + "columns": [ + "project_id" + ], + "isUnique": false + }, + "workspaces_worktree_id_idx": { + "name": "workspaces_worktree_id_idx", + "columns": [ + "worktree_id" + ], + "isUnique": false + }, + "workspaces_last_opened_at_idx": { + "name": "workspaces_last_opened_at_idx", + "columns": [ + "last_opened_at" + ], + "isUnique": false + } + }, + "foreignKeys": { + "workspaces_project_id_projects_id_fk": { + "name": "workspaces_project_id_projects_id_fk", + "tableFrom": "workspaces", + "tableTo": "projects", + "columnsFrom": [ + "project_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + }, + "workspaces_worktree_id_worktrees_id_fk": { + "name": "workspaces_worktree_id_worktrees_id_fk", + "tableFrom": "workspaces", + "tableTo": "worktrees", + "columnsFrom": [ + "worktree_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "worktrees": { + "name": "worktrees", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "project_id": { + "name": "project_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "path": { + "name": "path", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "branch": { + "name": "branch", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "base_branch": { + "name": "base_branch", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "git_status": { + "name": "git_status", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "github_status": { + "name": "github_status", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + } + }, + "indexes": { + "worktrees_project_id_idx": { + "name": "worktrees_project_id_idx", + "columns": [ + "project_id" + ], + "isUnique": false + }, + "worktrees_branch_idx": { + "name": "worktrees_branch_idx", + "columns": [ + "branch" + ], + "isUnique": false + } + }, + "foreignKeys": { + "worktrees_project_id_projects_id_fk": { + "name": "worktrees_project_id_projects_id_fk", + "tableFrom": "worktrees", + "tableTo": "projects", + "columnsFrom": [ + "project_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + } + }, + "views": {}, + "enums": {}, + "_meta": { + "schemas": {}, + "tables": {}, + "columns": {} + }, + "internal": { + "indexes": {} + } +} From d4e1456c4a4293ce2537649e8adbf341a144b672 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Wed, 31 Dec 2025 15:19:16 +0200 Subject: [PATCH 26/98] fix(desktop): address third round of PR review feedback P0: Add symlink escape protection for File Viewer writes - Block writes if file's realpath escapes worktree boundary - Add isSymlinkEscaping() method for UI to detect and warn users - Update threat model docs to reflect new symlink protection P1: Fix race condition in createBranchWorkspace ordering - Insert workspace first, then shift others only on success - Losers of the race no longer corrupt tabOrder - Exclude newly inserted workspace from shift operation P2: Fix migration to keep most recently used duplicate - Select survivor by last_opened_at DESC (not arbitrary MIN(id)) - Use id ASC as tiebreaker when last_opened_at is equal --- .../changes/security/path-validation.ts | 24 +++-- .../routers/changes/security/secure-fs.ts | 91 ++++++++++++++++++- .../lib/trpc/routers/workspaces/workspaces.ts | 48 ++++++---- ...0006_add_unique_branch_workspace_index.sql | 23 ++++- 4 files changed, 148 insertions(+), 38 deletions(-) diff --git a/apps/desktop/src/lib/trpc/routers/changes/security/path-validation.ts b/apps/desktop/src/lib/trpc/routers/changes/security/path-validation.ts index 9d6ad55706b..317994323f3 100644 --- a/apps/desktop/src/lib/trpc/routers/changes/security/path-validation.ts +++ b/apps/desktop/src/lib/trpc/routers/changes/security/path-validation.ts @@ -6,15 +6,12 @@ import { localDb } from "main/lib/local-db"; /** * Security model for desktop app filesystem access: * - * THREAT MODEL ASSUMPTION: - * A compromised renderer can already execute arbitrary commands via - * terminal panes. Therefore, filesystem-level symlink protections - * provide no meaningful security boundary—an attacker with renderer - * access can simply run `cat /etc/passwd` in a terminal. - * - * If your deployment exposes the renderer to untrusted content WITHOUT - * terminal access, this model does NOT apply and symlink escape checks - * should be re-enabled. + * THREAT MODEL: + * While a compromised renderer can execute commands via terminal panes, + * the File Viewer presents a distinct threat: malicious repositories can + * contain symlinks that trick users into reading/writing sensitive files + * (e.g., `docs/config.yml` → `~/.bashrc`). Users clicking these links + * don't know they're accessing files outside the repo. * * PRIMARY BOUNDARY: assertRegisteredWorktree() * - Only worktree paths registered in localDb are accessible via tRPC @@ -24,9 +21,9 @@ import { localDb } from "main/lib/local-db"; * - Rejects absolute paths and ".." traversal segments * - Defense in depth against path manipulation * - * NOT IMPLEMENTED (intentional, see threat model above): - * - Symlink escape detection - * - Realpath resolution + * SYMLINK PROTECTION (secure-fs.ts): + * - Writes: Block if realpath escapes worktree (prevents accidental overwrites) + * - Reads: Caller can check isSymlinkEscaping() to warn users */ /** @@ -36,7 +33,8 @@ export type PathValidationErrorCode = | "ABSOLUTE_PATH" | "PATH_TRAVERSAL" | "UNREGISTERED_WORKTREE" - | "INVALID_TARGET"; + | "INVALID_TARGET" + | "SYMLINK_ESCAPE"; /** * Error thrown when path validation fails. diff --git a/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts b/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts index 2e461dd731a..ed920e2070d 100644 --- a/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts +++ b/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts @@ -1,6 +1,14 @@ import type { Stats } from "node:fs"; -import { lstat, readFile, rm, stat, writeFile } from "node:fs/promises"; import { + lstat, + readFile, + realpath, + rm, + stat, + writeFile, +} from "node:fs/promises"; +import { + PathValidationError, assertRegisteredWorktree, resolvePathInWorktree, } from "./path-validation"; @@ -11,10 +19,46 @@ import { * Each operation: * 1. Validates worktree is registered (security boundary) * 2. Validates path doesn't escape worktree (defense in depth) - * 3. Performs the filesystem operation + * 3. For writes: validates target is not a symlink escaping worktree + * 4. Performs the filesystem operation * * See path-validation.ts for the full security model and threat assumptions. */ + +/** + * Check if the resolved realpath stays within the worktree boundary. + * Prevents symlink escape attacks where a symlink points outside the worktree. + * + * @throws PathValidationError if realpath escapes worktree + */ +async function assertRealpathInWorktree( + worktreePath: string, + fullPath: string, +): Promise { + try { + const real = await realpath(fullPath); + const worktreeReal = await realpath(worktreePath); + + // Ensure realpath is within worktree (with proper boundary check) + if (!real.startsWith(worktreeReal + "/") && real !== worktreeReal) { + throw new PathValidationError( + "File is a symlink pointing outside the worktree", + "SYMLINK_ESCAPE", + ); + } + } catch (error) { + // If realpath fails with ENOENT, file doesn't exist yet - that's OK for writes + if (error instanceof Error && "code" in error && error.code === "ENOENT") { + return; + } + // Re-throw PathValidationError + if (error instanceof PathValidationError) { + throw error; + } + // Other errors (permission denied, etc.) - let them propagate + throw error; + } +} export const secureFs = { /** * Read a file within a worktree. @@ -43,6 +87,12 @@ export const secureFs = { /** * Write content to a file within a worktree. + * + * SECURITY: Blocks writes if the file is a symlink pointing outside + * the worktree. This prevents malicious repos from tricking users + * into overwriting sensitive files like ~/.bashrc. + * + * @throws PathValidationError with code "SYMLINK_ESCAPE" if target escapes worktree */ async writeFile( worktreePath: string, @@ -51,6 +101,10 @@ export const secureFs = { ): Promise { assertRegisteredWorktree(worktreePath); const fullPath = resolvePathInWorktree(worktreePath, filePath); + + // Block writes through symlinks that escape the worktree + await assertRealpathInWorktree(worktreePath, fullPath); + await writeFile(fullPath, content, "utf-8"); }, @@ -107,4 +161,37 @@ export const secureFs = { return false; } }, + + /** + * Check if a file is a symlink that points outside the worktree. + * + * Use this to warn users when viewing files that resolve outside + * the worktree boundary (potential malicious repo symlink). + * + * @returns true if the file is a symlink escaping the worktree + */ + async isSymlinkEscaping( + worktreePath: string, + filePath: string, + ): Promise { + try { + assertRegisteredWorktree(worktreePath); + const fullPath = resolvePathInWorktree(worktreePath, filePath); + + // Check if it's a symlink first + const stats = await lstat(fullPath); + if (!stats.isSymbolicLink()) { + return false; + } + + // Check if realpath escapes worktree + const real = await realpath(fullPath); + const worktreeReal = await realpath(worktreePath); + + return !real.startsWith(worktreeReal + "/") && real !== worktreeReal; + } catch { + // If we can't determine, assume not escaping (file may not exist) + return false; + } + }, }; diff --git a/apps/desktop/src/lib/trpc/routers/workspaces/workspaces.ts b/apps/desktop/src/lib/trpc/routers/workspaces/workspaces.ts index ee0aa14c8a6..fe99a498631 100644 --- a/apps/desktop/src/lib/trpc/routers/workspaces/workspaces.ts +++ b/apps/desktop/src/lib/trpc/routers/workspaces/workspaces.ts @@ -7,7 +7,7 @@ import { workspaces, worktrees, } from "@superset/local-db"; -import { and, desc, eq, isNotNull } from "drizzle-orm"; +import { and, desc, eq, isNotNull, not } from "drizzle-orm"; import { track } from "main/lib/analytics"; import { localDb } from "main/lib/local-db"; import { terminalManager } from "main/lib/terminal"; @@ -305,22 +305,10 @@ export const createWorkspacesRouter = () => { }; } - // Shift existing workspaces to make room at front - const projectWorkspaces = localDb - .select() - .from(workspaces) - .where(eq(workspaces.projectId, input.projectId)) - .all(); - for (const ws of projectWorkspaces) { - localDb - .update(workspaces) - .set({ tabOrder: ws.tabOrder + 1 }) - .where(eq(workspaces.id, ws.id)) - .run(); - } - - // Insert new workspace with conflict handling for race conditions + // Insert new workspace first with conflict handling for race conditions // The unique partial index (projectId WHERE type='branch') prevents duplicates + // We insert first, then shift - this prevents race conditions where + // concurrent calls both shift before either inserts (causing double shifts) const insertResult = localDb .insert(workspaces) .values({ @@ -334,6 +322,32 @@ export const createWorkspacesRouter = () => { .returning() .all(); + const wasExisting = insertResult.length === 0; + + // Only shift existing workspaces if we successfully inserted + // Losers of the race should NOT shift (they didn't create anything) + if (!wasExisting) { + const newWorkspaceId = insertResult[0].id; + const projectWorkspaces = localDb + .select() + .from(workspaces) + .where( + and( + eq(workspaces.projectId, input.projectId), + // Exclude the workspace we just inserted + not(eq(workspaces.id, newWorkspaceId)), + ), + ) + .all(); + for (const ws of projectWorkspaces) { + localDb + .update(workspaces) + .set({ tabOrder: ws.tabOrder + 1 }) + .where(eq(workspaces.id, ws.id)) + .run(); + } + } + // If insert returned nothing, another concurrent call won the race // Fetch the existing workspace instead const workspace = @@ -353,8 +367,6 @@ export const createWorkspacesRouter = () => { throw new Error("Failed to create or find branch workspace"); } - const wasExisting = insertResult.length === 0; - // Update settings localDb .insert(settings) diff --git a/packages/local-db/drizzle/0006_add_unique_branch_workspace_index.sql b/packages/local-db/drizzle/0006_add_unique_branch_workspace_index.sql index 769ddfb436c..6945d545ce6 100644 --- a/packages/local-db/drizzle/0006_add_unique_branch_workspace_index.sql +++ b/packages/local-db/drizzle/0006_add_unique_branch_workspace_index.sql @@ -1,5 +1,5 @@ -- Dedupe existing duplicate branch workspaces before creating unique index. --- Keep the oldest one (smallest id) as the deterministic winner. +-- Keep the most recently used one (highest last_opened_at), with id ASC as tiebreaker. -- First, update settings.last_active_workspace_id if it points to a workspace we're about to delete UPDATE settings SET last_active_workspace_id = ( @@ -8,7 +8,7 @@ SET last_active_workspace_id = ( AND w1.project_id = ( SELECT w2.project_id FROM workspaces w2 WHERE w2.id = settings.last_active_workspace_id ) - ORDER BY w1.id ASC + ORDER BY w1.last_opened_at DESC NULLS LAST, w1.id ASC LIMIT 1 ) WHERE last_active_workspace_id IN ( @@ -18,15 +18,28 @@ WHERE last_active_workspace_id IN ( SELECT 1 FROM workspaces w2 WHERE w2.type = 'branch' AND w2.project_id = w1.project_id - AND w2.id < w1.id + AND ( + w2.last_opened_at > w1.last_opened_at + OR (w2.last_opened_at = w1.last_opened_at AND w2.id < w1.id) + OR (w2.last_opened_at IS NOT NULL AND w1.last_opened_at IS NULL) + ) ) ); --- Delete duplicate branch workspaces, keeping the oldest (smallest id) per project +-- Delete duplicate branch workspaces, keeping the most recently used per project +-- Survivor selection: highest last_opened_at, then lowest id as tiebreaker DELETE FROM workspaces WHERE type = 'branch' AND id NOT IN ( - SELECT MIN(id) FROM workspaces WHERE type = 'branch' GROUP BY project_id + SELECT id FROM ( + SELECT id, ROW_NUMBER() OVER ( + PARTITION BY project_id + ORDER BY last_opened_at DESC NULLS LAST, id ASC + ) as rn + FROM workspaces + WHERE type = 'branch' + ) ranked + WHERE rn = 1 ); -- Now safe to create the unique index From e1c6cca2cdf29913fead4cb5a410fd735f692c9f Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Fri, 2 Jan 2026 09:38:16 +0200 Subject: [PATCH 27/98] feat(desktop): merge workspace action bar into top bar Consolidate two navigation bars into a single unified top bar: - Create WorkspaceControls component group in TopBar/ - BranchIndicator: shows current branch (keyboard-focusable) - OpenInMenuButton: compact Open button with dropdown - ViewModeToggleCompact: Workbench/Review toggle (24px height) - Remove WorkspaceActionBar from WorkspaceView entirely - Delete unused WorkspaceActionBar component folder Improvements based on Oracle review: - Optimize Zustand selector to minimize rerenders - Add toast error handling for open/copy mutations - Add path to Open button tooltip for discoverability - Add focus-visible rings for keyboard accessibility - Use text-xs for consistent typography Also includes minor lint auto-fixes (import sorting, template literals) --- .../routers/changes/security/secure-fs.ts | 6 +- .../workspaces/useWorkspaceDeleteHandler.ts | 3 +- .../WorkspaceControls/BranchIndicator.tsx | 29 +++++ .../WorkspaceControls/OpenInMenuButton.tsx} | 102 ++++++++---------- .../ViewModeToggleCompact.tsx} | 38 ++++--- .../WorkspaceControls/WorkspaceControls.tsx | 26 +++++ .../TopBar/WorkspaceControls/index.ts | 1 + .../screens/main/components/TopBar/index.tsx | 12 ++- .../TabsContent/Terminal/Terminal.tsx | 2 +- .../WorkspaceActionBar/WorkspaceActionBar.tsx | 34 ------ .../components/ViewModeToggle/index.ts | 1 - .../WorkspaceActionBarLeft.tsx | 41 ------- .../WorkspaceActionBarLeft/index.ts | 1 - .../WorkspaceActionBarRight/index.ts | 1 - .../WorkspaceView/WorkspaceActionBar/index.ts | 1 - .../main/components/WorkspaceView/index.tsx | 8 -- .../src/renderer/screens/main/index.tsx | 2 +- 17 files changed, 138 insertions(+), 170 deletions(-) create mode 100644 apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceControls/BranchIndicator.tsx rename apps/desktop/src/renderer/screens/main/components/{WorkspaceView/WorkspaceActionBar/components/WorkspaceActionBarRight/WorkspaceActionBarRight.tsx => TopBar/WorkspaceControls/OpenInMenuButton.tsx} (66%) rename apps/desktop/src/renderer/screens/main/components/{WorkspaceView/WorkspaceActionBar/components/ViewModeToggle/ViewModeToggle.tsx => TopBar/WorkspaceControls/ViewModeToggleCompact.tsx} (50%) create mode 100644 apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceControls/WorkspaceControls.tsx create mode 100644 apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceControls/index.ts delete mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/WorkspaceActionBar.tsx delete mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/ViewModeToggle/index.ts delete mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/WorkspaceActionBarLeft/WorkspaceActionBarLeft.tsx delete mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/WorkspaceActionBarLeft/index.ts delete mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/WorkspaceActionBarRight/index.ts delete mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/index.ts diff --git a/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts b/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts index ed920e2070d..5c47f6e7c35 100644 --- a/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts +++ b/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts @@ -8,8 +8,8 @@ import { writeFile, } from "node:fs/promises"; import { - PathValidationError, assertRegisteredWorktree, + PathValidationError, resolvePathInWorktree, } from "./path-validation"; @@ -40,7 +40,7 @@ async function assertRealpathInWorktree( const worktreeReal = await realpath(worktreePath); // Ensure realpath is within worktree (with proper boundary check) - if (!real.startsWith(worktreeReal + "/") && real !== worktreeReal) { + if (!real.startsWith(`${worktreeReal}/`) && real !== worktreeReal) { throw new PathValidationError( "File is a symlink pointing outside the worktree", "SYMLINK_ESCAPE", @@ -188,7 +188,7 @@ export const secureFs = { const real = await realpath(fullPath); const worktreeReal = await realpath(worktreePath); - return !real.startsWith(worktreeReal + "/") && real !== worktreeReal; + return !real.startsWith(`${worktreeReal}/`) && real !== worktreeReal; } catch { // If we can't determine, assume not escaping (file may not exist) return false; diff --git a/apps/desktop/src/renderer/react-query/workspaces/useWorkspaceDeleteHandler.ts b/apps/desktop/src/renderer/react-query/workspaces/useWorkspaceDeleteHandler.ts index b7100f5a753..2c88bf1915c 100644 --- a/apps/desktop/src/renderer/react-query/workspaces/useWorkspaceDeleteHandler.ts +++ b/apps/desktop/src/renderer/react-query/workspaces/useWorkspaceDeleteHandler.ts @@ -72,8 +72,7 @@ export function useWorkspaceDeleteHandler({ // Only skip dialog if we have data confirming it's safe to delete const isEmpty = - canDeleteData && - canDeleteData.canDelete && + canDeleteData?.canDelete && canDeleteData.activeTerminalCount === 0 && !canDeleteData.warning && !canDeleteData.hasChanges && diff --git a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceControls/BranchIndicator.tsx b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceControls/BranchIndicator.tsx new file mode 100644 index 00000000000..3146293114f --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceControls/BranchIndicator.tsx @@ -0,0 +1,29 @@ +import { Tooltip, TooltipContent, TooltipTrigger } from "@superset/ui/tooltip"; +import { GoGitBranch } from "react-icons/go"; + +interface BranchIndicatorProps { + branch: string | undefined; +} + +export function BranchIndicator({ branch }: BranchIndicatorProps) { + if (!branch) return null; + + return ( + + + + + + Current branch + + + ); +} diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/WorkspaceActionBarRight/WorkspaceActionBarRight.tsx b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceControls/OpenInMenuButton.tsx similarity index 66% rename from apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/WorkspaceActionBarRight/WorkspaceActionBarRight.tsx rename to apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceControls/OpenInMenuButton.tsx index 222cade48cf..5287546fbee 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/WorkspaceActionBarRight/WorkspaceActionBarRight.tsx +++ b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceControls/OpenInMenuButton.tsx @@ -10,9 +10,11 @@ import { DropdownMenuSubTrigger, DropdownMenuTrigger, } from "@superset/ui/dropdown-menu"; +import { toast } from "@superset/ui/sonner"; import { Tooltip, TooltipContent, TooltipTrigger } from "@superset/ui/tooltip"; +import { cn } from "@superset/ui/utils"; import { HiChevronDown } from "react-icons/hi2"; -import { LuArrowUpRight, LuCopy } from "react-icons/lu"; +import { LuCopy } from "react-icons/lu"; import jetbrainsIcon from "renderer/assets/app-icons/jetbrains.svg"; import vscodeIcon from "renderer/assets/app-icons/vscode.svg"; import { @@ -21,117 +23,105 @@ import { JETBRAINS_OPTIONS, VSCODE_OPTIONS, } from "renderer/components/OpenInButton"; -import { shortenHomePath } from "renderer/lib/formatPath"; import { trpc } from "renderer/lib/trpc"; import { useHotkeyText } from "renderer/stores/hotkeys"; -interface FormattedPath { - prefix: string; - worktreeName: string; -} - -function formatWorktreePath( - path: string, - homeDir: string | undefined, -): FormattedPath { - const shortenedPath = shortenHomePath(path, homeDir); - - // Split into prefix and worktree name (last segment) - const lastSlashIndex = shortenedPath.lastIndexOf("/"); - if (lastSlashIndex !== -1) { - return { - prefix: shortenedPath.slice(0, lastSlashIndex + 1), - worktreeName: shortenedPath.slice(lastSlashIndex + 1), - }; - } - - return { prefix: "", worktreeName: shortenedPath }; -} - -interface WorkspaceActionBarRightProps { +interface OpenInMenuButtonProps { worktreePath: string; } -export function WorkspaceActionBarRight({ - worktreePath, -}: WorkspaceActionBarRightProps) { - const { data: homeDir } = trpc.window.getHomeDir.useQuery(); +export function OpenInMenuButton({ worktreePath }: OpenInMenuButtonProps) { const utils = trpc.useUtils(); const { data: lastUsedApp = "cursor" } = trpc.settings.getLastUsedApp.useQuery(); const openInApp = trpc.external.openInApp.useMutation({ onSuccess: () => utils.settings.getLastUsedApp.invalidate(), + onError: (error) => toast.error(`Failed to open: ${error.message}`), + }); + const copyPath = trpc.external.copyPath.useMutation({ + onSuccess: () => toast.success("Path copied to clipboard"), + onError: (error) => toast.error(`Failed to copy path: ${error.message}`), }); - const copyPath = trpc.external.copyPath.useMutation(); - const formattedPath = formatWorktreePath(worktreePath, homeDir); const currentApp = getAppOption(lastUsedApp); const openInShortcut = useHotkeyText("OPEN_IN_APP"); const copyPathShortcut = useHotkeyText("COPY_PATH"); const showOpenInShortcut = openInShortcut !== "Unassigned"; const showCopyPathShortcut = copyPathShortcut !== "Unassigned"; + const isLoading = openInApp.isPending || copyPath.isPending; const handleOpenInEditor = () => { + if (isLoading) return; openInApp.mutate({ path: worktreePath, app: lastUsedApp }); }; const handleOpenInOtherApp = (appId: ExternalApp) => { + if (isLoading) return; openInApp.mutate({ path: worktreePath, app: appId }); }; const handleCopyPath = () => { + if (isLoading) return; copyPath.mutate(worktreePath); }; const BUTTON_HEIGHT = 24; return ( - <> - {/* Path - clickable to open */} +
+ {/* Main button - opens in last used app */} - - - Open in {currentApp.displayLabel ?? currentApp.label} - - {showOpenInShortcut ? openInShortcut : "—"} - - + +
+ + Open in {currentApp.displayLabel ?? currentApp.label} + {showOpenInShortcut && ( + + {openInShortcut} + + )} + + + {worktreePath} + +
- {/* Open dropdown button */} + {/* Dropdown trigger */} @@ -215,6 +205,6 @@ export function WorkspaceActionBarRight({ - +
); } diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/ViewModeToggle/ViewModeToggle.tsx b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceControls/ViewModeToggleCompact.tsx similarity index 50% rename from apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/ViewModeToggle/ViewModeToggle.tsx rename to apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceControls/ViewModeToggleCompact.tsx index 00b93eaf6dc..a93f91fb3c6 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/ViewModeToggle/ViewModeToggle.tsx +++ b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceControls/ViewModeToggleCompact.tsx @@ -1,39 +1,43 @@ import { cn } from "@superset/ui/utils"; -import { trpc } from "renderer/lib/trpc"; import { useWorkspaceViewModeStore, type WorkspaceViewMode, } from "renderer/stores/workspace-view-mode"; -export function ViewModeToggle() { - const { data: activeWorkspace } = trpc.workspaces.getActive.useQuery(); - const workspaceId = activeWorkspace?.id; +interface ViewModeToggleCompactProps { + workspaceId: string; +} - const viewModeByWorkspaceId = useWorkspaceViewModeStore( - (s) => s.viewModeByWorkspaceId, +export function ViewModeToggleCompact({ + workspaceId, +}: ViewModeToggleCompactProps) { + // Select only this workspace's mode to minimize rerenders + const currentMode = useWorkspaceViewModeStore( + (s) => s.viewModeByWorkspaceId[workspaceId] ?? "workbench", ); const setWorkspaceViewMode = useWorkspaceViewModeStore( (s) => s.setWorkspaceViewMode, ); - if (!workspaceId) return null; - - const currentMode = viewModeByWorkspaceId[workspaceId] ?? "workbench"; - const handleModeChange = (mode: WorkspaceViewMode) => { setWorkspaceViewMode(workspaceId, mode); }; + const BUTTON_HEIGHT = 24; + return ( -
+
{isSidebarMode ? ( -
+
{activeWorkspace && ( {activeWorkspace.project?.name ?? "Workspace"} @@ -40,12 +41,17 @@ export function TopBar({ navigationStyle = "top-bar" }: TopBarProps) { )}
) : ( -
+
)} -
+
+ {!isMac && }
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index 0294049054a..2c73582c9af 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -88,7 +88,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { // e.g., /repo vs /repo-other should not match if (path === workspaceCwd) { filePath = "."; - } else if (path.startsWith(workspaceCwd + "/")) { + } else if (path.startsWith(`${workspaceCwd}/`)) { filePath = path.slice(workspaceCwd.length + 1); } else if (path.startsWith("/")) { // Absolute path outside workspace - still try to open it diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/WorkspaceActionBar.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/WorkspaceActionBar.tsx deleted file mode 100644 index 97bf9abdda1..00000000000 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/WorkspaceActionBar.tsx +++ /dev/null @@ -1,34 +0,0 @@ -import type { NavigationStyle } from "@superset/local-db"; -import { SidebarControl } from "../../SidebarControl"; -import { ViewModeToggle } from "./components/ViewModeToggle"; -import { WorkspaceActionBarLeft } from "./components/WorkspaceActionBarLeft"; -import { WorkspaceActionBarRight } from "./components/WorkspaceActionBarRight"; - -interface WorkspaceActionBarProps { - worktreePath: string | undefined; - navigationStyle?: NavigationStyle; -} - -export function WorkspaceActionBar({ - worktreePath, - navigationStyle = "top-bar", -}: WorkspaceActionBarProps) { - if (!worktreePath) return null; - - const isSidebarMode = navigationStyle === "sidebar"; - - return ( -
-
- {isSidebarMode && } - -
-
- -
-
- -
-
- ); -} diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/ViewModeToggle/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/ViewModeToggle/index.ts deleted file mode 100644 index 5e69ac17ef8..00000000000 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/ViewModeToggle/index.ts +++ /dev/null @@ -1 +0,0 @@ -export { ViewModeToggle } from "./ViewModeToggle"; diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/WorkspaceActionBarLeft/WorkspaceActionBarLeft.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/WorkspaceActionBarLeft/WorkspaceActionBarLeft.tsx deleted file mode 100644 index 0db773eb901..00000000000 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/WorkspaceActionBarLeft/WorkspaceActionBarLeft.tsx +++ /dev/null @@ -1,41 +0,0 @@ -import { Tooltip, TooltipContent, TooltipTrigger } from "@superset/ui/tooltip"; -import { GoGitBranch } from "react-icons/go"; -import { trpc } from "renderer/lib/trpc"; - -export function WorkspaceActionBarLeft() { - const { data: activeWorkspace } = trpc.workspaces.getActive.useQuery(); - const currentBranch = activeWorkspace?.worktree?.branch; - const baseBranch = activeWorkspace?.worktree?.baseBranch; - return ( - <> - {currentBranch && ( - - - - - - {currentBranch} - - - - - Current branch - - - )} - {baseBranch && baseBranch !== currentBranch && ( - - - - from - {baseBranch} - - - - Based on {baseBranch} - - - )} - - ); -} diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/WorkspaceActionBarLeft/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/WorkspaceActionBarLeft/index.ts deleted file mode 100644 index 9a42acaa856..00000000000 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/WorkspaceActionBarLeft/index.ts +++ /dev/null @@ -1 +0,0 @@ -export { WorkspaceActionBarLeft } from "./WorkspaceActionBarLeft"; diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/WorkspaceActionBarRight/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/WorkspaceActionBarRight/index.ts deleted file mode 100644 index da70bada5b9..00000000000 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/components/WorkspaceActionBarRight/index.ts +++ /dev/null @@ -1 +0,0 @@ -export { WorkspaceActionBarRight } from "./WorkspaceActionBarRight"; diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/index.ts deleted file mode 100644 index c8caa3fbcd3..00000000000 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/WorkspaceActionBar/index.ts +++ /dev/null @@ -1 +0,0 @@ -export { WorkspaceActionBar } from "./WorkspaceActionBar"; diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/index.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/index.tsx index 3c44c7f0a20..b8f8f07bbf2 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/index.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/index.tsx @@ -4,16 +4,12 @@ import { trpc } from "renderer/lib/trpc"; import { useTabsStore } from "renderer/stores/tabs/store"; import { getNextPaneId, getPreviousPaneId } from "renderer/stores/tabs/utils"; import { useWorkspaceViewModeStore } from "renderer/stores/workspace-view-mode"; -import { DEFAULT_NAVIGATION_STYLE } from "shared/constants"; import { HOTKEYS } from "shared/hotkeys"; import { ContentView } from "./ContentView"; import { ResizableSidebar } from "./ResizableSidebar"; -import { WorkspaceActionBar } from "./WorkspaceActionBar"; export function WorkspaceView() { const { data: activeWorkspace } = trpc.workspaces.getActive.useQuery(); - const { data: navigationStyle } = trpc.settings.getNavigationStyle.useQuery(); - const effectiveNavigationStyle = navigationStyle ?? DEFAULT_NAVIGATION_STYLE; const activeWorkspaceId = activeWorkspace?.id; const allTabs = useTabsStore((s) => s.tabs); const activeTabIds = useTabsStore((s) => s.activeTabIds); @@ -133,10 +129,6 @@ export function WorkspaceView() {
-
diff --git a/apps/desktop/src/renderer/screens/main/index.tsx b/apps/desktop/src/renderer/screens/main/index.tsx index 2d5f5543392..620b56b7463 100644 --- a/apps/desktop/src/renderer/screens/main/index.tsx +++ b/apps/desktop/src/renderer/screens/main/index.tsx @@ -2,8 +2,8 @@ import { FEATURE_FLAGS } from "@superset/shared/constants"; import { Button } from "@superset/ui/button"; import { useFeatureFlagEnabled } from "posthog-js/react"; import { useCallback, useState } from "react"; -import { useHotkeys } from "react-hotkeys-hook"; import { DndProvider } from "react-dnd"; +import { useHotkeys } from "react-hotkeys-hook"; import { HiArrowPath } from "react-icons/hi2"; import { NewWorkspaceModal } from "renderer/components/NewWorkspaceModal"; import { SetupConfigModal } from "renderer/components/SetupConfigModal"; From e3111f206984f33e70d63318359148cbad796eac Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Fri, 2 Jan 2026 10:01:01 +0200 Subject: [PATCH 28/98] fix(desktop): always show close/delete dialog for workspaces - Simplify useWorkspaceDeleteHandler to always show dialog instead of auto-deleting clean workspaces - Update tooltip from 'Delete workspace' to 'Close or delete' for clarity - Add isUnread state for workspace unread tracking - Add workspace setUnread mutation and schema migration --- .../lib/trpc/routers/workspaces/workspaces.ts | 35 +- .../workspaces/useSetActiveWorkspace.ts | 33 +- .../workspaces/useWorkspaceDeleteHandler.ts | 89 +- .../TopBar/WorkspaceTabs/WorkspaceGroup.tsx | 2 + .../TopBar/WorkspaceTabs/WorkspaceItem.tsx | 16 +- .../WorkspaceItemContextMenu.tsx | 42 +- .../ProjectSection/ProjectSection.tsx | 2 + .../WorkspaceListItem/WorkspaceListItem.tsx | 54 +- .../desktop/src/renderer/stores/tabs/store.ts | 27 - .../desktop/src/renderer/stores/tabs/types.ts | 1 - .../drizzle/0007_add_workspace_is_unread.sql | 1 + .../local-db/drizzle/meta/0007_snapshot.json | 992 ++++++++++++++++++ packages/local-db/drizzle/meta/_journal.json | 7 + packages/local-db/src/schema/schema.ts | 1 + 14 files changed, 1151 insertions(+), 151 deletions(-) create mode 100644 packages/local-db/drizzle/0007_add_workspace_is_unread.sql create mode 100644 packages/local-db/drizzle/meta/0007_snapshot.json diff --git a/apps/desktop/src/lib/trpc/routers/workspaces/workspaces.ts b/apps/desktop/src/lib/trpc/routers/workspaces/workspaces.ts index fe99a498631..4a57d0a0c8c 100644 --- a/apps/desktop/src/lib/trpc/routers/workspaces/workspaces.ts +++ b/apps/desktop/src/lib/trpc/routers/workspaces/workspaces.ts @@ -583,6 +583,7 @@ export const createWorkspacesRouter = () => { createdAt: number; updatedAt: number; lastOpenedAt: number; + isUnread: boolean; }>; } >(); @@ -612,6 +613,7 @@ export const createWorkspacesRouter = () => { ...workspace, type: workspace.type as "worktree" | "branch", worktreePath: getWorkspacePath(workspace) ?? "", + isUnread: workspace.isUnread ?? false, }); } } @@ -1014,10 +1016,18 @@ export const createWorkspacesRouter = () => { throw new Error(`Workspace ${input.id} not found`); } + // Track if workspace was unread before clearing + const wasUnread = workspace.isUnread ?? false; + const now = Date.now(); localDb .update(workspaces) - .set({ lastOpenedAt: now, updatedAt: now }) + .set({ + lastOpenedAt: now, + updatedAt: now, + // Auto-clear unread state when switching to workspace + isUnread: false, + }) .where(eq(workspaces.id, input.id)) .run(); @@ -1030,7 +1040,7 @@ export const createWorkspacesRouter = () => { }) .run(); - return { success: true }; + return { success: true, wasUnread }; }), reorder: publicProcedure @@ -1368,6 +1378,27 @@ export const createWorkspacesRouter = () => { }; }), + setUnread: publicProcedure + .input(z.object({ id: z.string(), isUnread: z.boolean() })) + .mutation(({ input }) => { + const workspace = localDb + .select() + .from(workspaces) + .where(eq(workspaces.id, input.id)) + .get(); + if (!workspace) { + throw new Error(`Workspace ${input.id} not found`); + } + + localDb + .update(workspaces) + .set({ isUnread: input.isUnread }) + .where(eq(workspaces.id, input.id)) + .run(); + + return { success: true, isUnread: input.isUnread }; + }), + close: publicProcedure .input(z.object({ id: z.string() })) .mutation(async ({ input }) => { diff --git a/apps/desktop/src/renderer/react-query/workspaces/useSetActiveWorkspace.ts b/apps/desktop/src/renderer/react-query/workspaces/useSetActiveWorkspace.ts index 7dc43e36b0b..dfbff3ef05a 100644 --- a/apps/desktop/src/renderer/react-query/workspaces/useSetActiveWorkspace.ts +++ b/apps/desktop/src/renderer/react-query/workspaces/useSetActiveWorkspace.ts @@ -1,23 +1,48 @@ +import { toast } from "@superset/ui/sonner"; import { trpc } from "renderer/lib/trpc"; /** * Mutation hook for setting the active workspace * Automatically invalidates getActive and getAll queries on success + * Shows undo toast if workspace was marked as unread (auto-cleared on switch) */ export function useSetActiveWorkspace( options?: Parameters[0], ) { const utils = trpc.useUtils(); + const setUnread = trpc.workspaces.setUnread.useMutation({ + onSuccess: () => { + utils.workspaces.getAllGrouped.invalidate(); + }, + }); return trpc.workspaces.setActive.useMutation({ ...options, - onSuccess: async (...args) => { + onSuccess: async (data, variables, ...rest) => { // Auto-invalidate active workspace and all workspaces queries - await utils.workspaces.getActive.invalidate(); - await utils.workspaces.getAll.invalidate(); + await Promise.all([ + utils.workspaces.getActive.invalidate(), + utils.workspaces.getAll.invalidate(), + utils.workspaces.getAllGrouped.invalidate(), + ]); + + // Show undo toast if workspace was marked as unread + if (data.wasUnread) { + toast("Marked as read", { + description: "Workspace unread marker cleared", + action: { + label: "Undo", + onClick: () => { + setUnread.mutate({ id: variables.id, isUnread: true }); + }, + }, + duration: 5000, + }); + } // Call user's onSuccess if provided - await options?.onSuccess?.(...args); + // biome-ignore lint/suspicious/noExplicitAny: spread args for compatibility + await (options?.onSuccess as any)?.(data, variables, ...rest); }, }); } diff --git a/apps/desktop/src/renderer/react-query/workspaces/useWorkspaceDeleteHandler.ts b/apps/desktop/src/renderer/react-query/workspaces/useWorkspaceDeleteHandler.ts index 2c88bf1915c..cdd2075e12b 100644 --- a/apps/desktop/src/renderer/react-query/workspaces/useWorkspaceDeleteHandler.ts +++ b/apps/desktop/src/renderer/react-query/workspaces/useWorkspaceDeleteHandler.ts @@ -1,104 +1,29 @@ -import { toast } from "@superset/ui/sonner"; import { useState } from "react"; -import { trpc } from "renderer/lib/trpc"; -import { useDeleteWorkspace } from "./useDeleteWorkspace"; - -interface UseWorkspaceDeleteHandlerParams { - id: string; - name: string; - type: "worktree" | "branch"; -} interface UseWorkspaceDeleteHandlerResult { /** Whether the delete dialog should be shown */ showDeleteDialog: boolean; /** Set whether the delete dialog should be shown */ setShowDeleteDialog: (show: boolean) => void; - /** Handle delete click - checks conditions and either deletes directly or shows dialog */ - handleDeleteClick: (e?: React.MouseEvent) => Promise; - /** Whether a delete operation is pending */ - isPending: boolean; + /** Handle delete click - always shows the dialog to let user choose close or delete */ + handleDeleteClick: (e?: React.MouseEvent) => void; } /** - * Shared hook for workspace delete logic. - * Handles the decision of whether to show confirmation dialog or delete directly. - * - * For branch workspaces: Shows dialog only if there are active terminals - * For worktree workspaces: Shows dialog if there are changes, unpushed commits, or terminals + * Shared hook for workspace delete/close dialog state. + * Always shows the confirmation dialog to let user choose between closing or deleting. */ -export function useWorkspaceDeleteHandler({ - id, - name, - type, -}: UseWorkspaceDeleteHandlerParams): UseWorkspaceDeleteHandlerResult { +export function useWorkspaceDeleteHandler(): UseWorkspaceDeleteHandlerResult { const [showDeleteDialog, setShowDeleteDialog] = useState(false); - const deleteWorkspace = useDeleteWorkspace(); - const isBranchWorkspace = type === "branch"; - const canDeleteQuery = trpc.workspaces.canDelete.useQuery( - { id }, - { enabled: false }, - ); - - const handleDeleteClick = async (e?: React.MouseEvent) => { + const handleDeleteClick = (e?: React.MouseEvent) => { e?.stopPropagation(); - - if (deleteWorkspace.isPending || canDeleteQuery.isFetching) return; - - try { - const { data: canDeleteData } = await canDeleteQuery.refetch(); - - if (isBranchWorkspace) { - // Show dialog if we couldn't get data (safe default) or there are active terminals - if ( - !canDeleteData || - (canDeleteData.activeTerminalCount && - canDeleteData.activeTerminalCount > 0) - ) { - setShowDeleteDialog(true); - } else { - toast.promise(deleteWorkspace.mutateAsync({ id }), { - loading: `Closing "${name}"...`, - success: `Workspace "${name}" closed`, - error: (error) => - error instanceof Error - ? `Failed to close workspace: ${error.message}` - : "Failed to close workspace", - }); - } - return; - } - - // Only skip dialog if we have data confirming it's safe to delete - const isEmpty = - canDeleteData?.canDelete && - canDeleteData.activeTerminalCount === 0 && - !canDeleteData.warning && - !canDeleteData.hasChanges && - !canDeleteData.hasUnpushedCommits; - - if (isEmpty) { - toast.promise(deleteWorkspace.mutateAsync({ id }), { - loading: `Deleting "${name}"...`, - success: `Workspace "${name}" deleted`, - error: (error) => - error instanceof Error - ? `Failed to delete workspace: ${error.message}` - : "Failed to delete workspace", - }); - } else { - setShowDeleteDialog(true); - } - } catch { - setShowDeleteDialog(true); - } + setShowDeleteDialog(true); }; return { showDeleteDialog, setShowDeleteDialog, handleDeleteClick, - isPending: deleteWorkspace.isPending || canDeleteQuery.isFetching, }; } diff --git a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceGroup.tsx b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceGroup.tsx index 0b042f2ef52..75505bf3313 100644 --- a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceGroup.tsx +++ b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceGroup.tsx @@ -11,6 +11,7 @@ interface Workspace { branch: string; name: string; tabOrder: number; + isUnread: boolean; } interface WorkspaceGroupProps { @@ -79,6 +80,7 @@ export function WorkspaceGroup({ branch={workspace.branch} title={workspace.name} isActive={workspace.id === activeWorkspaceId} + isUnread={workspace.isUnread} index={index} width={workspaceWidth} onMouseEnter={() => onWorkspaceHover(workspace.id)} diff --git a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx index 2f91dbcbb9c..b98e36c98c2 100644 --- a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx +++ b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx @@ -29,6 +29,7 @@ interface WorkspaceItemProps { branch?: string; title: string; isActive: boolean; + isUnread?: boolean; index: number; width: number; onMouseEnter?: () => void; @@ -43,6 +44,7 @@ export function WorkspaceItem({ branch, title, isActive, + isUnread = false, index, width, onMouseEnter, @@ -61,17 +63,20 @@ export function WorkspaceItem({ // Shared delete logic const { showDeleteDialog, setShowDeleteDialog, handleDeleteClick } = - useWorkspaceDeleteHandler({ id, name: title, type: workspaceType }); + useWorkspaceDeleteHandler(); - // Check if any pane in tabs belonging to this workspace needs attention + // Check if any pane in tabs belonging to this workspace needs attention (agent notifications) const workspaceTabs = tabs.filter((t) => t.workspaceId === id); const workspacePaneIds = new Set( workspaceTabs.flatMap((t) => extractPaneIdsFromLayout(t.layout)), ); - const needsAttention = Object.values(panes) + const hasPaneAttention = Object.values(panes) .filter((p) => workspacePaneIds.has(p.id)) .some((p) => p.needsAttention); + // Show indicator if workspace is manually marked as unread OR has pane-level attention + const needsAttention = isUnread || hasPaneAttention; + const [{ isDragging }, drag] = useDrag( () => ({ type: WORKSPACE_TYPE, @@ -104,6 +109,7 @@ export function WorkspaceItem({ workspaceId={id} worktreePath={worktreePath} workspaceAlias={title} + isUnread={isUnread} onRename={rename.startRename} canRename={!isBranchWorkspace} showHoverCard={!isBranchWorkspace} @@ -228,13 +234,13 @@ export function WorkspaceItem({ "mt-1 absolute right-1 top-1/2 -translate-y-1/2 cursor-pointer size-5 group-hover:opacity-100", isActive ? "opacity-90" : "opacity-0", )} - aria-label="Delete workspace" + aria-label="Close or delete workspace" > - Delete workspace + Close or delete )} diff --git a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItemContextMenu.tsx b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItemContextMenu.tsx index e514e552b8f..81b8b6ce181 100644 --- a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItemContextMenu.tsx +++ b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItemContextMenu.tsx @@ -11,9 +11,8 @@ import { HoverCardTrigger, } from "@superset/ui/hover-card"; import type { ReactNode } from "react"; -import { LuEyeOff } from "react-icons/lu"; +import { LuEye, LuEyeOff } from "react-icons/lu"; import { trpc } from "renderer/lib/trpc"; -import { useTabsStore } from "renderer/stores/tabs/store"; import { WorkspaceHoverCardContent } from "./WorkspaceHoverCard"; interface WorkspaceItemContextMenuProps { @@ -21,6 +20,7 @@ interface WorkspaceItemContextMenuProps { workspaceId: string; worktreePath: string; workspaceAlias?: string; + isUnread?: boolean; onRename: () => void; canRename?: boolean; showHoverCard?: boolean; @@ -31,12 +31,18 @@ export function WorkspaceItemContextMenu({ workspaceId, worktreePath, workspaceAlias, + isUnread = false, onRename, canRename = true, showHoverCard = true, }: WorkspaceItemContextMenuProps) { + const utils = trpc.useUtils(); const openInFinder = trpc.external.openInFinder.useMutation(); - const markWorkspaceAsUnread = useTabsStore((s) => s.markWorkspaceAsUnread); + const setUnread = trpc.workspaces.setUnread.useMutation({ + onSuccess: () => { + utils.workspaces.getAllGrouped.invalidate(); + }, + }); const handleOpenInFinder = () => { if (worktreePath) { @@ -44,10 +50,26 @@ export function WorkspaceItemContextMenu({ } }; - const handleMarkAsUnread = () => { - markWorkspaceAsUnread(workspaceId); + const handleToggleUnread = () => { + setUnread.mutate({ id: workspaceId, isUnread: !isUnread }); }; + const unreadMenuItem = ( + + {isUnread ? ( + <> + + Mark as Read + + ) : ( + <> + + Mark as Unread + + )} + + ); + // For branch workspaces, just show context menu without hover card if (!showHoverCard) { return ( @@ -64,10 +86,7 @@ export function WorkspaceItemContextMenu({ Open in Finder - - - Mark as Unread - + {unreadMenuItem} ); @@ -90,10 +109,7 @@ export function WorkspaceItemContextMenu({ Open in Finder - - - Mark as Unread - + {unreadMenuItem} diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/ProjectSection/ProjectSection.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/ProjectSection/ProjectSection.tsx index 0f52fec1a79..75c933b2482 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/ProjectSection/ProjectSection.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/ProjectSection/ProjectSection.tsx @@ -22,6 +22,7 @@ interface Workspace { branch: string; name: string; tabOrder: number; + isUnread: boolean; } interface ProjectSectionProps { @@ -95,6 +96,7 @@ export function ProjectSection({ branch={workspace.branch} type={workspace.type} isActive={workspace.id === activeWorkspaceId} + isUnread={workspace.isUnread} index={index} shortcutIndex={shortcutBaseIndex + index} /> diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx index a955e51a65d..9a1ca16b45d 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx @@ -17,7 +17,7 @@ import { cn } from "@superset/ui/utils"; import { useState } from "react"; import { useDrag, useDrop } from "react-dnd"; import { HiMiniXMark } from "react-icons/hi2"; -import { LuEyeOff, LuGitBranch } from "react-icons/lu"; +import { LuEye, LuEyeOff, LuGitBranch } from "react-icons/lu"; import { trpc } from "renderer/lib/trpc"; import { useReorderWorkspaces, @@ -49,6 +49,7 @@ interface WorkspaceListItemProps { branch: string; type: "worktree" | "branch"; isActive: boolean; + isUnread?: boolean; index: number; shortcutIndex?: number; } @@ -61,6 +62,7 @@ export function WorkspaceListItem({ branch, type, isActive, + isUnread = false, index, shortcutIndex, }: WorkspaceListItemProps) { @@ -71,15 +73,20 @@ export function WorkspaceListItem({ const rename = useWorkspaceRename(id, name); const tabs = useTabsStore((s) => s.tabs); const panes = useTabsStore((s) => s.panes); - const markWorkspaceAsUnread = useTabsStore((s) => s.markWorkspaceAsUnread); const clearWorkspaceAttention = useTabsStore( (s) => s.clearWorkspaceAttention, ); + const utils = trpc.useUtils(); const openInFinder = trpc.external.openInFinder.useMutation(); + const setUnread = trpc.workspaces.setUnread.useMutation({ + onSuccess: () => { + utils.workspaces.getAllGrouped.invalidate(); + }, + }); // Shared delete logic const { showDeleteDialog, setShowDeleteDialog, handleDeleteClick } = - useWorkspaceDeleteHandler({ id, name, type }); + useWorkspaceDeleteHandler(); // Lazy-load GitHub status on hover to avoid N+1 queries const { data: githubStatus } = trpc.workspaces.getGitHubStatus.useQuery( @@ -90,15 +97,18 @@ export function WorkspaceListItem({ }, ); - // Check if any pane in tabs belonging to this workspace needs attention + // Check if any pane in tabs belonging to this workspace needs attention (agent notifications) const workspaceTabs = tabs.filter((t) => t.workspaceId === id); const workspacePaneIds = new Set( workspaceTabs.flatMap((t) => extractPaneIdsFromLayout(t.layout)), ); - const needsAttention = Object.values(panes) + const hasPaneAttention = Object.values(panes) .filter((p) => workspacePaneIds.has(p.id)) .some((p) => p.needsAttention); + // Show indicator if workspace is manually marked as unread OR has pane-level attention + const needsAttention = isUnread || hasPaneAttention; + const handleClick = () => { if (!rename.isRenaming) { setActiveWorkspace.mutate({ id }); @@ -118,8 +128,8 @@ export function WorkspaceListItem({ } }; - const handleMarkAsUnread = () => { - markWorkspaceAsUnread(id); + const handleToggleUnread = () => { + setUnread.mutate({ id, isUnread: !isUnread }); }; // Drag and drop @@ -251,19 +261,35 @@ export function WorkspaceListItem({ "size-5 shrink-0 opacity-0 group-hover:opacity-100 transition-opacity", isActive && "opacity-70", )} - aria-label="Delete workspace" + aria-label="Close or delete workspace" > - Delete workspace + Close or delete )} ); + const unreadMenuItem = ( + + {isUnread ? ( + <> + + Mark as Read + + ) : ( + <> + + Mark as Unread + + )} + + ); + // Wrap with context menu and hover card if (isBranchWorkspace) { return ( @@ -275,10 +301,7 @@ export function WorkspaceListItem({ Open in Finder - - - Mark as Unread - + {unreadMenuItem} - - - Mark as Unread - + {unreadMenuItem} diff --git a/apps/desktop/src/renderer/stores/tabs/store.ts b/apps/desktop/src/renderer/stores/tabs/store.ts index 9347c4d1b21..6e6823d33e0 100644 --- a/apps/desktop/src/renderer/stores/tabs/store.ts +++ b/apps/desktop/src/renderer/stores/tabs/store.ts @@ -543,33 +543,6 @@ export const useTabsStore = create()( })); }, - markWorkspaceAsUnread: (workspaceId) => { - const state = get(); - const workspaceTabs = state.tabs.filter( - (t) => t.workspaceId === workspaceId, - ); - const workspacePaneIds = workspaceTabs.flatMap((t) => - extractPaneIdsFromLayout(t.layout), - ); - - if (workspacePaneIds.length === 0) { - console.log( - "[tabs/markUnread] No panes to mark for workspace:", - workspaceId, - ); - return; - } - - const newPanes = { ...state.panes }; - for (const paneId of workspacePaneIds) { - if (newPanes[paneId]) { - newPanes[paneId] = { ...newPanes[paneId], needsAttention: true }; - } - } - - set({ panes: newPanes }); - }, - clearWorkspaceAttention: (workspaceId) => { const state = get(); const workspaceTabs = state.tabs.filter( diff --git a/apps/desktop/src/renderer/stores/tabs/types.ts b/apps/desktop/src/renderer/stores/tabs/types.ts index d6f43ab6e00..64a298ab958 100644 --- a/apps/desktop/src/renderer/stores/tabs/types.ts +++ b/apps/desktop/src/renderer/stores/tabs/types.ts @@ -70,7 +70,6 @@ export interface TabsStore extends TabsState { setFocusedPane: (tabId: string, paneId: string) => void; markPaneAsUsed: (paneId: string) => void; setNeedsAttention: (paneId: string, needsAttention: boolean) => void; - markWorkspaceAsUnread: (workspaceId: string) => void; clearWorkspaceAttention: (workspaceId: string) => void; updatePaneCwd: ( paneId: string, diff --git a/packages/local-db/drizzle/0007_add_workspace_is_unread.sql b/packages/local-db/drizzle/0007_add_workspace_is_unread.sql new file mode 100644 index 00000000000..9f3ca8ec300 --- /dev/null +++ b/packages/local-db/drizzle/0007_add_workspace_is_unread.sql @@ -0,0 +1 @@ +ALTER TABLE `workspaces` ADD `is_unread` integer DEFAULT false; diff --git a/packages/local-db/drizzle/meta/0007_snapshot.json b/packages/local-db/drizzle/meta/0007_snapshot.json new file mode 100644 index 00000000000..dbf24a697c3 --- /dev/null +++ b/packages/local-db/drizzle/meta/0007_snapshot.json @@ -0,0 +1,992 @@ +{ + "version": "6", + "dialect": "sqlite", + "id": "a7b8c9d0-e1f2-3456-7890-abcdef123456", + "prevId": "f1e2d3c4-b5a6-7890-abcd-ef1234567890", + "tables": { + "organization_members": { + "name": "organization_members", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "organization_id": { + "name": "organization_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "user_id": { + "name": "user_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "role": { + "name": "role", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + } + }, + "indexes": { + "organization_members_organization_id_idx": { + "name": "organization_members_organization_id_idx", + "columns": [ + "organization_id" + ], + "isUnique": false + }, + "organization_members_user_id_idx": { + "name": "organization_members_user_id_idx", + "columns": [ + "user_id" + ], + "isUnique": false + } + }, + "foreignKeys": { + "organization_members_organization_id_organizations_id_fk": { + "name": "organization_members_organization_id_organizations_id_fk", + "tableFrom": "organization_members", + "tableTo": "organizations", + "columnsFrom": [ + "organization_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + }, + "organization_members_user_id_users_id_fk": { + "name": "organization_members_user_id_users_id_fk", + "tableFrom": "organization_members", + "tableTo": "users", + "columnsFrom": [ + "user_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "organizations": { + "name": "organizations", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "clerk_org_id": { + "name": "clerk_org_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "name": { + "name": "name", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "slug": { + "name": "slug", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "github_org": { + "name": "github_org", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "avatar_url": { + "name": "avatar_url", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "updated_at": { + "name": "updated_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + } + }, + "indexes": { + "organizations_clerk_org_id_unique": { + "name": "organizations_clerk_org_id_unique", + "columns": [ + "clerk_org_id" + ], + "isUnique": true + }, + "organizations_slug_unique": { + "name": "organizations_slug_unique", + "columns": [ + "slug" + ], + "isUnique": true + }, + "organizations_slug_idx": { + "name": "organizations_slug_idx", + "columns": [ + "slug" + ], + "isUnique": false + }, + "organizations_clerk_org_id_idx": { + "name": "organizations_clerk_org_id_idx", + "columns": [ + "clerk_org_id" + ], + "isUnique": false + } + }, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "projects": { + "name": "projects", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "main_repo_path": { + "name": "main_repo_path", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "name": { + "name": "name", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "color": { + "name": "color", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "tab_order": { + "name": "tab_order", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "last_opened_at": { + "name": "last_opened_at", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "config_toast_dismissed": { + "name": "config_toast_dismissed", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "default_branch": { + "name": "default_branch", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + } + }, + "indexes": { + "projects_main_repo_path_idx": { + "name": "projects_main_repo_path_idx", + "columns": [ + "main_repo_path" + ], + "isUnique": false + }, + "projects_last_opened_at_idx": { + "name": "projects_last_opened_at_idx", + "columns": [ + "last_opened_at" + ], + "isUnique": false + } + }, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "settings": { + "name": "settings", + "columns": { + "id": { + "name": "id", + "type": "integer", + "primaryKey": true, + "notNull": true, + "autoincrement": false, + "default": 1 + }, + "last_active_workspace_id": { + "name": "last_active_workspace_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "last_used_app": { + "name": "last_used_app", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "terminal_presets": { + "name": "terminal_presets", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "terminal_presets_initialized": { + "name": "terminal_presets_initialized", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "selected_ringtone_id": { + "name": "selected_ringtone_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "active_organization_id": { + "name": "active_organization_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "confirm_on_quit": { + "name": "confirm_on_quit", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "terminal_link_behavior": { + "name": "terminal_link_behavior", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "navigation_style": { + "name": "navigation_style", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + } + }, + "indexes": {}, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "tasks": { + "name": "tasks", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "slug": { + "name": "slug", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "title": { + "name": "title", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "description": { + "name": "description", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "status": { + "name": "status", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "status_color": { + "name": "status_color", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "status_type": { + "name": "status_type", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "status_position": { + "name": "status_position", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "priority": { + "name": "priority", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "organization_id": { + "name": "organization_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "repository_id": { + "name": "repository_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "assignee_id": { + "name": "assignee_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "creator_id": { + "name": "creator_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "estimate": { + "name": "estimate", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "due_date": { + "name": "due_date", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "labels": { + "name": "labels", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "branch": { + "name": "branch", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "pr_url": { + "name": "pr_url", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "external_provider": { + "name": "external_provider", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "external_id": { + "name": "external_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "external_key": { + "name": "external_key", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "external_url": { + "name": "external_url", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "last_synced_at": { + "name": "last_synced_at", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "sync_error": { + "name": "sync_error", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "started_at": { + "name": "started_at", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "completed_at": { + "name": "completed_at", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "deleted_at": { + "name": "deleted_at", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "updated_at": { + "name": "updated_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + } + }, + "indexes": { + "tasks_slug_unique": { + "name": "tasks_slug_unique", + "columns": [ + "slug" + ], + "isUnique": true + }, + "tasks_slug_idx": { + "name": "tasks_slug_idx", + "columns": [ + "slug" + ], + "isUnique": false + }, + "tasks_organization_id_idx": { + "name": "tasks_organization_id_idx", + "columns": [ + "organization_id" + ], + "isUnique": false + }, + "tasks_assignee_id_idx": { + "name": "tasks_assignee_id_idx", + "columns": [ + "assignee_id" + ], + "isUnique": false + }, + "tasks_status_idx": { + "name": "tasks_status_idx", + "columns": [ + "status" + ], + "isUnique": false + }, + "tasks_created_at_idx": { + "name": "tasks_created_at_idx", + "columns": [ + "created_at" + ], + "isUnique": false + } + }, + "foreignKeys": { + "tasks_organization_id_organizations_id_fk": { + "name": "tasks_organization_id_organizations_id_fk", + "tableFrom": "tasks", + "tableTo": "organizations", + "columnsFrom": [ + "organization_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + }, + "tasks_assignee_id_users_id_fk": { + "name": "tasks_assignee_id_users_id_fk", + "tableFrom": "tasks", + "tableTo": "users", + "columnsFrom": [ + "assignee_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "set null", + "onUpdate": "no action" + }, + "tasks_creator_id_users_id_fk": { + "name": "tasks_creator_id_users_id_fk", + "tableFrom": "tasks", + "tableTo": "users", + "columnsFrom": [ + "creator_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "users": { + "name": "users", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "clerk_id": { + "name": "clerk_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "name": { + "name": "name", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "email": { + "name": "email", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "avatar_url": { + "name": "avatar_url", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "deleted_at": { + "name": "deleted_at", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "updated_at": { + "name": "updated_at", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + } + }, + "indexes": { + "users_clerk_id_unique": { + "name": "users_clerk_id_unique", + "columns": [ + "clerk_id" + ], + "isUnique": true + }, + "users_email_unique": { + "name": "users_email_unique", + "columns": [ + "email" + ], + "isUnique": true + }, + "users_email_idx": { + "name": "users_email_idx", + "columns": [ + "email" + ], + "isUnique": false + }, + "users_clerk_id_idx": { + "name": "users_clerk_id_idx", + "columns": [ + "clerk_id" + ], + "isUnique": false + } + }, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "workspaces": { + "name": "workspaces", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "project_id": { + "name": "project_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "worktree_id": { + "name": "worktree_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "type": { + "name": "type", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "branch": { + "name": "branch", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "name": { + "name": "name", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "tab_order": { + "name": "tab_order", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "updated_at": { + "name": "updated_at", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "last_opened_at": { + "name": "last_opened_at", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "is_unread": { + "name": "is_unread", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false, + "default": false + } + }, + "indexes": { + "workspaces_project_id_idx": { + "name": "workspaces_project_id_idx", + "columns": [ + "project_id" + ], + "isUnique": false + }, + "workspaces_worktree_id_idx": { + "name": "workspaces_worktree_id_idx", + "columns": [ + "worktree_id" + ], + "isUnique": false + }, + "workspaces_last_opened_at_idx": { + "name": "workspaces_last_opened_at_idx", + "columns": [ + "last_opened_at" + ], + "isUnique": false + } + }, + "foreignKeys": { + "workspaces_project_id_projects_id_fk": { + "name": "workspaces_project_id_projects_id_fk", + "tableFrom": "workspaces", + "tableTo": "projects", + "columnsFrom": [ + "project_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + }, + "workspaces_worktree_id_worktrees_id_fk": { + "name": "workspaces_worktree_id_worktrees_id_fk", + "tableFrom": "workspaces", + "tableTo": "worktrees", + "columnsFrom": [ + "worktree_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + }, + "worktrees": { + "name": "worktrees", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true, + "autoincrement": false + }, + "project_id": { + "name": "project_id", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "path": { + "name": "path", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "branch": { + "name": "branch", + "type": "text", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "base_branch": { + "name": "base_branch", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "created_at": { + "name": "created_at", + "type": "integer", + "primaryKey": false, + "notNull": true, + "autoincrement": false + }, + "git_status": { + "name": "git_status", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "github_status": { + "name": "github_status", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + } + }, + "indexes": { + "worktrees_project_id_idx": { + "name": "worktrees_project_id_idx", + "columns": [ + "project_id" + ], + "isUnique": false + }, + "worktrees_branch_idx": { + "name": "worktrees_branch_idx", + "columns": [ + "branch" + ], + "isUnique": false + } + }, + "foreignKeys": { + "worktrees_project_id_projects_id_fk": { + "name": "worktrees_project_id_projects_id_fk", + "tableFrom": "worktrees", + "tableTo": "projects", + "columnsFrom": [ + "project_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "checkConstraints": {} + } + }, + "views": {}, + "enums": {}, + "_meta": { + "schemas": {}, + "tables": {}, + "columns": {} + }, + "internal": { + "indexes": {} + } +} diff --git a/packages/local-db/drizzle/meta/_journal.json b/packages/local-db/drizzle/meta/_journal.json index d72a8fe1e80..c63757dc471 100644 --- a/packages/local-db/drizzle/meta/_journal.json +++ b/packages/local-db/drizzle/meta/_journal.json @@ -50,6 +50,13 @@ "when": 1767230000000, "tag": "0006_add_unique_branch_workspace_index", "breakpoints": true + }, + { + "idx": 7, + "version": "6", + "when": 1767350000000, + "tag": "0007_add_workspace_is_unread", + "breakpoints": true } ] } \ No newline at end of file diff --git a/packages/local-db/src/schema/schema.ts b/packages/local-db/src/schema/schema.ts index c708a32964f..b5437dd783d 100644 --- a/packages/local-db/src/schema/schema.ts +++ b/packages/local-db/src/schema/schema.ts @@ -101,6 +101,7 @@ export const workspaces = sqliteTable( lastOpenedAt: integer("last_opened_at") .notNull() .$defaultFn(() => Date.now()), + isUnread: integer("is_unread", { mode: "boolean" }).default(false), }, (table) => [ index("workspaces_project_id_idx").on(table.projectId), From 303a158599f68bb7967b93c09a55a496d0d7f651 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Fri, 2 Jan 2026 10:22:17 +0200 Subject: [PATCH 29/98] fix(desktop): resolve TypeScript errors in workspace-sidebar branch - Fix hotkey() typo to defineHotkey() in hotkeys.ts - Add getHotkey() helper that returns string (not null) for useHotkeys compatibility - Replace all HOTKEYS.*.keys usages with getHotkey() calls - Fix 'against-main' to 'against-base' in ChangeCategory references - Add proper type annotation in WorkspaceSidebarControl.tsx --- .../desktop/src/lib/trpc/routers/ui-state/index.ts | 2 +- .../src/renderer/hooks/useWorkspaceShortcuts.ts | 6 +++--- .../components/TopBar/WorkspaceSidebarControl.tsx | 11 +++++++++-- .../TabView/FileViewerPane/FileViewerPane.tsx | 8 ++++---- .../main/components/WorkspaceView/index.tsx | 14 +++++++------- apps/desktop/src/renderer/screens/main/index.tsx | 4 ++-- apps/desktop/src/shared/hotkeys.ts | 11 ++++++++++- 7 files changed, 36 insertions(+), 20 deletions(-) diff --git a/apps/desktop/src/lib/trpc/routers/ui-state/index.ts b/apps/desktop/src/lib/trpc/routers/ui-state/index.ts index 77b32e36286..acbfa3bae18 100644 --- a/apps/desktop/src/lib/trpc/routers/ui-state/index.ts +++ b/apps/desktop/src/lib/trpc/routers/ui-state/index.ts @@ -19,7 +19,7 @@ const fileViewerStateSchema = z.object({ isLocked: z.boolean(), diffLayout: z.enum(["inline", "side-by-side"]), diffCategory: z - .enum(["against-main", "committed", "staged", "unstaged"]) + .enum(["against-base", "committed", "staged", "unstaged"]) .optional(), commitHash: z.string().optional(), oldPath: z.string().optional(), diff --git a/apps/desktop/src/renderer/hooks/useWorkspaceShortcuts.ts b/apps/desktop/src/renderer/hooks/useWorkspaceShortcuts.ts index cd222045883..a37a8684377 100644 --- a/apps/desktop/src/renderer/hooks/useWorkspaceShortcuts.ts +++ b/apps/desktop/src/renderer/hooks/useWorkspaceShortcuts.ts @@ -5,7 +5,7 @@ import { useCreateBranchWorkspace, useSetActiveWorkspace, } from "renderer/react-query/workspaces"; -import { HOTKEYS } from "shared/hotkeys"; +import { getHotkey } from "shared/hotkeys"; /** * Shared hook for workspace keyboard shortcuts and auto-creation logic. @@ -105,8 +105,8 @@ export function useWorkspaceShortcuts() { }, [activeWorkspaceId, allWorkspaces, setActiveWorkspace]); useHotkeys(workspaceKeys, handleWorkspaceSwitch); - useHotkeys(HOTKEYS.PREV_WORKSPACE.keys, handlePrevWorkspace); - useHotkeys(HOTKEYS.NEXT_WORKSPACE.keys, handleNextWorkspace); + useHotkeys(getHotkey("PREV_WORKSPACE"), handlePrevWorkspace); + useHotkeys(getHotkey("NEXT_WORKSPACE"), handleNextWorkspace); return { groups, diff --git a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceSidebarControl.tsx b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceSidebarControl.tsx index 9f73f0e465b..a5a517901f6 100644 --- a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceSidebarControl.tsx +++ b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceSidebarControl.tsx @@ -3,7 +3,11 @@ import { Kbd, KbdGroup } from "@superset/ui/kbd"; import { Tooltip, TooltipContent, TooltipTrigger } from "@superset/ui/tooltip"; import { LuPanelLeft, LuPanelLeftClose } from "react-icons/lu"; import { useWorkspaceSidebarStore } from "renderer/stores"; -import { HOTKEYS } from "shared/hotkeys"; +import { + formatHotkeyDisplay, + getCurrentPlatform, + getHotkey, +} from "shared/hotkeys"; export function WorkspaceSidebarControl() { const { isOpen, toggleOpen } = useWorkspaceSidebarStore(); @@ -29,7 +33,10 @@ export function WorkspaceSidebarControl() { Toggle Workspaces - {HOTKEYS.TOGGLE_WORKSPACE_SIDEBAR.display.map((key) => ( + {formatHotkeyDisplay( + getHotkey("TOGGLE_WORKSPACE_SIDEBAR"), + getCurrentPlatform(), + ).map((key) => ( {key} ))} diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx index 4a842517364..e8a975f2ee4 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx @@ -137,10 +137,10 @@ export function FileViewerPane({ const commitHash = fileViewer?.commitHash; const oldPath = fileViewer?.oldPath; - // Fetch branch info for against-main diffs (P1-1) + // Fetch branch info for against-base diffs (P1-1) const { data: branchData } = trpc.changes.getBranches.useQuery( { worktreePath }, - { enabled: !!worktreePath && diffCategory === "against-main" }, + { enabled: !!worktreePath && diffCategory === "against-base" }, ); const effectiveBaseBranch = branchData?.defaultBranch ?? "main"; @@ -274,9 +274,9 @@ export function FileViewerPane({ oldPath, category: diffCategory ?? "unstaged", commitHash, - // P1-1: Pass defaultBranch for against-main diffs + // P1-1: Pass defaultBranch for against-base diffs defaultBranch: - diffCategory === "against-main" ? effectiveBaseBranch : undefined, + diffCategory === "against-base" ? effectiveBaseBranch : undefined, }, { enabled: diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/index.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/index.tsx index b8f8f07bbf2..38c3045058f 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/index.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/index.tsx @@ -4,7 +4,7 @@ import { trpc } from "renderer/lib/trpc"; import { useTabsStore } from "renderer/stores/tabs/store"; import { getNextPaneId, getPreviousPaneId } from "renderer/stores/tabs/utils"; import { useWorkspaceViewModeStore } from "renderer/stores/workspace-view-mode"; -import { HOTKEYS } from "shared/hotkeys"; +import { getHotkey } from "shared/hotkeys"; import { ContentView } from "./ContentView"; import { ResizableSidebar } from "./ResizableSidebar"; @@ -52,7 +52,7 @@ export function WorkspaceView() { : "workbench"; // Tab management shortcuts - useHotkeys(HOTKEYS.NEW_TERMINAL.keys, () => { + useHotkeys(getHotkey("NEW_TERMINAL"), () => { if (activeWorkspaceId) { // If in Review mode, switch to Workbench first if (viewMode === "review") { @@ -62,7 +62,7 @@ export function WorkspaceView() { } }, [activeWorkspaceId, addTab, viewMode, setWorkspaceViewMode]); - useHotkeys(HOTKEYS.CLOSE_TERMINAL.keys, () => { + useHotkeys(getHotkey("CLOSE_TERMINAL"), () => { // Close focused pane (which may close the tab if it's the last pane) if (focusedPaneId) { removePane(focusedPaneId); @@ -70,7 +70,7 @@ export function WorkspaceView() { }, [focusedPaneId, removePane]); // Switch between tabs (⌘+Up/Down) - useHotkeys(HOTKEYS.PREV_TERMINAL.keys, () => { + useHotkeys(getHotkey("PREV_TERMINAL"), () => { if (!activeWorkspaceId || !activeTabId) return; const index = tabs.findIndex((t) => t.id === activeTabId); if (index > 0) { @@ -78,7 +78,7 @@ export function WorkspaceView() { } }, [activeWorkspaceId, activeTabId, tabs, setActiveTab]); - useHotkeys(HOTKEYS.NEXT_TERMINAL.keys, () => { + useHotkeys(getHotkey("NEXT_TERMINAL"), () => { if (!activeWorkspaceId || !activeTabId) return; const index = tabs.findIndex((t) => t.id === activeTabId); if (index < tabs.length - 1) { @@ -87,7 +87,7 @@ export function WorkspaceView() { }, [activeWorkspaceId, activeTabId, tabs, setActiveTab]); // Switch between panes within a tab (⌘+⌥+Left/Right) - useHotkeys(HOTKEYS.PREV_PANE.keys, () => { + useHotkeys(getHotkey("PREV_PANE"), () => { if (!activeTabId || !activeTab?.layout || !focusedPaneId) return; const prevPaneId = getPreviousPaneId(activeTab.layout, focusedPaneId); if (prevPaneId) { @@ -95,7 +95,7 @@ export function WorkspaceView() { } }, [activeTabId, activeTab?.layout, focusedPaneId, setFocusedPane]); - useHotkeys(HOTKEYS.NEXT_PANE.keys, () => { + useHotkeys(getHotkey("NEXT_PANE"), () => { if (!activeTabId || !activeTab?.layout || !focusedPaneId) return; const nextPaneId = getNextPaneId(activeTab.layout, focusedPaneId); if (nextPaneId) { diff --git a/apps/desktop/src/renderer/screens/main/index.tsx b/apps/desktop/src/renderer/screens/main/index.tsx index 620b56b7463..89a05a15854 100644 --- a/apps/desktop/src/renderer/screens/main/index.tsx +++ b/apps/desktop/src/renderer/screens/main/index.tsx @@ -22,7 +22,7 @@ import { useAgentHookListener } from "renderer/stores/tabs/useAgentHookListener" import { findPanePath, getFirstPaneId } from "renderer/stores/tabs/utils"; import { useWorkspaceSidebarStore } from "renderer/stores/workspace-sidebar-state"; import { DEFAULT_NAVIGATION_STYLE } from "shared/constants"; -import { HOTKEYS } from "shared/hotkeys"; +import { getHotkey, HOTKEYS } from "shared/hotkeys"; import { dragDropManager } from "../../lib/dnd"; import { AppFrame } from "./components/AppFrame"; import { Background } from "./components/Background"; @@ -122,7 +122,7 @@ export function MainScreen() { [toggleSidebar, isWorkspaceView], ); - useHotkeys(HOTKEYS.TOGGLE_WORKSPACE_SIDEBAR.keys, () => { + useHotkeys(getHotkey("TOGGLE_WORKSPACE_SIDEBAR"), () => { if (isSidebarMode) toggleWorkspaceSidebar(); }, [toggleWorkspaceSidebar, isSidebarMode]); diff --git a/apps/desktop/src/shared/hotkeys.ts b/apps/desktop/src/shared/hotkeys.ts index b650d06d791..1a1e78bd24b 100644 --- a/apps/desktop/src/shared/hotkeys.ts +++ b/apps/desktop/src/shared/hotkeys.ts @@ -426,7 +426,7 @@ export const HOTKEYS = { label: "Toggle Files Sidebar", category: "Layout", }), - TOGGLE_WORKSPACE_SIDEBAR: hotkey({ + TOGGLE_WORKSPACE_SIDEBAR: defineHotkey({ keys: "meta+shift+b", label: "Toggle Workspaces Sidebar", category: "Layout", @@ -580,6 +580,15 @@ export function getDefaultHotkey( return HOTKEYS[id].defaults[platform]; } +/** + * Get the hotkey binding for the current platform. + * Convenience wrapper around getDefaultHotkey. + * Returns empty string if no hotkey is defined (safe for useHotkeys). + */ +export function getHotkey(id: HotkeyId): string { + return getDefaultHotkey(id, getCurrentPlatform()) ?? ""; +} + export function getEffectiveHotkey( id: HotkeyId, overrides: Partial>, From 45f474144373a7b3484a492e31521eaf1d53ea9b Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Fri, 2 Jan 2026 11:36:37 +0200 Subject: [PATCH 30/98] style(desktop): use border instead of bg for active tab in GroupStrip Replace intense bg-tertiary-active background with subtle border-b-2 border-border for active tab state - cleaner visual that's less heavy --- .../ContentView/TabsContent/GroupStrip/GroupStrip.tsx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx index e6f271b53a4..f68bce5c1ac 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx @@ -35,7 +35,7 @@ function GroupItem({ className={cn( "flex items-center gap-1.5 rounded-t-md transition-all w-full shrink-0 pl-3 pr-6 h-[80%]", isActive - ? "text-foreground bg-tertiary-active" + ? "text-foreground border-b-2 border-border" : "text-muted-foreground hover:text-foreground hover:bg-tertiary/30", )} > @@ -132,7 +132,7 @@ export function GroupStrip() { }; return ( -
+
{tabs.length > 0 && (
{tabs.map((tab) => ( From 9d168c9ad850999b8139b032e4df0c7ff2bebe33 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Fri, 2 Jan 2026 11:37:08 +0200 Subject: [PATCH 31/98] style(desktop): use top/side borders for active tab in GroupStrip Change from bottom border to top/left/right borders for a traditional tab appearance that connects to content below --- .../ContentView/TabsContent/GroupStrip/GroupStrip.tsx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx index f68bce5c1ac..77790ae7b88 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx @@ -35,7 +35,7 @@ function GroupItem({ className={cn( "flex items-center gap-1.5 rounded-t-md transition-all w-full shrink-0 pl-3 pr-6 h-[80%]", isActive - ? "text-foreground border-b-2 border-border" + ? "text-foreground border-t border-l border-r border-border" : "text-muted-foreground hover:text-foreground hover:bg-tertiary/30", )} > From 96fa30937db3cea51eb64e0dac714f3170f44f80 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Fri, 2 Jan 2026 11:56:08 +0200 Subject: [PATCH 32/98] fix(desktop): update sidebar toggle tooltip to 'Toggle Changes Sidebar' --- .../screens/main/components/SidebarControl/SidebarControl.tsx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/apps/desktop/src/renderer/screens/main/components/SidebarControl/SidebarControl.tsx b/apps/desktop/src/renderer/screens/main/components/SidebarControl/SidebarControl.tsx index 6fa45f91846..275d0e03424 100644 --- a/apps/desktop/src/renderer/screens/main/components/SidebarControl/SidebarControl.tsx +++ b/apps/desktop/src/renderer/screens/main/components/SidebarControl/SidebarControl.tsx @@ -14,7 +14,7 @@ export function SidebarControl() { variant="ghost" size="icon" onClick={toggleSidebar} - aria-label="Toggle sidebar" + aria-label="Toggle Changes Sidebar" className="no-drag" > {isSidebarOpen ? ( @@ -26,7 +26,7 @@ export function SidebarControl() { From ed7a9d08e82c71db8761a64069cc20b5bd9b93b0 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Fri, 2 Jan 2026 11:56:57 +0200 Subject: [PATCH 33/98] feat(desktop): add sidebar toggle to TabsContent in sidebar navigation mode Show SidebarControl in GroupStrip header and EmptyTabView when using sidebar navigation style, allowing users to toggle the changes sidebar --- .../ContentView/TabsContent/EmptyTabView.tsx | 47 ++++++++++++------- .../ContentView/TabsContent/index.tsx | 16 ++++++- 2 files changed, 46 insertions(+), 17 deletions(-) diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/EmptyTabView.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/EmptyTabView.tsx index 0f9a435a873..53d29745fe4 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/EmptyTabView.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/EmptyTabView.tsx @@ -1,35 +1,50 @@ import { Kbd, KbdGroup } from "@superset/ui/kbd"; import { HiMiniCommandLine } from "react-icons/hi2"; +import { trpc } from "renderer/lib/trpc"; import { useHotkeyDisplay } from "renderer/stores/hotkeys"; +import { DEFAULT_NAVIGATION_STYLE } from "shared/constants"; +import { SidebarControl } from "../../../SidebarControl"; export function EmptyTabView() { const newTerminalDisplay = useHotkeyDisplay("NEW_TERMINAL"); const openInAppDisplay = useHotkeyDisplay("OPEN_IN_APP"); + // Get navigation style to conditionally show sidebar toggle + const { data: navigationStyle } = trpc.settings.getNavigationStyle.useQuery(); + const isSidebarMode = + (navigationStyle ?? DEFAULT_NAVIGATION_STYLE) === "sidebar"; + const shortcuts = [ { label: "New Terminal", display: newTerminalDisplay }, { label: "Open in App", display: openInAppDisplay }, ]; return ( -
-
- -
+
+ {isSidebarMode && ( +
+ +
+ )} +
+
+ +
-

No terminal open

+

No terminal open

-
- {shortcuts.map((shortcut) => ( -
- - {shortcut.display.map((key) => ( - {key} - ))} - - {shortcut.label} -
- ))} +
+ {shortcuts.map((shortcut) => ( +
+ + {shortcut.display.map((key) => ( + {key} + ))} + + {shortcut.label} +
+ ))} +
); diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/index.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/index.tsx index 8dc969d541a..36d2a427b9a 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/index.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/index.tsx @@ -1,6 +1,8 @@ import { useMemo } from "react"; import { trpc } from "renderer/lib/trpc"; import { useTabsStore } from "renderer/stores/tabs/store"; +import { DEFAULT_NAVIGATION_STYLE } from "shared/constants"; +import { SidebarControl } from "../../../SidebarControl"; import { EmptyTabView } from "./EmptyTabView"; import { GroupStrip } from "./GroupStrip"; import { TabView } from "./TabView"; @@ -12,6 +14,11 @@ export function TabsContent() { const panes = useTabsStore((s) => s.panes); const activeTabIds = useTabsStore((s) => s.activeTabIds); + // Get navigation style to conditionally show sidebar toggle + const { data: navigationStyle } = trpc.settings.getNavigationStyle.useQuery(); + const isSidebarMode = + (navigationStyle ?? DEFAULT_NAVIGATION_STYLE) === "sidebar"; + const tabToRender = useMemo(() => { if (!activeWorkspaceId) return null; const activeTabId = activeTabIds[activeWorkspaceId]; @@ -26,7 +33,14 @@ export function TabsContent() { return (
- +
+ {isSidebarMode && ( +
+ +
+ )} + +
From 166be332a716ae404f979b2beb2b043bbd86419e Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Fri, 2 Jan 2026 14:18:10 +0200 Subject: [PATCH 34/98] fix(desktop): lift SidebarControl to ContentView to fix review mode regression The sidebar toggle was missing when switching to Review mode because it was rendered inside TabsContent, which doesn't render in review mode. Changes: - Create ContentHeader component at ContentView level with leadingAction slot - ContentView now owns SidebarControl placement for both workbench and review modes - Remove SidebarControl from TabsContent and EmptyTabView (now handled by parent) - Remove unused BranchIndicator component and HOTKEYS import (cleanup) --- .../WorkspaceControls/BranchIndicator.tsx | 29 ------------ .../WorkspaceControls/WorkspaceControls.tsx | 4 -- .../screens/main/components/TopBar/index.tsx | 1 - .../ContentHeader/ContentHeader.tsx | 19 ++++++++ .../ContentView/ContentHeader/index.ts | 1 + .../ContentView/TabsContent/EmptyTabView.tsx | 47 +++++++------------ .../ContentView/TabsContent/index.tsx | 22 +-------- .../WorkspaceView/ContentView/index.tsx | 34 ++++++++++++-- .../src/renderer/screens/main/index.tsx | 2 +- 9 files changed, 69 insertions(+), 90 deletions(-) delete mode 100644 apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceControls/BranchIndicator.tsx create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/ContentHeader/ContentHeader.tsx create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/ContentHeader/index.ts diff --git a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceControls/BranchIndicator.tsx b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceControls/BranchIndicator.tsx deleted file mode 100644 index 3146293114f..00000000000 --- a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceControls/BranchIndicator.tsx +++ /dev/null @@ -1,29 +0,0 @@ -import { Tooltip, TooltipContent, TooltipTrigger } from "@superset/ui/tooltip"; -import { GoGitBranch } from "react-icons/go"; - -interface BranchIndicatorProps { - branch: string | undefined; -} - -export function BranchIndicator({ branch }: BranchIndicatorProps) { - if (!branch) return null; - - return ( - - - - - - Current branch - - - ); -} diff --git a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceControls/WorkspaceControls.tsx b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceControls/WorkspaceControls.tsx index 2c09ecd95c7..e590051951c 100644 --- a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceControls/WorkspaceControls.tsx +++ b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceControls/WorkspaceControls.tsx @@ -1,24 +1,20 @@ -import { BranchIndicator } from "./BranchIndicator"; import { OpenInMenuButton } from "./OpenInMenuButton"; import { ViewModeToggleCompact } from "./ViewModeToggleCompact"; interface WorkspaceControlsProps { workspaceId: string | undefined; worktreePath: string | undefined; - branch: string | undefined; } export function WorkspaceControls({ workspaceId, worktreePath, - branch, }: WorkspaceControlsProps) { // Don't render if no active workspace with a worktree path if (!workspaceId || !worktreePath) return null; return (
-
diff --git a/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx b/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx index f537b4793ff..a3ea4f4167a 100644 --- a/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx +++ b/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx @@ -50,7 +50,6 @@ export function TopBar({ navigationStyle = "top-bar" }: TopBarProps) { {!isMac && } diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/ContentHeader/ContentHeader.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/ContentHeader/ContentHeader.tsx new file mode 100644 index 00000000000..6839ca39b04 --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/ContentHeader/ContentHeader.tsx @@ -0,0 +1,19 @@ +import type { ReactNode } from "react"; + +interface ContentHeaderProps { + /** Optional leading action (e.g., SidebarControl) */ + leadingAction?: ReactNode; + /** Mode-specific header content (e.g., GroupStrip or file info) */ + children: ReactNode; +} + +export function ContentHeader({ leadingAction, children }: ContentHeaderProps) { + return ( +
+ {leadingAction && ( +
{leadingAction}
+ )} + {children} +
+ ); +} diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/ContentHeader/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/ContentHeader/index.ts new file mode 100644 index 00000000000..26fb6ccbc3e --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/ContentHeader/index.ts @@ -0,0 +1 @@ +export { ContentHeader } from "./ContentHeader"; diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/EmptyTabView.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/EmptyTabView.tsx index 53d29745fe4..7be04c0c208 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/EmptyTabView.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/EmptyTabView.tsx @@ -1,50 +1,35 @@ import { Kbd, KbdGroup } from "@superset/ui/kbd"; import { HiMiniCommandLine } from "react-icons/hi2"; -import { trpc } from "renderer/lib/trpc"; import { useHotkeyDisplay } from "renderer/stores/hotkeys"; -import { DEFAULT_NAVIGATION_STYLE } from "shared/constants"; -import { SidebarControl } from "../../../SidebarControl"; export function EmptyTabView() { const newTerminalDisplay = useHotkeyDisplay("NEW_TERMINAL"); const openInAppDisplay = useHotkeyDisplay("OPEN_IN_APP"); - // Get navigation style to conditionally show sidebar toggle - const { data: navigationStyle } = trpc.settings.getNavigationStyle.useQuery(); - const isSidebarMode = - (navigationStyle ?? DEFAULT_NAVIGATION_STYLE) === "sidebar"; - const shortcuts = [ { label: "New Terminal", display: newTerminalDisplay }, { label: "Open in App", display: openInAppDisplay }, ]; return ( -
- {isSidebarMode && ( -
- -
- )} -
-
- -
+
+
+ +
-

No terminal open

+

No terminal open

-
- {shortcuts.map((shortcut) => ( -
- - {shortcut.display.map((key) => ( - {key} - ))} - - {shortcut.label} -
- ))} -
+
+ {shortcuts.map((shortcut) => ( +
+ + {shortcut.display.map((key) => ( + {key} + ))} + + {shortcut.label} +
+ ))}
); diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/index.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/index.tsx index 36d2a427b9a..fb3908f55f4 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/index.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/index.tsx @@ -1,10 +1,7 @@ import { useMemo } from "react"; import { trpc } from "renderer/lib/trpc"; import { useTabsStore } from "renderer/stores/tabs/store"; -import { DEFAULT_NAVIGATION_STYLE } from "shared/constants"; -import { SidebarControl } from "../../../SidebarControl"; import { EmptyTabView } from "./EmptyTabView"; -import { GroupStrip } from "./GroupStrip"; import { TabView } from "./TabView"; export function TabsContent() { @@ -14,11 +11,6 @@ export function TabsContent() { const panes = useTabsStore((s) => s.panes); const activeTabIds = useTabsStore((s) => s.activeTabIds); - // Get navigation style to conditionally show sidebar toggle - const { data: navigationStyle } = trpc.settings.getNavigationStyle.useQuery(); - const isSidebarMode = - (navigationStyle ?? DEFAULT_NAVIGATION_STYLE) === "sidebar"; - const tabToRender = useMemo(() => { if (!activeWorkspaceId) return null; const activeTabId = activeTabIds[activeWorkspaceId]; @@ -32,18 +24,8 @@ export function TabsContent() { } return ( -
-
- {isSidebarMode && ( -
- -
- )} - -
-
- -
+
+
); } diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/index.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/index.tsx index 835e914fc05..d3f4675c0e0 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/index.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/index.tsx @@ -1,7 +1,11 @@ import { trpc } from "renderer/lib/trpc"; import { useWorkspaceViewModeStore } from "renderer/stores/workspace-view-mode"; +import { DEFAULT_NAVIGATION_STYLE } from "shared/constants"; +import { SidebarControl } from "../../SidebarControl"; import { ChangesContent } from "./ChangesContent"; +import { ContentHeader } from "./ContentHeader"; import { TabsContent } from "./TabsContent"; +import { GroupStrip } from "./TabsContent/GroupStrip"; export function ContentView() { const { data: activeWorkspace } = trpc.workspaces.getActive.useQuery(); @@ -16,15 +20,37 @@ export function ContentView() { ? (viewModeByWorkspaceId[workspaceId] ?? "workbench") : "workbench"; + // Get navigation style to conditionally show sidebar toggle + const { data: navigationStyle } = trpc.settings.getNavigationStyle.useQuery(); + const isSidebarMode = + (navigationStyle ?? DEFAULT_NAVIGATION_STYLE) === "sidebar"; + if (viewMode === "review") { return ( -
-
- +
+ {isSidebarMode && ( + }> + {/* Review mode has no additional header content - FileHeader is inside ChangesContent */} +
+ + )} +
+
+ +
); } - return ; + return ( +
+ : undefined} + > + + + +
+ ); } diff --git a/apps/desktop/src/renderer/screens/main/index.tsx b/apps/desktop/src/renderer/screens/main/index.tsx index 89a05a15854..580f08bbf7f 100644 --- a/apps/desktop/src/renderer/screens/main/index.tsx +++ b/apps/desktop/src/renderer/screens/main/index.tsx @@ -22,7 +22,7 @@ import { useAgentHookListener } from "renderer/stores/tabs/useAgentHookListener" import { findPanePath, getFirstPaneId } from "renderer/stores/tabs/utils"; import { useWorkspaceSidebarStore } from "renderer/stores/workspace-sidebar-state"; import { DEFAULT_NAVIGATION_STYLE } from "shared/constants"; -import { getHotkey, HOTKEYS } from "shared/hotkeys"; +import { getHotkey } from "shared/hotkeys"; import { dragDropManager } from "../../lib/dnd"; import { AppFrame } from "./components/AppFrame"; import { Background } from "./components/Background"; From 936dd58cc75cdce7e20be67767ec237450b05404 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Fri, 2 Jan 2026 14:35:05 +0200 Subject: [PATCH 35/98] refactor(desktop): rename NEW_TERMINAL hotkey to NEW_GROUP for clarity CMD+T creates a new Group (tab container), not a terminal pane. This aligns the hotkey naming with the existing 'New Group' button tooltip. --- .../WorkspaceView/ContentView/TabsContent/EmptyTabView.tsx | 4 ++-- .../renderer/screens/main/components/WorkspaceView/index.tsx | 2 +- apps/desktop/src/shared/hotkeys.ts | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/EmptyTabView.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/EmptyTabView.tsx index 7be04c0c208..daaff3366fd 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/EmptyTabView.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/EmptyTabView.tsx @@ -3,11 +3,11 @@ import { HiMiniCommandLine } from "react-icons/hi2"; import { useHotkeyDisplay } from "renderer/stores/hotkeys"; export function EmptyTabView() { - const newTerminalDisplay = useHotkeyDisplay("NEW_TERMINAL"); + const newGroupDisplay = useHotkeyDisplay("NEW_GROUP"); const openInAppDisplay = useHotkeyDisplay("OPEN_IN_APP"); const shortcuts = [ - { label: "New Terminal", display: newTerminalDisplay }, + { label: "New Group", display: newGroupDisplay }, { label: "Open in App", display: openInAppDisplay }, ]; diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/index.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/index.tsx index 38c3045058f..84f22532079 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/index.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/index.tsx @@ -52,7 +52,7 @@ export function WorkspaceView() { : "workbench"; // Tab management shortcuts - useHotkeys(getHotkey("NEW_TERMINAL"), () => { + useHotkeys(getHotkey("NEW_GROUP"), () => { if (activeWorkspaceId) { // If in Review mode, switch to Workbench first if (viewMode === "review") { diff --git a/apps/desktop/src/shared/hotkeys.ts b/apps/desktop/src/shared/hotkeys.ts index 1a1e78bd24b..2a2b4620789 100644 --- a/apps/desktop/src/shared/hotkeys.ts +++ b/apps/desktop/src/shared/hotkeys.ts @@ -457,9 +457,9 @@ export const HOTKEYS = { category: "Terminal", description: "Search text in the active terminal", }), - NEW_TERMINAL: defineHotkey({ + NEW_GROUP: defineHotkey({ keys: "meta+t", - label: "New Terminal", + label: "New Group", category: "Terminal", }), CLOSE_TERMINAL: defineHotkey({ From 6ced48d4d7826eca26ddb267c6e0c881098ceb45 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Sat, 3 Jan 2026 09:36:52 +0200 Subject: [PATCH 36/98] feat(desktop): move workspace controls to content header in sidebar mode In sidebar navigation mode, move the 'Open In' button and 'Workbench/Review' toggle from TopBar down to ContentHeader alongside the group tabs. This keeps the profile dropdown in TopBar while placing workspace controls closer to the content they affect. Changes: - ContentHeader: Add trailingAction prop for right-side controls - ContentView: Pass WorkspaceControls as trailingAction when isSidebarMode - TopBar: Only render WorkspaceControls when not in sidebar mode The controls are visible in both Workbench (with group tabs) and Review (without group tabs) modes. Top-bar navigation mode is unchanged. --- .../screens/main/components/TopBar/index.tsx | 10 ++++++---- .../ContentView/ContentHeader/ContentHeader.tsx | 13 +++++++++++-- .../WorkspaceView/ContentView/index.tsx | 17 +++++++++++++++-- 3 files changed, 32 insertions(+), 8 deletions(-) diff --git a/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx b/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx index a3ea4f4167a..f9f163791dc 100644 --- a/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx +++ b/apps/desktop/src/renderer/screens/main/components/TopBar/index.tsx @@ -47,10 +47,12 @@ export function TopBar({ navigationStyle = "top-bar" }: TopBarProps) { )}
- + {!isSidebarMode && ( + + )} {!isMac && }
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/ContentHeader/ContentHeader.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/ContentHeader/ContentHeader.tsx index 6839ca39b04..85abdc17a8d 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/ContentHeader/ContentHeader.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/ContentHeader/ContentHeader.tsx @@ -5,15 +5,24 @@ interface ContentHeaderProps { leadingAction?: ReactNode; /** Mode-specific header content (e.g., GroupStrip or file info) */ children: ReactNode; + /** Optional trailing action (e.g., WorkspaceControls) */ + trailingAction?: ReactNode; } -export function ContentHeader({ leadingAction, children }: ContentHeaderProps) { +export function ContentHeader({ + leadingAction, + children, + trailingAction, +}: ContentHeaderProps) { return (
{leadingAction && (
{leadingAction}
)} - {children} +
{children}
+ {trailingAction && ( +
{trailingAction}
+ )}
); } diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/index.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/index.tsx index d3f4675c0e0..01d80ffa175 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/index.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/index.tsx @@ -2,6 +2,7 @@ import { trpc } from "renderer/lib/trpc"; import { useWorkspaceViewModeStore } from "renderer/stores/workspace-view-mode"; import { DEFAULT_NAVIGATION_STYLE } from "shared/constants"; import { SidebarControl } from "../../SidebarControl"; +import { WorkspaceControls } from "../../TopBar/WorkspaceControls"; import { ChangesContent } from "./ChangesContent"; import { ContentHeader } from "./ContentHeader"; import { TabsContent } from "./TabsContent"; @@ -25,12 +26,23 @@ export function ContentView() { const isSidebarMode = (navigationStyle ?? DEFAULT_NAVIGATION_STYLE) === "sidebar"; + // Render WorkspaceControls in ContentHeader when in sidebar mode + const workspaceControls = isSidebarMode ? ( + + ) : undefined; + if (viewMode === "review") { return (
{isSidebarMode && ( - }> - {/* Review mode has no additional header content - FileHeader is inside ChangesContent */} + } + trailingAction={workspaceControls} + > + {/* Review mode has no group tabs */}
)} @@ -47,6 +59,7 @@ export function ContentView() {
: undefined} + trailingAction={workspaceControls} > From 1f988d811629981947e0be407b8e8f2744ebb3cd Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Sat, 3 Jan 2026 16:41:08 +0200 Subject: [PATCH 37/98] fix(desktop): harden file viewer security and improve terminal link handling Security fixes (code review feedback): - P0-1: Fix ENOENT handling in secure-fs to detect dangling symlinks and validate parent directory chains for write operations - P0-2: Add centralized symlink-escape enforcement to secureFs.readFile and readFileBuffer - reads now blocked if symlink escapes worktree - Add 'symlink-escape' error reason to distinguish from other validation errors - Use path.relative() for safer boundary checks instead of string prefix matching - P1: Handle undefined workspaceCwd gracefully in Terminal file-viewer mode by falling back to external editor when workspace is still initializing - P2: Update FileViewerState schema comment to clarify intentional omission of transient fields (initialLine/initialColumn) - P2: Document unique branch-workspace index limitation in schema.ts Feature completion: - Terminal file links now pass line/column to File Viewer for initial scroll - FileViewerPane applies initial line/column navigation in raw mode - Add initialLine/initialColumn to FileViewerState and store types --- .../lib/trpc/routers/changes/file-contents.ts | 11 +- .../routers/changes/security/secure-fs.ts | 178 +++++++++++++++++- .../src/lib/trpc/routers/ui-state/index.ts | 4 +- .../TabView/FileViewerPane/FileViewerPane.tsx | 42 ++++- .../TabsContent/Terminal/Terminal.tsx | 61 +++--- .../desktop/src/renderer/stores/tabs/store.ts | 2 + .../desktop/src/renderer/stores/tabs/types.ts | 4 + .../desktop/src/renderer/stores/tabs/utils.ts | 6 + apps/desktop/src/shared/tabs-types.ts | 4 + packages/local-db/src/schema/schema.ts | 6 + 10 files changed, 284 insertions(+), 34 deletions(-) diff --git a/apps/desktop/src/lib/trpc/routers/changes/file-contents.ts b/apps/desktop/src/lib/trpc/routers/changes/file-contents.ts index dc4aba8f4e5..4b2ae5aca2c 100644 --- a/apps/desktop/src/lib/trpc/routers/changes/file-contents.ts +++ b/apps/desktop/src/lib/trpc/routers/changes/file-contents.ts @@ -22,7 +22,12 @@ type ReadWorkingFileResult = | { ok: true; content: string; truncated: boolean; byteLength: number } | { ok: false; - reason: "not-found" | "too-large" | "binary" | "outside-worktree"; + reason: + | "not-found" + | "too-large" + | "binary" + | "outside-worktree" + | "symlink-escape"; }; /** @@ -131,6 +136,10 @@ export const createFileContentsRouter = () => { }; } catch (error) { if (error instanceof PathValidationError) { + // Map specific error codes to distinct reasons + if (error.code === "SYMLINK_ESCAPE") { + return { ok: false, reason: "symlink-escape" }; + } return { ok: false, reason: "outside-worktree" }; } // File not found or other read error diff --git a/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts b/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts index 5c47f6e7c35..4f68e28932e 100644 --- a/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts +++ b/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts @@ -2,11 +2,13 @@ import type { Stats } from "node:fs"; import { lstat, readFile, + readlink, realpath, rm, stat, writeFile, } from "node:fs/promises"; +import { dirname, isAbsolute, relative, resolve } from "node:path"; import { assertRegisteredWorktree, PathValidationError, @@ -25,6 +27,137 @@ import { * See path-validation.ts for the full security model and threat assumptions. */ +/** + * Check if a resolved path is within the worktree boundary using path.relative(). + * This is safer than string prefix matching which can have boundary bugs. + */ +function isPathWithinWorktree( + worktreeReal: string, + targetReal: string, +): boolean { + if (targetReal === worktreeReal) { + return true; + } + const relativePath = relative(worktreeReal, targetReal); + // If relative path starts with ".." or is absolute, it's outside + return ( + !relativePath.startsWith("..") && + !isAbsolute(relativePath) && + relativePath !== "" + ); +} + +/** + * Validate that the parent directory chain stays within the worktree. + * Handles the case where the target file doesn't exist yet (ENOENT). + * + * This function walks up the directory tree to find the first existing + * ancestor and validates it. It also detects dangling symlinks by checking + * if any component is a symlink pointing outside the worktree. + * + * @throws PathValidationError if any ancestor escapes the worktree + */ +async function assertParentInWorktree( + worktreePath: string, + fullPath: string, +): Promise { + const worktreeReal = await realpath(worktreePath); + let currentPath = dirname(fullPath); + + // Walk up the directory tree until we find an existing directory + while (currentPath !== dirname(currentPath)) { + // Stop at filesystem root + try { + // First check if this path component is a symlink (even if target doesn't exist) + const stats = await lstat(currentPath); + + if (stats.isSymbolicLink()) { + // This is a symlink - validate its target even if it doesn't exist + const linkTarget = await readlink(currentPath); + // Resolve the link target relative to the symlink's parent + const resolvedTarget = isAbsolute(linkTarget) + ? linkTarget + : resolve(dirname(currentPath), linkTarget); + + // Try to get the realpath of the resolved target + try { + const targetReal = await realpath(resolvedTarget); + if (!isPathWithinWorktree(worktreeReal, targetReal)) { + throw new PathValidationError( + "Symlink in path resolves outside the worktree", + "SYMLINK_ESCAPE", + ); + } + } catch (error) { + // Target doesn't exist - check if the resolved target path + // would be within worktree if it existed + if ( + error instanceof Error && + "code" in error && + error.code === "ENOENT" + ) { + // For dangling symlinks, validate the target path itself + // We need to check if the target, when resolved, would be in worktree + // This is conservative: if we can't determine, fail closed + const targetRelative = relative(worktreeReal, resolvedTarget); + if (targetRelative.startsWith("..") || isAbsolute(targetRelative)) { + throw new PathValidationError( + "Dangling symlink points outside the worktree", + "SYMLINK_ESCAPE", + ); + } + // Target would be within worktree if it existed - continue + return; + } + if (error instanceof PathValidationError) { + throw error; + } + // Other errors - fail closed for security + throw new PathValidationError( + "Cannot validate symlink target", + "SYMLINK_ESCAPE", + ); + } + return; // Symlink validated successfully + } + + // Not a symlink - get realpath and validate + const parentReal = await realpath(currentPath); + if (!isPathWithinWorktree(worktreeReal, parentReal)) { + throw new PathValidationError( + "Parent directory resolves outside the worktree", + "SYMLINK_ESCAPE", + ); + } + return; // Found valid ancestor + } catch (error) { + if (error instanceof PathValidationError) { + throw error; + } + if ( + error instanceof Error && + "code" in error && + error.code === "ENOENT" + ) { + // This ancestor doesn't exist either, keep walking up + currentPath = dirname(currentPath); + continue; + } + // Other errors (EACCES, ENOTDIR, etc.) - fail closed for security + throw new PathValidationError( + "Cannot validate path ancestry", + "SYMLINK_ESCAPE", + ); + } + } + + // Reached filesystem root without finding valid ancestor + throw new PathValidationError( + "Could not validate path ancestry within worktree", + "SYMLINK_ESCAPE", + ); +} + /** * Check if the resolved realpath stays within the worktree boundary. * Prevents symlink escape attacks where a symlink points outside the worktree. @@ -39,29 +172,39 @@ async function assertRealpathInWorktree( const real = await realpath(fullPath); const worktreeReal = await realpath(worktreePath); - // Ensure realpath is within worktree (with proper boundary check) - if (!real.startsWith(`${worktreeReal}/`) && real !== worktreeReal) { + // Use path.relative for safer boundary checking + if (!isPathWithinWorktree(worktreeReal, real)) { throw new PathValidationError( "File is a symlink pointing outside the worktree", "SYMLINK_ESCAPE", ); } } catch (error) { - // If realpath fails with ENOENT, file doesn't exist yet - that's OK for writes + // If realpath fails with ENOENT, file doesn't exist yet + // Validate the parent directory chain instead if (error instanceof Error && "code" in error && error.code === "ENOENT") { + await assertParentInWorktree(worktreePath, fullPath); return; } // Re-throw PathValidationError if (error instanceof PathValidationError) { throw error; } - // Other errors (permission denied, etc.) - let them propagate - throw error; + // Other errors (permission denied, etc.) - fail closed for security + throw new PathValidationError( + "Cannot validate file path", + "SYMLINK_ESCAPE", + ); } } export const secureFs = { /** * Read a file within a worktree. + * + * SECURITY: Enforces symlink-escape check. If the file is a symlink + * pointing outside the worktree, this will throw PathValidationError. + * + * @throws PathValidationError with code "SYMLINK_ESCAPE" if file escapes worktree */ async readFile( worktreePath: string, @@ -70,11 +213,20 @@ export const secureFs = { ): Promise { assertRegisteredWorktree(worktreePath); const fullPath = resolvePathInWorktree(worktreePath, filePath); + + // Block reads through symlinks that escape the worktree + await assertRealpathInWorktree(worktreePath, fullPath); + return readFile(fullPath, encoding); }, /** * Read a file as a Buffer within a worktree. + * + * SECURITY: Enforces symlink-escape check. If the file is a symlink + * pointing outside the worktree, this will throw PathValidationError. + * + * @throws PathValidationError with code "SYMLINK_ESCAPE" if file escapes worktree */ async readFileBuffer( worktreePath: string, @@ -82,6 +234,10 @@ export const secureFs = { ): Promise { assertRegisteredWorktree(worktreePath); const fullPath = resolvePathInWorktree(worktreePath, filePath); + + // Block reads through symlinks that escape the worktree + await assertRealpathInWorktree(worktreePath, fullPath); + return readFile(fullPath); }, @@ -165,10 +321,13 @@ export const secureFs = { /** * Check if a file is a symlink that points outside the worktree. * - * Use this to warn users when viewing files that resolve outside - * the worktree boundary (potential malicious repo symlink). + * WARNING: This is a best-effort helper for UI warnings only. + * It returns `false` on errors, so it is NOT suitable as a security gate. + * For security enforcement, use the read/write methods which call + * assertRealpathInWorktree internally. * - * @returns true if the file is a symlink escaping the worktree + * @returns true if the file is definitely a symlink escaping the worktree, + * false if not escaping OR if we can't determine (errors) */ async isSymlinkEscaping( worktreePath: string, @@ -188,9 +347,10 @@ export const secureFs = { const real = await realpath(fullPath); const worktreeReal = await realpath(worktreePath); - return !real.startsWith(`${worktreeReal}/`) && real !== worktreeReal; + return !isPathWithinWorktree(worktreeReal, real); } catch { // If we can't determine, assume not escaping (file may not exist) + // NOTE: This makes this method unsuitable as a security gate return false; } }, diff --git a/apps/desktop/src/lib/trpc/routers/ui-state/index.ts b/apps/desktop/src/lib/trpc/routers/ui-state/index.ts index acbfa3bae18..afbff9fc94b 100644 --- a/apps/desktop/src/lib/trpc/routers/ui-state/index.ts +++ b/apps/desktop/src/lib/trpc/routers/ui-state/index.ts @@ -11,7 +11,9 @@ import { z } from "zod"; import { publicProcedure, router } from "../.."; /** - * Zod schema for FileViewerState - matches shared/tabs-types.ts + * Zod schema for FileViewerState persistence. + * Note: initialLine/initialColumn from shared/tabs-types.ts are intentionally + * omitted as they are transient (applied once on open, not persisted). */ const fileViewerStateSchema = z.object({ filePath: z.string(), diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx index e8a975f2ee4..11c2c491cc2 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx @@ -136,6 +136,9 @@ export function FileViewerPane({ const diffCategory = fileViewer?.diffCategory; const commitHash = fileViewer?.commitHash; const oldPath = fileViewer?.oldPath; + // Line/column for initial scroll position (raw mode only, applied once) + const initialLine = fileViewer?.initialLine; + const initialColumn = fileViewer?.initialColumn; // Fetch branch info for against-base diffs (P1-1) const { data: branchData } = trpc.changes.getBranches.useQuery( @@ -147,6 +150,9 @@ export function FileViewerPane({ // Track if we're saving from raw mode to know when to clear draft const savingFromRawRef = useRef(false); + // Track if we've applied initial line/column navigation (reset on file change) + const hasAppliedInitialLocationRef = useRef(false); + // Save mutation const saveFileMutation = trpc.changes.saveFile.useMutation({ onSuccess: () => { @@ -247,12 +253,13 @@ export function FileViewerPane({ } }, []); - // Reset dirty state and draft when file changes + // Reset dirty state, draft, and initial location tracking when file changes // biome-ignore lint/correctness/useExhaustiveDependencies: Reset on file change only useEffect(() => { setIsDirty(false); originalContentRef.current = ""; draftContentRef.current = null; + hasAppliedInitialLocationRef.current = false; }, [filePath]); // Fetch raw file content - always call hook, use enabled to control fetching @@ -296,6 +303,39 @@ export function FileViewerPane({ } }, [rawFileData]); + // Apply initial line/column navigation when raw content is ready + // NOTE: Line/column navigation only supported in raw mode. + // Diff mode has different line numbers between sides; rendered mode has no line concept. + useEffect(() => { + if ( + viewMode !== "raw" || + !editorRef.current || + !initialLine || + hasAppliedInitialLocationRef.current || + isLoadingRaw || + !rawFileData?.ok + ) { + return; + } + + const editor = editorRef.current; + const model = editor.getModel(); + if (!model) return; + + // Clamp to valid range to handle lines that exceed file length + const lineCount = model.getLineCount(); + const safeLine = Math.max(1, Math.min(initialLine, lineCount)); + const maxColumn = model.getLineMaxColumn(safeLine); + const safeColumn = Math.max(1, Math.min(initialColumn ?? 1, maxColumn)); + + const position = { lineNumber: safeLine, column: safeColumn }; + editor.setPosition(position); + editor.revealPositionInCenter(position); + editor.focus(); + + hasAppliedInitialLocationRef.current = true; + }, [viewMode, initialLine, initialColumn, isLoadingRaw, rawFileData]); + // Early return AFTER hooks if (!fileViewer) { return ( diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index 2c73582c9af..bb4d776297e 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -1,3 +1,4 @@ +import { toast } from "@superset/ui/sonner"; import type { FitAddon } from "@xterm/addon-fit"; import type { SearchAddon } from "@xterm/addon-search"; import type { Terminal as XTerm } from "@xterm/xterm"; @@ -79,28 +80,8 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { (path: string, line?: number, column?: number) => { const behavior = terminalLinkBehavior ?? "external-editor"; - if (behavior === "file-viewer") { - // Normalize absolute paths to worktree-relative paths for file viewer - // File viewer expects relative paths, but terminal links can be absolute - let filePath = path; - if (workspaceCwd) { - // Use path boundary check to avoid incorrect prefix stripping - // e.g., /repo vs /repo-other should not match - if (path === workspaceCwd) { - filePath = "."; - } else if (path.startsWith(`${workspaceCwd}/`)) { - filePath = path.slice(workspaceCwd.length + 1); - } else if (path.startsWith("/")) { - // Absolute path outside workspace - still try to open it - // but warn in console as it may fail validation - console.warn( - "[Terminal] Opening absolute path outside workspace:", - path, - ); - } - } - addFileViewerPane(workspaceId, { filePath }); - } else { + // Helper to open in external editor + const openInExternalEditor = () => { trpcClient.external.openFileInEditor .mutate({ path, @@ -114,7 +95,43 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { path, error, ); + toast.error("Failed to open file in editor", { + description: path, + }); }); + }; + + if (behavior === "file-viewer") { + // If workspaceCwd is not loaded yet, fall back to external editor + // This prevents confusing errors when the workspace is still initializing + if (!workspaceCwd) { + console.warn( + "[Terminal] workspaceCwd not loaded, falling back to external editor", + ); + openInExternalEditor(); + return; + } + + // Normalize absolute paths to worktree-relative paths for file viewer + // File viewer expects relative paths, but terminal links can be absolute + let filePath = path; + // Use path boundary check to avoid incorrect prefix stripping + // e.g., /repo vs /repo-other should not match + if (path === workspaceCwd) { + filePath = "."; + } else if (path.startsWith(`${workspaceCwd}/`)) { + filePath = path.slice(workspaceCwd.length + 1); + } else if (path.startsWith("/")) { + // Absolute path outside workspace - show warning and don't attempt to open + toast.warning("File is outside the workspace", { + description: + "Switch to 'External editor' in Settings to open this file", + }); + return; + } + addFileViewerPane(workspaceId, { filePath, line, column }); + } else { + openInExternalEditor(); } }, [terminalLinkBehavior, workspaceId, workspaceCwd, addFileViewerPane], diff --git a/apps/desktop/src/renderer/stores/tabs/store.ts b/apps/desktop/src/renderer/stores/tabs/store.ts index 6e6823d33e0..828d0679dc1 100644 --- a/apps/desktop/src/renderer/stores/tabs/store.ts +++ b/apps/desktop/src/renderer/stores/tabs/store.ts @@ -416,6 +416,8 @@ export const useTabsStore = create()( diffCategory: options.diffCategory, commitHash: options.commitHash, oldPath: options.oldPath, + initialLine: options.line, + initialColumn: options.column, }, }, }, diff --git a/apps/desktop/src/renderer/stores/tabs/types.ts b/apps/desktop/src/renderer/stores/tabs/types.ts index 64a298ab958..9638df6e072 100644 --- a/apps/desktop/src/renderer/stores/tabs/types.ts +++ b/apps/desktop/src/renderer/stores/tabs/types.ts @@ -37,6 +37,10 @@ export interface AddFileViewerPaneOptions { diffCategory?: ChangeCategory; commitHash?: string; oldPath?: string; + /** Line to scroll to (raw mode only) */ + line?: number; + /** Column to scroll to (raw mode only) */ + column?: number; } /** diff --git a/apps/desktop/src/renderer/stores/tabs/utils.ts b/apps/desktop/src/renderer/stores/tabs/utils.ts index 797e644d0c8..77eecc76c1f 100644 --- a/apps/desktop/src/renderer/stores/tabs/utils.ts +++ b/apps/desktop/src/renderer/stores/tabs/utils.ts @@ -99,6 +99,10 @@ export interface CreateFileViewerPaneOptions { diffCategory?: ChangeCategory; commitHash?: string; oldPath?: string; + /** Line to scroll to (raw mode only) */ + line?: number; + /** Column to scroll to (raw mode only) */ + column?: number; } /** @@ -130,6 +134,8 @@ export const createFileViewerPane = ( diffCategory: options.diffCategory, commitHash: options.commitHash, oldPath: options.oldPath, + initialLine: options.line, + initialColumn: options.column, }; // Use filename for display name diff --git a/apps/desktop/src/shared/tabs-types.ts b/apps/desktop/src/shared/tabs-types.ts index d38ce4c4284..d8c921186eb 100644 --- a/apps/desktop/src/shared/tabs-types.ts +++ b/apps/desktop/src/shared/tabs-types.ts @@ -38,6 +38,10 @@ export interface FileViewerState { commitHash?: string; /** Original path for renamed files */ oldPath?: string; + /** Initial line to scroll to (raw mode only, transient - applied once) */ + initialLine?: number; + /** Initial column to scroll to (raw mode only, transient - applied once) */ + initialColumn?: number; } /** diff --git a/packages/local-db/src/schema/schema.ts b/packages/local-db/src/schema/schema.ts index b5437dd783d..8c4daa138e6 100644 --- a/packages/local-db/src/schema/schema.ts +++ b/packages/local-db/src/schema/schema.ts @@ -107,6 +107,12 @@ export const workspaces = sqliteTable( index("workspaces_project_id_idx").on(table.projectId), index("workspaces_worktree_id_idx").on(table.worktreeId), index("workspaces_last_opened_at_idx").on(table.lastOpenedAt), + // NOTE: Migration 0006 creates an additional partial unique index: + // CREATE UNIQUE INDEX workspaces_unique_branch_per_project + // ON workspaces(project_id) WHERE type = 'branch' + // This enforces one branch workspace per project. Drizzle's schema DSL + // doesn't support partial/filtered indexes, so this constraint is only + // applied via the migration, not schema push. See migration 0006 for details. ], ); From ab1d0f65a6b09cc7b5f0b5289203d67094632007 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Sat, 3 Jan 2026 17:23:30 +0200 Subject: [PATCH 38/98] fix(desktop): address PR review security and UX issues - P0: Add dangling symlink validation to prevent writes outside worktree - P2: Fix isPathWithinWorktree to not incorrectly reject '..config' dirs - P1: Add symlink-escape error message in FileViewerPane - P1: Fix line/column navigation when clicking same file with new coords --- .../routers/changes/security/secure-fs.ts | 89 ++++++++++++++++--- .../TabView/FileViewerPane/FileViewerPane.tsx | 10 ++- 2 files changed, 88 insertions(+), 11 deletions(-) diff --git a/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts b/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts index 4f68e28932e..c6de9823606 100644 --- a/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts +++ b/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts @@ -8,7 +8,7 @@ import { stat, writeFile, } from "node:fs/promises"; -import { dirname, isAbsolute, relative, resolve } from "node:path"; +import { dirname, isAbsolute, relative, resolve, sep } from "node:path"; import { assertRegisteredWorktree, PathValidationError, @@ -39,12 +39,18 @@ function isPathWithinWorktree( return true; } const relativePath = relative(worktreeReal, targetReal); - // If relative path starts with ".." or is absolute, it's outside - return ( - !relativePath.startsWith("..") && - !isAbsolute(relativePath) && - relativePath !== "" - ); + // Check if path escapes worktree: + // - ".." means direct parent + // - "../" prefix means ancestor escape (use sep for cross-platform) + // - Absolute path means completely outside + // Note: Don't use startsWith("..") as it incorrectly catches "..config" directories + const escapesWorktree = + relativePath === ".." || + relativePath.startsWith(`..${sep}`) || + isAbsolute(relativePath) || + relativePath === ""; + + return !escapesWorktree; } /** @@ -180,10 +186,10 @@ async function assertRealpathInWorktree( ); } } catch (error) { - // If realpath fails with ENOENT, file doesn't exist yet - // Validate the parent directory chain instead + // If realpath fails with ENOENT, the target doesn't exist + // But the path itself might be a dangling symlink - check that first! if (error instanceof Error && "code" in error && error.code === "ENOENT") { - await assertParentInWorktree(worktreePath, fullPath); + await assertDanglingSymlinkSafe(worktreePath, fullPath); return; } // Re-throw PathValidationError @@ -197,6 +203,69 @@ async function assertRealpathInWorktree( ); } } + +/** + * Handle the ENOENT case: check if fullPath is a dangling symlink pointing outside + * the worktree, or if it truly doesn't exist (in which case validate parent chain). + * + * Attack scenario this prevents: + * - Repo contains `docs/config.yml` → symlink to `~/.ssh/some_new_file` (doesn't exist) + * - realpath() fails with ENOENT (target missing) + * - Without this check, we'd only validate parent (`docs/`) which is valid + * - Write would follow symlink and create `~/.ssh/some_new_file` + * + * @throws PathValidationError if symlink escapes worktree + */ +async function assertDanglingSymlinkSafe( + worktreePath: string, + fullPath: string, +): Promise { + const worktreeReal = await realpath(worktreePath); + + try { + // Check if the path itself exists (as a symlink or otherwise) + const stats = await lstat(fullPath); + + if (stats.isSymbolicLink()) { + // It's a dangling symlink - validate where it points + const linkTarget = await readlink(fullPath); + const resolvedTarget = isAbsolute(linkTarget) + ? linkTarget + : resolve(dirname(fullPath), linkTarget); + + // Check if the resolved target would be within worktree + // For dangling symlinks, we can't use realpath on the target, + // so we check the literal resolved path + const targetRelative = relative(worktreeReal, resolvedTarget); + if ( + targetRelative === ".." || + targetRelative.startsWith(`..${sep}`) || + isAbsolute(targetRelative) + ) { + throw new PathValidationError( + "Dangling symlink points outside the worktree", + "SYMLINK_ESCAPE", + ); + } + // Dangling symlink points within worktree - allow the operation + return; + } + + // Not a symlink but lstat succeeded - weird state, but validate parent chain + await assertParentInWorktree(worktreePath, fullPath); + } catch (error) { + if (error instanceof PathValidationError) { + throw error; + } + if (error instanceof Error && "code" in error && error.code === "ENOENT") { + // Path truly doesn't exist (not even as a symlink) - validate parent chain + await assertParentInWorktree(worktreePath, fullPath); + return; + } + // Other errors - fail closed + throw new PathValidationError("Cannot validate path", "SYMLINK_ESCAPE"); + } +} export const secureFs = { /** * Read a file within a worktree. diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx index 11c2c491cc2..e33ce675d2a 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/TabView/FileViewerPane/FileViewerPane.tsx @@ -262,6 +262,12 @@ export function FileViewerPane({ hasAppliedInitialLocationRef.current = false; }, [filePath]); + // P1: Reset navigation flag when line/column changes (e.g., clicking same file from terminal with different line) + // biome-ignore lint/correctness/useExhaustiveDependencies: Only reset when coordinates change + useEffect(() => { + hasAppliedInitialLocationRef.current = false; + }, [initialLine, initialColumn]); + // Fetch raw file content - always call hook, use enabled to control fetching const { data: rawFileData, isLoading: isLoadingRaw } = trpc.changes.readWorkingFile.useQuery( @@ -471,7 +477,9 @@ export function FileViewerPane({ ? "Binary file preview not supported" : rawFileData?.reason === "outside-worktree" ? "File is outside worktree" - : "File not found"; + : rawFileData?.reason === "symlink-escape" + ? "File is a symlink pointing outside worktree" + : "File not found"; return (
{errorMessage} From c791f54473a656c1e5eaadbc98e291f324bf7a98 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Sat, 3 Jan 2026 17:40:03 +0200 Subject: [PATCH 39/98] fix(desktop): use sep-aware check in assertParentInWorktree ENOENT path P2 from review: The dangling symlink target check in assertParentInWorktree was still using startsWith('..') which incorrectly rejects '..config' dirs. Now uses the same pattern as isPathWithinWorktree. --- .../src/lib/trpc/routers/changes/security/secure-fs.ts | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts b/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts index c6de9823606..75201eb81f9 100644 --- a/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts +++ b/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts @@ -106,7 +106,12 @@ async function assertParentInWorktree( // We need to check if the target, when resolved, would be in worktree // This is conservative: if we can't determine, fail closed const targetRelative = relative(worktreeReal, resolvedTarget); - if (targetRelative.startsWith("..") || isAbsolute(targetRelative)) { + // Use sep-aware check to avoid false positives on "..config" dirs + if ( + targetRelative === ".." || + targetRelative.startsWith(`..${sep}`) || + isAbsolute(targetRelative) + ) { throw new PathValidationError( "Dangling symlink points outside the worktree", "SYMLINK_ESCAPE", From 1a2988e773014802ea32fe60a65e91897a041bc0 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Sat, 3 Jan 2026 18:35:34 +0200 Subject: [PATCH 40/98] fix(desktop): address P0/P1 security issues from review P0: secureFs.delete symlink escape - Check if target is symlink via lstat before deletion - Symlinks: delete the link itself (safe - lives in worktree) - Files/dirs: validate realpath is within worktree before rm - Prevents attack: docs -> /victim, delete docs/file deletes /victim/file P1: Block external images in markdown renderer - Add SafeImage component that blocks http:// and https:// URLs - Shows 'External image blocked' placeholder for external images - Allows relative paths and data: URLs (safe for repo content) - Prevents tracking pixels and privacy leaks from untrusted repos Design decisions (reviewer questions): - Markdown remote images: Blocked by default. No opt-in toggle yet. - Deleting symlinks: Allow deleting the symlink file itself (it lives in worktree). Never follow the symlink during deletion. --- .../routers/changes/security/secure-fs.ts | 39 +++++++++++++- .../components/SafeImage/SafeImage.tsx | 54 +++++++++++++++++++ .../components/SafeImage/index.ts | 1 + .../MarkdownRenderer/components/index.ts | 1 + .../styles/default/config.tsx | 8 ++- .../MarkdownRenderer/styles/tufte/config.tsx | 4 +- 6 files changed, 102 insertions(+), 5 deletions(-) create mode 100644 apps/desktop/src/renderer/components/MarkdownRenderer/components/SafeImage/SafeImage.tsx create mode 100644 apps/desktop/src/renderer/components/MarkdownRenderer/components/SafeImage/index.ts diff --git a/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts b/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts index 75201eb81f9..6d72eb31109 100644 --- a/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts +++ b/apps/desktop/src/lib/trpc/routers/changes/security/secure-fs.ts @@ -341,8 +341,13 @@ export const secureFs = { /** * Delete a file or directory within a worktree. * - * DANGEROUS: Uses recursive + force deletion. - * Explicitly prevents deleting the worktree root. + * SECURITY: Validates the real path is within worktree before deletion. + * - Symlinks: Deletes the link itself (safe - link lives in worktree) + * - Files/dirs: Validates realpath then deletes + * + * This prevents symlink escape attacks where a malicious repo contains + * `docs -> /Users/victim` and a delete of `docs/file` would delete + * `/Users/victim/file`. */ async delete(worktreePath: string, filePath: string): Promise { assertRegisteredWorktree(worktreePath); @@ -350,6 +355,36 @@ export const secureFs = { const fullPath = resolvePathInWorktree(worktreePath, filePath, { allowRoot: false, }); + + let stats: Stats; + try { + stats = await lstat(fullPath); + } catch (error) { + // File doesn't exist - idempotent delete, nothing to do + if ( + error instanceof Error && + "code" in error && + error.code === "ENOENT" + ) { + return; + } + throw error; + } + + if (stats.isSymbolicLink()) { + // Symlink - safe to delete the link itself (it lives in the worktree). + // Don't use recursive as we're just removing the symlink file. + await rm(fullPath); + return; + } + + // Regular file or directory - validate realpath is within worktree. + // This catches path traversal via symlinked parent components: + // e.g., `docs -> /victim`, delete `docs/file` → realpath is `/victim/file` + await assertRealpathInWorktree(worktreePath, fullPath); + + // Safe to delete - realpath confirmed within worktree. + // Note: Symlinks INSIDE a directory are safe - rm deletes the links, not targets. await rm(fullPath, { recursive: true, force: true }); }, diff --git a/apps/desktop/src/renderer/components/MarkdownRenderer/components/SafeImage/SafeImage.tsx b/apps/desktop/src/renderer/components/MarkdownRenderer/components/SafeImage/SafeImage.tsx new file mode 100644 index 00000000000..be5d07fcc21 --- /dev/null +++ b/apps/desktop/src/renderer/components/MarkdownRenderer/components/SafeImage/SafeImage.tsx @@ -0,0 +1,54 @@ +import { LuImageOff } from "react-icons/lu"; + +/** + * Check if a URL is external (http:// or https://). + * External images are blocked by default to prevent: + * - Tracking pixels leaking user IP/activity + * - Automatic downloads of large/malicious files + * - Internal network exposure + */ +function isExternalUrl(src: string | undefined): boolean { + if (!src) return false; + const lower = src.toLowerCase().trim(); + return lower.startsWith("http://") || lower.startsWith("https://"); +} + +interface SafeImageProps { + src?: string; + alt?: string; + className?: string; +} + +/** + * Safe image component that blocks external URLs by default. + * + * Allowed: + * - Relative paths (./image.png, ../assets/logo.svg) + * - Data URLs (data:image/png;base64,...) + * - File URLs (file://...) + * + * Blocked: + * - HTTP/HTTPS URLs (privacy risk from untrusted repos) + */ +export function SafeImage({ src, alt, className }: SafeImageProps) { + if (isExternalUrl(src)) { + return ( +
+ + External image blocked +
+ ); + } + + // Safe to render - relative path or data URL + return ( + {alt} + ); +} diff --git a/apps/desktop/src/renderer/components/MarkdownRenderer/components/SafeImage/index.ts b/apps/desktop/src/renderer/components/MarkdownRenderer/components/SafeImage/index.ts new file mode 100644 index 00000000000..3a608bf50fd --- /dev/null +++ b/apps/desktop/src/renderer/components/MarkdownRenderer/components/SafeImage/index.ts @@ -0,0 +1 @@ +export { SafeImage } from "./SafeImage"; diff --git a/apps/desktop/src/renderer/components/MarkdownRenderer/components/index.ts b/apps/desktop/src/renderer/components/MarkdownRenderer/components/index.ts index b5cd6b0e8fd..d208845016c 100644 --- a/apps/desktop/src/renderer/components/MarkdownRenderer/components/index.ts +++ b/apps/desktop/src/renderer/components/MarkdownRenderer/components/index.ts @@ -1,2 +1,3 @@ export { CodeBlock } from "./CodeBlock"; +export { SafeImage } from "./SafeImage"; export { SelectionContextMenu } from "./SelectionContextMenu"; diff --git a/apps/desktop/src/renderer/components/MarkdownRenderer/styles/default/config.tsx b/apps/desktop/src/renderer/components/MarkdownRenderer/styles/default/config.tsx index 61ef8cdd6a0..c19cc5e1b78 100644 --- a/apps/desktop/src/renderer/components/MarkdownRenderer/styles/default/config.tsx +++ b/apps/desktop/src/renderer/components/MarkdownRenderer/styles/default/config.tsx @@ -1,5 +1,5 @@ import { cn } from "@superset/ui/utils"; -import { CodeBlock } from "../../components"; +import { CodeBlock, SafeImage } from "../../components"; import type { MarkdownStyleConfig } from "../types"; import "./default.css"; @@ -41,7 +41,11 @@ export const defaultConfig: MarkdownStyleConfig = { ), img: ({ src, alt }) => ( - {alt} + ), hr: () =>
, li: ({ children, className }) => { diff --git a/apps/desktop/src/renderer/components/MarkdownRenderer/styles/tufte/config.tsx b/apps/desktop/src/renderer/components/MarkdownRenderer/styles/tufte/config.tsx index 077f8d91371..5173f7e4557 100644 --- a/apps/desktop/src/renderer/components/MarkdownRenderer/styles/tufte/config.tsx +++ b/apps/desktop/src/renderer/components/MarkdownRenderer/styles/tufte/config.tsx @@ -1,4 +1,4 @@ -import { CodeBlock } from "../../components"; +import { CodeBlock, SafeImage } from "../../components"; import type { MarkdownStyleConfig } from "../types"; import "./tufte.css"; @@ -12,5 +12,7 @@ export const tufteConfig: MarkdownStyleConfig = { {children} ), + // Block external images for privacy (tracking pixels, etc.) + img: ({ src, alt }) => , }, }; From 930c122a43a760a8ae10786dac8278b21a14aa48 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Sat, 3 Jan 2026 18:42:08 +0200 Subject: [PATCH 41/98] fix(desktop): guard against undefined panes in attention check --- .../main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx | 2 +- .../WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx index b98e36c98c2..8b3dd67e6b2 100644 --- a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx +++ b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx @@ -71,7 +71,7 @@ export function WorkspaceItem({ workspaceTabs.flatMap((t) => extractPaneIdsFromLayout(t.layout)), ); const hasPaneAttention = Object.values(panes) - .filter((p) => workspacePaneIds.has(p.id)) + .filter((p) => p != null && workspacePaneIds.has(p.id)) .some((p) => p.needsAttention); // Show indicator if workspace is manually marked as unread OR has pane-level attention diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx index 9a1ca16b45d..04afd81d085 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx @@ -103,7 +103,7 @@ export function WorkspaceListItem({ workspaceTabs.flatMap((t) => extractPaneIdsFromLayout(t.layout)), ); const hasPaneAttention = Object.values(panes) - .filter((p) => workspacePaneIds.has(p.id)) + .filter((p) => p != null && workspacePaneIds.has(p.id)) .some((p) => p.needsAttention); // Show indicator if workspace is manually marked as unread OR has pane-level attention From edc4dae0dcfba059cffc623d5b74ca604302e9b0 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Sat, 3 Jan 2026 19:00:48 +0200 Subject: [PATCH 42/98] fix(desktop): use strict allowlist for SafeImage - only allow data: URLs P0: Previous fix only blocked http/https but missed: - file:// URLs (arbitrary local file access) - Absolute paths /... or \... (become file:// in Electron) - Relative paths with .. (escape repo boundary) - UNC paths //server/share (Windows NTLM credential leak) Now uses strict allowlist: ONLY data: URLs are allowed. All other sources show 'Image blocked' placeholder. Future: Could add opt-in secure loader for repo-relative images via secureFs validation + blob: URL serving. --- .../components/SafeImage/SafeImage.tsx | 55 ++++++++++++------- 1 file changed, 36 insertions(+), 19 deletions(-) diff --git a/apps/desktop/src/renderer/components/MarkdownRenderer/components/SafeImage/SafeImage.tsx b/apps/desktop/src/renderer/components/MarkdownRenderer/components/SafeImage/SafeImage.tsx index be5d07fcc21..91295eaa98f 100644 --- a/apps/desktop/src/renderer/components/MarkdownRenderer/components/SafeImage/SafeImage.tsx +++ b/apps/desktop/src/renderer/components/MarkdownRenderer/components/SafeImage/SafeImage.tsx @@ -1,16 +1,33 @@ import { LuImageOff } from "react-icons/lu"; /** - * Check if a URL is external (http:// or https://). - * External images are blocked by default to prevent: - * - Tracking pixels leaking user IP/activity - * - Automatic downloads of large/malicious files - * - Internal network exposure + * Check if an image source is safe to load. + * + * Uses strict ALLOWLIST approach - only data: URLs are safe. + * + * ALLOWED: + * - data: URLs (embedded base64 images) + * + * BLOCKED (everything else): + * - http://, https:// (tracking pixels, privacy leak) + * - file:// URLs (arbitrary local file access) + * - Absolute paths /... or \... (become file:// in Electron) + * - Relative paths with .. (can escape repo boundary) + * - UNC paths //server/share (Windows NTLM credential leak) + * - Empty or malformed sources + * + * Security context: In Electron production, renderer loads via file:// + * protocol. Any non-data: image src could access local filesystem or + * trigger network requests to attacker-controlled servers. */ -function isExternalUrl(src: string | undefined): boolean { +function isSafeImageSrc(src: string | undefined): boolean { if (!src) return false; - const lower = src.toLowerCase().trim(); - return lower.startsWith("http://") || lower.startsWith("https://"); + const trimmed = src.trim(); + if (trimmed.length === 0) return false; + + // Only allow data: URLs (embedded images) + // These are self-contained and can't access external resources + return trimmed.toLowerCase().startsWith("data:"); } interface SafeImageProps { @@ -20,30 +37,30 @@ interface SafeImageProps { } /** - * Safe image component that blocks external URLs by default. + * Safe image component for untrusted markdown content. * - * Allowed: - * - Relative paths (./image.png, ../assets/logo.svg) - * - Data URLs (data:image/png;base64,...) - * - File URLs (file://...) + * Only renders embedded data: URLs. All other sources are blocked + * to prevent local file access, network requests, and path traversal + * attacks from malicious repository content. * - * Blocked: - * - HTTP/HTTPS URLs (privacy risk from untrusted repos) + * Future: Could add opt-in support for repo-relative images via a + * secure loader that validates paths through secureFs and serves + * as blob: URLs. */ export function SafeImage({ src, alt, className }: SafeImageProps) { - if (isExternalUrl(src)) { + if (!isSafeImageSrc(src)) { return (
- External image blocked + Image blocked
); } - // Safe to render - relative path or data URL + // Safe to render - embedded data: URL return ( Date: Mon, 29 Dec 2025 21:01:23 +0200 Subject: [PATCH 43/98] feat(desktop): terminal persistence via daemon process Implement terminal session persistence using a background daemon process that survives app restarts. Key features: - Terminal host daemon: Long-lived process that owns PTYs and maintains terminal emulation state while Electron app is closed - Headless terminal emulator: Captures full terminal state (screen, scrollback, modes) for perfect resume - NDJSON-over-Unix-socket IPC: Secure communication with token authentication - DaemonTerminalManager: Drop-in replacement that delegates to daemon while preserving existing TRPC API When enabled (SUPERSET_TERMINAL_DAEMON=1), terminals persist across app quit/restart with exact screen state and interactive input working immediately. --- ...rminal-host-daemon-terminal-persistence.md | 512 ++++++++++++++ apps/desktop/electron.vite.config.ts | 5 + apps/desktop/package.json | 1 + .../src/lib/trpc/routers/terminal/terminal.ts | 7 +- .../src/main/lib/terminal-host/client.ts | 611 +++++++++++++++++ .../lib/terminal-host/headless-emulator.ts | 437 ++++++++++++ .../prototype/headless-roundtrip.test.ts | 529 +++++++++++++++ .../src/main/lib/terminal-host/types.ts | 303 +++++++++ .../src/main/lib/terminal/daemon-manager.ts | 446 ++++++++++++ apps/desktop/src/main/lib/terminal/index.ts | 45 +- apps/desktop/src/main/lib/terminal/types.ts | 10 + .../src/main/terminal-host/daemon.test.ts | 429 ++++++++++++ apps/desktop/src/main/terminal-host/index.ts | 495 ++++++++++++++ .../terminal-host/session-lifecycle.test.ts | 642 ++++++++++++++++++ .../desktop/src/main/terminal-host/session.ts | 388 +++++++++++ .../src/main/terminal-host/terminal-host.ts | 206 ++++++ bun.lock | 3 + 17 files changed, 5067 insertions(+), 2 deletions(-) create mode 100644 20251229-1858-terminal-host-daemon-terminal-persistence.md create mode 100644 apps/desktop/src/main/lib/terminal-host/client.ts create mode 100644 apps/desktop/src/main/lib/terminal-host/headless-emulator.ts create mode 100644 apps/desktop/src/main/lib/terminal-host/prototype/headless-roundtrip.test.ts create mode 100644 apps/desktop/src/main/lib/terminal-host/types.ts create mode 100644 apps/desktop/src/main/lib/terminal/daemon-manager.ts create mode 100644 apps/desktop/src/main/terminal-host/daemon.test.ts create mode 100644 apps/desktop/src/main/terminal-host/index.ts create mode 100644 apps/desktop/src/main/terminal-host/session-lifecycle.test.ts create mode 100644 apps/desktop/src/main/terminal-host/session.ts create mode 100644 apps/desktop/src/main/terminal-host/terminal-host.ts diff --git a/20251229-1858-terminal-host-daemon-terminal-persistence.md b/20251229-1858-terminal-host-daemon-terminal-persistence.md new file mode 100644 index 00000000000..f3297f4ee3e --- /dev/null +++ b/20251229-1858-terminal-host-daemon-terminal-persistence.md @@ -0,0 +1,512 @@ +# Terminal persistence via Superset-owned terminal host daemon (Desktop) + +This ExecPlan is a living document. The sections `Progress`, `Surprises & Discoveries`, `Decision Log`, and `Outcomes & Retrospective` must be kept up to date as work proceeds. + +No `PLANS.md` file was found in this repository at the time of writing. Follow the ExecPlan template requirements embedded in the prompt for structure, idempotence, and validation. + +## Purpose / Big Picture + +After this change, a Superset Desktop user can enable “terminal session persistence” and then: + +1. Open a terminal pane and start a long-running terminal UI (a “TUI”, e.g. `vim`, `htop`, `opencode`, `less`). +2. Quit Superset Desktop (including via auto-update install flow). +3. Reopen Superset Desktop and see the terminal come back exactly as it was (“perfect resume”): the screen contents match, the cursor/modes match, and interactive input works immediately (arrow keys, mouse, bracketed paste, etc.). +4. While the app was closed, the terminal continued running and its output was captured; reopening shows the up-to-date TUI state and recent scrollback. + +The key implementation change is introducing a long-lived background “terminal host” process (a daemon) that owns the PTYs and maintains terminal emulation state while the Electron app is closed. The Electron main process becomes a client of this daemon and continues to expose the same TRPC terminal interface to the renderer. + +## Assumptions + +1. This work targets `origin/main` and will be implemented on a new branch created from `origin/main` (e.g. `feat/terminal-host-daemon`). +2. macOS is the primary supported platform today; Linux is secondary. Windows support is explicitly deferred but must be feasible with the chosen abstractions. +3. The project continues to use `node-pty` as the PTY implementation for macOS/Linux (current dependency in `apps/desktop/package.json`). +4. The renderer continues to use xterm.js (`@xterm/xterm`) as the visible terminal UI (current implementation under `apps/desktop/src/renderer/.../Terminal`). +5. “Survive app updates” means: installing an update (on macOS via `electron-updater`) does not kill terminal sessions; a newly-launched updated app can attach to the already-running sessions. +6. “Perfect TUI resume” is interpreted strictly: the user should not need to “press a key to redraw” or rely on application-specific repaint behavior; the terminal state must be restored deterministically from the daemon-maintained emulator state. + +If any assumption is wrong, record the correction in `Decision Log` and update all impacted sections. + +## Open Questions + +**All questions resolved.** See Decision Log for details. + +1. ~~Persistence default and UX~~ → **RESOLVED**: Opt-in setting in Behaviors page, default off. +2. ~~Update/version skew policy~~ → **RESOLVED**: (A) Old daemon continues; additive protocol changes only. +3. ~~Output retention bounds~~ → **RESOLVED**: Configurable settings; defaults 10k lines + 4 MB disk per session. +4. ~~Multi-window semantics~~ → **RESOLVED**: Not applicable; single client per session. +5. ~~Security posture~~ → **RESOLVED**: User-only socket + token file. +6. ~~"Perfect resume" acceptance set~~ → **RESOLVED**: Test opencode, claude code, codex. + +## Progress + +- [x] (2025-12-29 18:58 local) Create new branch from `origin/main` and add this ExecPlan. +- [x] (2025-12-29 19:30 local) Implement prototyping harness for headless emulation + snapshot round-trip. **Milestone 1 complete** - 29 tests pass. +- [x] (2025-12-29 19:45 local) Implement daemon entrypoint and IPC framing. **Milestone 2 complete** - 6 tests pass. + - Created daemon entrypoint at `apps/desktop/src/main/terminal-host/index.ts` + - Updated `electron.vite.config.ts` to build daemon as separate bundle + - Implemented NDJSON protocol over Unix domain socket + - Implemented token-based authentication + - All hello/auth tests passing +- [x] (2025-12-29 20:00 local) Implement daemon session manager (PTY + headless emulator + capture). **Milestone 3 substantially complete** - 9 tests pass, 4 skipped (PTY tests). + - Created `Session` class with PTY + HeadlessEmulator integration + - Created `TerminalHost` class for session lifecycle management + - Implemented all IPC handlers (createOrAttach, write, resize, detach, kill, killAll, listSessions, clearScrollback) + - Data/exit event streaming to attached clients implemented + - Note: Some integration tests skipped due to bun/node-pty compatibility issue (see Surprises) + - Output capture to disk (ring buffer) deferred to later milestone +- [x] (2025-12-29 19:30 local) Integrate daemon client into Electron main process and preserve existing TRPC API. **Milestone 4 substantially complete**. + - Created `TerminalHostClient` at `apps/desktop/src/main/lib/terminal-host/client.ts` + - Manages connection to daemon socket + - Spawns daemon if not running (detached process with ELECTRON_RUN_AS_NODE=1) + - Handles authentication and request/response framing + - Forwards data/exit events via EventEmitter + - Created `DaemonTerminalManager` at `apps/desktop/src/main/lib/terminal/daemon-manager.ts` + - Same interface as original `TerminalManager` + - Delegates all operations to `TerminalHostClient` + - Maintains EventEmitter compatibility for TRPC subscriptions + - Updated `apps/desktop/src/main/lib/terminal/index.ts` + - Added `getActiveTerminalManager()` function + - Controlled by `SUPERSET_TERMINAL_DAEMON=1` env var for testing + - Updated TRPC terminal router to: + - Use `getActiveTerminalManager()` for manager selection + - Return snapshot payload in `createOrAttach` response + - Build passes, tests pass (362 pass, 4 skip, 1 fail - pre-existing) + - Note: Manual testing pending - set `SUPERSET_TERMINAL_DAEMON=1` and run `bun dev` +- [ ] Update renderer terminal to apply daemon snapshot + mode rehydration before streaming. +- [ ] Add persistence setting + quit/update behavior changes; add "Stop background sessions" control. +- [ ] Add tests + manual acceptance checklist; document known limitations and recovery steps. +- [ ] Fill in Outcomes & Retrospective; move plan to `.agents/plans/done/` when PR is created. + +## Surprises & Discoveries + +- **bun/node-pty test compatibility issue** (2025-12-29): When running integration tests with real PTYs via bun, there's an internal node-pty error: `this._socket.write is not a function`. This affects PTY write operations in the test environment. The existing TerminalManager tests work around this by mocking node-pty entirely. For the daemon, we've skipped the PTY-dependent integration tests and will rely on manual testing until this is resolved. The core daemon infrastructure (socket, auth, NDJSON protocol) is fully tested. + +## Decision Log + +Add entries here as decisions are made and questions are resolved. + +- **Decision (Q1): Persistence default and UX** — RESOLVED + Setting added to Behaviors settings page with default **off**. + Rationale: Lower risk for v1; users consciously opt-in to background daemon behavior. Can flip to default-on in future release once confidence is high. + Date: 2025-12-29. + +- **Decision (Q2): Update/version skew policy** — RESOLVED + **(A) Old daemon continues running** when app updates. New app speaks old protocol. + Protocol changes must be additive-only. If breaking change required, bump `protocolVersion` and show user prompt to restart terminals. + Rationale: The whole point of persistence is surviving app restarts — updates are the primary restart trigger. + Date: 2025-12-29. + +- **Decision (Q3): Output retention bounds** — RESOLVED + Configurable via Behaviors settings page. Defaults: + - Emulator scrollback: **10,000 lines** (range: 1k–100k) + - Disk ring buffer: **4 MB per session** (range: 1–32 MB) + Rationale: Users may have 100+ terminals; conservative defaults (100 sessions × 4 MB = 400 MB disk) prevent resource exhaustion. Power users can increase via settings. + Date: 2025-12-29. + +- **Decision (Q4): Multi-window attach semantics** — RESOLVED + **Not applicable.** The same terminal pane cannot be visible in multiple windows simultaneously due to app architecture. Implementation assumes single attached client per session — no fanout logic needed. + Rationale: Simplifies protocol and eliminates race conditions. + Date: 2025-12-29. + +- **Decision (Q5): Security posture** — RESOLVED + **User-only socket + token file** is sufficient. + - `SUPERSET_HOME_DIR` created with mode `0700` + - Socket at `~/.superset/terminal-host.sock` inherits directory permissions + - Token file at `~/.superset/terminal-host.token` with mode `0600` + - Token is 32+ bytes from `crypto.randomBytes`, hex-encoded + - Token validated on every `hello` request + Rationale: Local-only threat model; if attacker has same-user access, they can already kill the daemon or read process memory. Token prevents accidental cross-user access. + Date: 2025-12-29. + +- **Decision (Q6): "Perfect resume" acceptance set** — RESOLVED + Test the following AI coding agents (primary use case for Superset users): + - **opencode** + - **claude code** (Anthropic's Claude CLI) + - **codex** (OpenAI Codex CLI) + These stress long-running sessions, bracketed paste, and complex terminal modes — the exact workflows being optimized. + Date: 2025-12-29. + +## Outcomes & Retrospective + +(to be filled as milestones complete) + +## Context and Orientation + +This repository is a Bun + Turborepo monorepo. The Superset Desktop app lives under `apps/desktop/` and is built with Electron + `electron-vite`. + +In Desktop, there are three relevant runtime “sides”: + +1. Main process (Node.js/Electron environment): `apps/desktop/src/main/` + This can use Node.js modules and is responsible for creating BrowserWindows, running the local SQLite DB, managing terminals, etc. +2. Renderer process (browser environment): `apps/desktop/src/renderer/` + This cannot import Node.js modules. It renders the UI and hosts xterm.js terminal UI components. +3. Shared modules: `apps/desktop/src/shared/` + These must not import Node.js modules; they’re used by both main and renderer. + +Today’s terminal architecture (before this change): + +1. Renderer terminal UI: `apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx` + - Creates a visible xterm.js instance. + - Calls TRPC mutations to create/attach a session, write input, resize, detach, clear scrollback. + - Subscribes to a TRPC stream of terminal output events. +2. TRPC terminal router: `apps/desktop/src/lib/trpc/routers/terminal/terminal.ts` + - Exposes `createOrAttach`, `write`, `resize`, `kill`, `detach`, `clearScrollback`, and `stream`. + - Delegates to `terminalManager` in the main process. +3. TerminalManager: `apps/desktop/src/main/lib/terminal/manager.ts` + - Owns `node-pty` processes in-memory and emits `data:` and `exit:` events. + - On app quit, the main process calls `terminalManager.cleanup()` from `apps/desktop/src/main/index.ts`, killing PTYs. +4. Terminal history: `apps/desktop/src/main/lib/terminal-history.ts` + - Writes scrollback to disk under `~/.superset*/terminal-history/...` for recovery within a running app session. + +Why this is insufficient for persistence: + +- A PTY session cannot be “reattached” after the owning process exits. Today, the Electron main process owns the PTYs, so quitting the app necessarily kills sessions. + +New architecture required: + +- Introduce a persistent background process that owns PTYs and the “terminal emulator state” so sessions outlive app restarts and TUIs remain correct even when the renderer is closed. + +Terminology used in this plan (definitions): + +- PTY (pseudo-terminal): the OS interface that lets us run a shell/program as if it’s connected to a terminal. `node-pty` provides a cross-platform-ish API to spawn PTYs. +- TUI: a text-based interactive UI that relies on terminal modes, cursor addressing, alternate screen buffers, mouse tracking, etc. +- Terminal emulator: software that interprets control sequences (ANSI/VT) to maintain a screen buffer and state. xterm.js is one. +- Daemon (terminal host): a background process that continues running after the Electron app exits. +- Snapshot/rehydration: the daemon provides enough information (screen contents + mode state) for the renderer to recreate the exact terminal state on attach. + +## Plan of Work + +This work is intentionally milestone-driven. Each milestone must leave the repository in a runnable/testable state and must be independently verifiable. Do not attempt to “big bang” the whole daemon + UI rewrite in one pass. + +### Milestone 1: Prototyping spike — prove “perfect resume” is achievable + +Goal: demonstrate, in code checked into this repo, that we can: + +1. Feed terminal output into a headless terminal emulator (in Node), keep it running while no UI exists, and +2. Produce a snapshot that can be applied to a fresh xterm.js instance such that interactive input behavior matches (application cursor keys, bracketed paste, mouse tracking). + +Work to do: + +1. Add a prototyping script + tests under `apps/desktop/src/main/lib/terminal-host/prototype/`: + - `apps/desktop/src/main/lib/terminal-host/prototype/headless-roundtrip.test.ts` + - The test should: + - Create a headless emulator instance. + - Apply a sequence of terminal bytes that: + - Enters alternate screen, draws a screen, moves cursor. + - Enables application cursor keys (`CSI ? 1 h`) and bracketed paste (`CSI ? 2004 h`). + - Enables mouse mode (choose one: `CSI ? 1000 h` and SGR `CSI ? 1006 h`). + - Produce a snapshot payload: `{ snapshotAnsi: string, modes: {...} }`. + - Apply it into a fresh xterm.js instance in Node (or a second headless instance) and assert: + - The visible buffer text matches expected lines. + - The emulator’s mode flags are consistent (for flags we explicitly track). +2. Dependency choice: + - Add `@xterm/headless` to `apps/desktop/package.json` (used only in main/daemon code). + - Reuse `@xterm/addon-serialize` (already present) for snapshot generation. +3. Decide “source of truth” for query responses: + - While *no renderer client is attached*, the daemon must send xterm-generated query responses back to the PTY. + - While *a renderer client is attached*, the renderer continues sending xterm’s `onData` to backend (as today), and the daemon must not double-respond. + +Exit criteria / proof: + +- `cd apps/desktop && bun test` includes the new headless round-trip test and it passes. + +If the spike fails (serialize cannot rehydrate required state), update this ExecPlan with a pivot: track mode state explicitly and reapply via control sequences on attach, even if the snapshot only contains screen text. + +### Milestone 2: Add a terminal host daemon entrypoint and IPC framing + +Goal: add a runnable daemon process that can start, accept a connection, and respond to a `hello` request. No PTYs yet. + +Work to do: + +1. Create a new daemon entrypoint: + - `apps/desktop/src/main/terminal-host/index.ts` + This file is executed in a Node context (via Electron with `ELECTRON_RUN_AS_NODE=1`) and must not import any renderer/shared browser-only modules. +2. Update build configuration to produce the daemon bundle: + - In `apps/desktop/electron.vite.config.ts`, add an additional Rollup input for the main build so `dist/main/terminal-host.js` is built alongside `dist/main/index.js`. +3. Implement IPC message framing: + - Use a newline-delimited JSON protocol (NDJSON) over a local socket: + - request: `{ id: string, type: string, payload: object }` + - response: `{ id: string, ok: true, payload: object }` or `{ id: string, ok: false, error: { code: string, message: string } }` + - events: `{ type: "event", event: string, payload: object }` + - This keeps early prototypes simple and debuggable. +4. Socket location: + - macOS/Linux: Unix domain socket at `join(SUPERSET_HOME_DIR, "terminal-host.sock")`. + - Ensure permissions by relying on existing `SUPERSET_HOME_DIR` mode `0700` (created by local-db initialization). If that’s not guaranteed early enough, explicitly `mkdir/chmod` within daemon. +5. Auth token: + - Generate a random token on first run and write to `join(SUPERSET_HOME_DIR, "terminal-host.token")` with `0600`. + - Require the client to send it in `hello`. + +Exit criteria / proof: + +- A small Node script in main can connect and get a valid `hello` response. + +### Milestone 3: Daemon session manager (PTY + headless emulator + capture) + +Goal: daemon can create sessions (spawn PTY), keep them running when no clients are attached, continuously capture output to disk, and provide attach snapshots. + +Work to do: + +1. Define daemon session identity and lifecycle: + - Session ID should be stable across restarts and updates. Use `workspaceId` + `paneId` from existing TRPC inputs. + - Store per-session metadata (cwd, createdAt, lastAttachedAt, cols/rows). +2. Implement a `TerminalHost` in `apps/desktop/src/main/lib/terminal-host/`: + - `TerminalHost` holds a `Map`. + - Each `Session` owns: + - the `node-pty` process + - a headless xterm instance (“emulator of record”) + - a bounded on-disk log (ring buffer) and minimal metadata file + - a set of currently attached clients (0 or more) and their stream subscriptions +3. Emulator responsibilities: + - All PTY output is fed into the headless emulator to maintain state. + - The headless emulator’s `onData` is treated as “terminal-generated responses”. + - If `attachedClients === 0`: write these responses to the PTY (so TUIs keep functioning while app closed). + - If `attachedClients > 0`: do not write (renderer is responsible; avoids duplicate responses). +4. Snapshot API: + - `attach(sessionId, cols, rows)` returns: + - `snapshotAnsi`: serialized screen state string suitable to `xterm.write()`. + - `rehydrateSequences`: a small set of control sequences to restore input-affecting modes (application cursor keys, bracketed paste, mouse reporting, focus reporting, alt-screen, cursor visibility). + - `cwd` (best-effort, derived from OSC-7 parsing in output; see note below). + - `meta` including `attachedAt`, `cols/rows`. + - The daemon must keep mode state explicitly (don’t rely on private xterm internals). + - Track DECSET/DECRST `CSI ? Pm h/l` for the specific mode numbers needed. +5. CWD tracking: + - Move OSC-7 parsing to a shared module under `apps/desktop/src/shared/parse-cwd.ts` (no Node imports). + - The daemon parses PTY output stream to update `session.cwd`. +6. Output capture while closed: + - Write the raw output stream (post-clear-filtering if desired) to a bounded file (ring). + - Also keep emulator scrollback bounded via xterm options. + +Exit criteria / proof: + +- Manual: start daemon, create session, run a TUI, detach client (simulate by closing app window), confirm process continues and output grows in ring file, then reattach and see correct screen. +- Automated: add at least one integration-style test that spawns a short-lived PTY program that uses alternate screen + cursor movement and validate snapshot round-trip. + +### Milestone 4: Electron main integration (client + TRPC compatibility) + +Goal: keep the renderer’s TRPC interface mostly unchanged, but route terminal operations through the daemon instead of owning PTYs in-process. + +Work to do: + +1. Add a `TerminalHostClient` in main: + - `apps/desktop/src/main/lib/terminal-host/client.ts` + - Responsibilities: + - Ensure daemon is running (start if not). + - Maintain a connection pool (or single connection) and reconnect logic. + - Expose typed methods: `createOrAttach`, `write`, `resize`, `detach`, `kill`, `clearScrollback`, `subscribe`. +2. Start/ensure daemon: + - Spawn detached `process.execPath` with `ELECTRON_RUN_AS_NODE=1` and script path pointing at `dist/main/terminal-host.js`. + - In dev, use the built script path in the workspace; in prod, resolve via `app.getAppPath()` + `dist/main/terminal-host.js` equivalent. +3. Preserve `terminalManager` interface: + - Refactor `apps/desktop/src/main/lib/terminal/manager.ts` into a thin adapter that: + - keeps the existing EventEmitter (`data:`, `exit:`) + - delegates operations to `TerminalHostClient` + - no longer spawns `node-pty` directly (that code moves into daemon). +4. Update TRPC router: + - `apps/desktop/src/lib/trpc/routers/terminal/terminal.ts` should continue to work with the same calls, but `createOrAttach` must return the daemon snapshot payload. + - Add a backwards-compatible response shape by adding optional fields rather than breaking existing ones, then migrate renderer. + +Exit criteria / proof: + +- `bun dev` for Desktop works; opening a terminal shows output; basic typing works. + +### Milestone 5: Renderer rehydration path (snapshot + mode restore + streaming) + +Goal: on attach, the renderer restores a perfect terminal state before streaming live output. + +Work to do: + +1. Update `apps/desktop/src/renderer/.../Terminal/Terminal.tsx`: + - Replace “write `result.scrollback`” with: + - apply `result.rehydrateSequences` first (these are control sequences that update xterm mode state) + - apply `result.snapshotAnsi` next + - only then enable subscription consumption (`subscriptionEnabled = true`) and flush queued events. +2. Ensure user input is sent unchanged: + - Keep using `xterm.onData` and send to backend via TRPC `write`. + - This includes query responses; daemon must ignore responses while attached (per Milestone 3). +3. Handle resize: + - On resize, send `resize` to daemon; daemon resizes PTY and also updates emulator dimensions. +4. Recovery UI: + - If attach fails due to daemon mismatch or missing session, show a small UI affordance: + - “Session ended” (if PTY exited) + - “Restart terminal” (creates new session) + +Exit criteria / proof: + +- Manual acceptance: pick a TUI, quit app, reopen, resume and immediately interact with correct behavior. + +### Milestone 6: Persistence setting + quit/update behavior + “stop daemon” control + +Goal: make persistence user-controlled, safe by default, and compatible with auto-update install flow. + +Work to do: + +1. Local DB settings: + - Add to local DB schema (`packages/local-db/src/schema/schema.ts`): + - `terminalPersistenceEnabled` boolean (default: false) + - `terminalScrollbackLines` integer (default: 10000, range: 1000–100000) + - `terminalDiskBufferMb` integer (default: 4, range: 1–32) + - Expose via settings TRPC router (`apps/desktop/src/lib/trpc/routers/settings/index.ts`) with optimistic UI patterns consistent with existing settings. +2. Behavior settings UI: + - Add under behavior settings in the renderer: + - Toggle: "Enable terminal persistence" (default off) — Keep terminal sessions alive when Superset is closed + - Number input: "Scrollback lines" (default 10000) — Lines of history kept per terminal + - Number input: "Disk buffer per terminal" (default 4 MB) — Output captured while app is closed + - Add an explicit button: "Stop background terminal sessions": + - Calls daemon `killAll` and stops daemon (or marks it idle and allows exit). +3. App quit behavior: + - When persistence is enabled, do not kill sessions on quit. The app should simply detach/disconnect. + - When persistence is disabled, keep the current behavior (cleanup kills PTYs). +4. Auto-update install behavior: + - Ensure the “install update” path does not kill sessions even if it triggers a forced quit. + +Exit criteria / proof: + +- Toggle on → sessions survive quit/reopen. +- Toggle off → quitting kills sessions (existing behavior). +- Update install flow (manual) does not kill sessions. + +### Milestone 7: Hardening, tests, and future-proofing (Windows) + +Goal: reduce operational risk and lay groundwork for Windows. + +Work to do: + +1. Orphan cleanup: + - On app start, compare current panes (from app state) with daemon sessions; kill sessions not referenced after a grace period. +2. Crash recovery: + - If daemon crashes, main should detect and show “sessions lost; restart terminal” rather than hanging. +3. Protocol compatibility: + - Establish a stable protocol version (`protocolVersion: 1`) and enforce additive changes only. + - Add a compatibility test that simulates missing optional fields. +4. Windows groundwork (no implementation yet): + - Abstract socket path selection so future named pipe support can be plugged in without rewriting the daemon. + - Identify the Windows-specific risks (ConPTY differences, process detachment semantics) and document them in-code. + +Exit criteria / proof: + +- `cd apps/desktop && bun test` passes. +- Manual acceptance checklist completed and recorded in PR description (not in this ExecPlan). + +## Concrete Steps + +All commands are from repo root unless stated otherwise. + +1. Create work branch: + + - `cd /Users/andreasasprou/Documents/superset` + - `git checkout -b feat/terminal-host-daemon origin/main` + +2. Run Desktop tests while iterating: + + - `cd apps/desktop` + - `bun test` + + Expected: existing tests pass; new tests added by this plan should fail before their implementation and pass after. + +3. Run Desktop dev build: + + - `cd /Users/andreasasprou/Documents/superset` + - `bun dev` + + Expected: Electron app launches; terminals function. + +4. Manual persistence demo (post-implementation): + + - Enable persistence toggle in Settings → Behavior. + - Open a terminal pane and run one of the target AI agents: `opencode`, `claude`, or `codex`. + - Interact with the agent (start a conversation, let it generate code). + - Quit the app (Cmd+Q). + - Reopen the app and verify: + - Screen content matches pre-quit state exactly. + - Cursor is in correct position. + - Arrow keys work correctly (not printing escape codes). + - Can immediately continue interacting without redraw. + - While app is closed, optionally run a command that prints periodically (e.g. `watch date`) and confirm it progressed when reattached. + +## Validation and Acceptance + +Acceptance is met when all of the following are true: + +1. Persistence disabled (default): quitting Superset kills terminal sessions (current behavior). +2. Persistence enabled: terminal sessions survive app quit/reopen; output continues to be captured while app is closed. +3. Perfect TUI resume: the following AI coding agents resume with correct screen state and correct interactive input semantics immediately on reopen: + - **opencode** + - **claude code** (Anthropic's Claude CLI) + - **codex** (OpenAI Codex CLI) +4. Update survival: using the in-app update install flow does not kill persistent sessions; reopening the updated app can attach to existing sessions. +5. Automated tests exist for the headless snapshot round-trip and pass in CI-equivalent `bun test` runs. + +## Idempotence and Recovery + +This plan should be safe to apply incrementally: + +- Each milestone adds functionality behind stable interfaces and can be rerun. +- Socket + token files under `SUPERSET_HOME_DIR` must be created with safe permissions and should not be overwritten unexpectedly. If regeneration is needed (e.g. token compromised), provide an explicit “reset daemon” action and document it. +- If the daemon fails to start or protocol mismatch occurs, the app must fail gracefully: show a recoverable error and allow “Restart terminal” (non-persistent) rather than hanging. + +Rollback strategy (if needed): + +- Keep the old in-process `TerminalManager` path behind a feature flag during migration (temporary). +- If daemon integration is unstable, disable the persistence toggle and fall back to in-process PTY ownership. + +## Artifacts and Notes + +When implementing, capture short evidence snippets here (examples, not code fences): + +- Example of successful daemon handshake log output. +- Example of a snapshot payload size and attach timing. +- Example of a TUI resume manual checklist with timestamps. + +## Interfaces and Dependencies + +### New dependencies (Desktop app) + +In `apps/desktop/package.json`, add: + +- `@xterm/headless` (Node-only headless emulator in daemon) + +Reuse existing: + +- `@xterm/addon-serialize` (snapshot generation) +- `node-pty` (PTY spawning in daemon) + +### Required modules and types + +Create `apps/desktop/src/main/lib/terminal-host/types.ts` with stable protocol shapes: + + export interface TerminalHostHelloRequest { token: string; protocolVersion: 1 } + export interface TerminalHostHelloResponse { protocolVersion: 1; daemonVersion: string } + + export interface AttachResult { + snapshotAnsi: string; + rehydrateSequences: string; + cwd: string | null; + } + + export type TerminalHostRequest = + | { type: "hello"; payload: TerminalHostHelloRequest } + | { type: "createOrAttach"; payload: { sessionId: string; cols: number; rows: number; cwd?: string; env?: Record } } + | { type: "write"; payload: { sessionId: string; data: string } } + | { type: "resize"; payload: { sessionId: string; cols: number; rows: number } } + | { type: "detach"; payload: { sessionId: string } } + | { type: "kill"; payload: { sessionId: string } } + | { type: "killAll"; payload: {} }; + +Daemon must implement these and keep them backwards compatible (additive changes only). + +### Main process integration points + +Files that will change: + +- `apps/desktop/electron.vite.config.ts` (build daemon entry) +- `apps/desktop/src/main/index.ts` (quit behavior based on setting; ensure daemon survival on quit/update) +- `apps/desktop/src/main/lib/terminal/manager.ts` (delegate to daemon client) +- `apps/desktop/src/lib/trpc/routers/terminal/terminal.ts` (return snapshot payload; stream from daemon) +- `apps/desktop/src/renderer/.../Terminal/Terminal.tsx` (apply snapshot/rehydrate) +- `packages/local-db/src/schema/schema.ts` and migrations (new setting) +- `apps/desktop/src/lib/trpc/routers/settings/index.ts` + renderer settings UI (toggle + “stop daemon”) + +Windows future: + +- Design IPC so it can swap UDS for named pipes without changing higher-level interfaces. + diff --git a/apps/desktop/electron.vite.config.ts b/apps/desktop/electron.vite.config.ts index 2ce99bdabed..64a0e3801e7 100644 --- a/apps/desktop/electron.vite.config.ts +++ b/apps/desktop/electron.vite.config.ts @@ -98,12 +98,17 @@ export default defineConfig({ "process.env.NEXT_PUBLIC_POSTHOG_HOST": JSON.stringify( process.env.NEXT_PUBLIC_POSTHOG_HOST, ), + // Terminal daemon mode - for terminal session persistence + "process.env.SUPERSET_TERMINAL_DAEMON": JSON.stringify( + process.env.SUPERSET_TERMINAL_DAEMON || "", + ), }, build: { rollupOptions: { input: { index: resolve("src/main/index.ts"), + "terminal-host": resolve("src/main/terminal-host/index.ts"), }, output: { dir: resolve(devPath, "main"), diff --git a/apps/desktop/package.json b/apps/desktop/package.json index 978a383ab50..8975c374a69 100644 --- a/apps/desktop/package.json +++ b/apps/desktop/package.json @@ -64,6 +64,7 @@ "@xterm/addon-unicode11": "^0.8.0", "@xterm/addon-web-links": "^0.11.0", "@xterm/addon-webgl": "^0.18.0", + "@xterm/headless": "^5.5.0", "@xterm/xterm": "^5.5.0", "better-sqlite3": "12.5.0", "bindings": "^1.5.0", diff --git a/apps/desktop/src/lib/trpc/routers/terminal/terminal.ts b/apps/desktop/src/lib/trpc/routers/terminal/terminal.ts index 725c4592d80..fb783f42caa 100644 --- a/apps/desktop/src/lib/trpc/routers/terminal/terminal.ts +++ b/apps/desktop/src/lib/trpc/routers/terminal/terminal.ts @@ -4,7 +4,7 @@ import { projects, workspaces, worktrees } from "@superset/local-db"; import { observable } from "@trpc/server/observable"; import { eq } from "drizzle-orm"; import { localDb } from "main/lib/local-db"; -import { terminalManager } from "main/lib/terminal"; +import { getActiveTerminalManager } from "main/lib/terminal"; import { z } from "zod"; import { publicProcedure, router } from "../.."; import { getWorkspacePath } from "../workspaces/utils/worktree"; @@ -25,6 +25,9 @@ import { resolveCwd } from "./utils"; * - SUPERSET_PORT: The hooks server port for agent completion notifications */ export const createTerminalRouter = () => { + // Get the active terminal manager (in-process or daemon-based) + const terminalManager = getActiveTerminalManager(); + return router({ createOrAttach: publicProcedure .input( @@ -87,6 +90,8 @@ export const createTerminalRouter = () => { isNew: result.isNew, scrollback: result.scrollback, wasRecovered: result.wasRecovered, + // Include snapshot for daemon mode (renderer can use for rehydration) + snapshot: result.snapshot, }; }), diff --git a/apps/desktop/src/main/lib/terminal-host/client.ts b/apps/desktop/src/main/lib/terminal-host/client.ts new file mode 100644 index 00000000000..5407a385d72 --- /dev/null +++ b/apps/desktop/src/main/lib/terminal-host/client.ts @@ -0,0 +1,611 @@ +/** + * Terminal Host Daemon Client + * + * Client library for the Electron main process to communicate with + * the terminal host daemon. Handles: + * - Daemon lifecycle (spawning if not running) + * - Socket connection and reconnection + * - Request/response framing + * - Event streaming + */ + +import { spawn } from "node:child_process"; +import { EventEmitter } from "node:events"; +import { existsSync, readFileSync, unlinkSync } from "node:fs"; +import { connect, type Socket } from "node:net"; +import { homedir } from "node:os"; +import { join } from "node:path"; +import { app } from "electron"; +import { + type ClearScrollbackRequest, + type CreateOrAttachRequest, + type CreateOrAttachResponse, + type DetachRequest, + type EmptyResponse, + type HelloResponse, + type IpcErrorResponse, + type IpcEvent, + type IpcResponse, + type IpcSuccessResponse, + type KillAllRequest, + type KillRequest, + type ListSessionsResponse, + PROTOCOL_VERSION, + type ResizeRequest, + type TerminalDataEvent, + type TerminalExitEvent, + type WriteRequest, +} from "./types"; + +// ============================================================================= +// Configuration +// ============================================================================= + +const SUPERSET_DIR_NAME = + process.env.NODE_ENV === "development" ? ".superset-dev" : ".superset"; +const SUPERSET_HOME_DIR = join(homedir(), SUPERSET_DIR_NAME); + +const SOCKET_PATH = join(SUPERSET_HOME_DIR, "terminal-host.sock"); +const TOKEN_PATH = join(SUPERSET_HOME_DIR, "terminal-host.token"); +const PID_PATH = join(SUPERSET_HOME_DIR, "terminal-host.pid"); + +// Connection timeouts +const CONNECT_TIMEOUT_MS = 5000; +const SPAWN_WAIT_MS = 2000; +const REQUEST_TIMEOUT_MS = 30000; + +// ============================================================================= +// NDJSON Parser +// ============================================================================= + +class NdjsonParser { + private buffer = ""; + + parse(chunk: string): Array { + this.buffer += chunk; + const messages: Array = []; + + let newlineIndex = this.buffer.indexOf("\n"); + while (newlineIndex !== -1) { + const line = this.buffer.slice(0, newlineIndex); + this.buffer = this.buffer.slice(newlineIndex + 1); + + if (line.trim()) { + try { + messages.push(JSON.parse(line)); + } catch { + console.warn("[TerminalHostClient] Failed to parse NDJSON line"); + } + } + + newlineIndex = this.buffer.indexOf("\n"); + } + + return messages; + } +} + +// ============================================================================= +// Pending Request Tracker +// ============================================================================= + +interface PendingRequest { + resolve: (value: unknown) => void; + reject: (error: Error) => void; + timeoutId: NodeJS.Timeout; +} + +// ============================================================================= +// TerminalHostClient +// ============================================================================= + +export interface TerminalHostClientEvents { + data: (sessionId: string, data: string) => void; + exit: (sessionId: string, exitCode: number, signal?: number) => void; + connected: () => void; + disconnected: () => void; + error: (error: Error) => void; +} + +/** + * Client for communicating with the terminal host daemon. + * Emits events for terminal data and exit. + */ +export class TerminalHostClient extends EventEmitter { + private socket: Socket | null = null; + private parser = new NdjsonParser(); + private pendingRequests = new Map(); + private requestCounter = 0; + private authenticated = false; + private connecting = false; + private disposed = false; + + // =========================================================================== + // Connection Management + // =========================================================================== + + /** + * Ensure we have a connected, authenticated socket. + * Spawns daemon if needed. + */ + async ensureConnected(): Promise { + if (this.socket && this.authenticated) { + console.log("[TerminalHostClient] Already connected and authenticated"); + return; + } + + if (this.connecting) { + console.log( + "[TerminalHostClient] Connection already in progress, waiting...", + ); + // Wait for existing connection attempt + return new Promise((resolve, reject) => { + const checkConnection = () => { + if (this.socket && this.authenticated) { + resolve(); + } else if (!this.connecting) { + reject(new Error("Connection failed")); + } else { + setTimeout(checkConnection, 100); + } + }; + checkConnection(); + }); + } + + this.connecting = true; + console.log("[TerminalHostClient] Connecting to daemon..."); + + try { + // Try to connect to existing daemon + let connected = await this.tryConnect(); + console.log( + `[TerminalHostClient] Initial connection attempt: ${connected ? "SUCCESS" : "FAILED"}`, + ); + + if (!connected) { + // Spawn daemon and retry + console.log("[TerminalHostClient] Spawning daemon..."); + await this.spawnDaemon(); + connected = await this.tryConnect(); + console.log( + `[TerminalHostClient] Post-spawn connection attempt: ${connected ? "SUCCESS" : "FAILED"}`, + ); + + if (!connected) { + throw new Error("Failed to connect to daemon after spawn"); + } + } + + // Authenticate + console.log("[TerminalHostClient] Authenticating..."); + await this.authenticate(); + console.log("[TerminalHostClient] Authentication successful!"); + } finally { + this.connecting = false; + } + } + + /** + * Try to connect to the daemon socket. + * Returns true if connected, false if daemon not running. + */ + private async tryConnect(): Promise { + return new Promise((resolve) => { + if (!existsSync(SOCKET_PATH)) { + resolve(false); + return; + } + + const socket = connect(SOCKET_PATH); + let resolved = false; + + const timeout = setTimeout(() => { + if (!resolved) { + resolved = true; + socket.destroy(); + resolve(false); + } + }, CONNECT_TIMEOUT_MS); + + socket.on("connect", () => { + if (!resolved) { + resolved = true; + clearTimeout(timeout); + this.socket = socket; + this.setupSocketHandlers(); + resolve(true); + } + }); + + socket.on("error", () => { + if (!resolved) { + resolved = true; + clearTimeout(timeout); + resolve(false); + } + }); + }); + } + + /** + * Set up socket event handlers + */ + private setupSocketHandlers(): void { + if (!this.socket) return; + + this.socket.setEncoding("utf-8"); + + this.socket.on("data", (data: string) => { + const messages = this.parser.parse(data); + for (const message of messages) { + this.handleMessage(message); + } + }); + + this.socket.on("close", () => { + this.handleDisconnect(); + }); + + this.socket.on("error", (error) => { + this.emit("error", error); + this.handleDisconnect(); + }); + } + + /** + * Handle incoming message (response or event) + */ + private handleMessage(message: IpcResponse | IpcEvent): void { + if ("id" in message) { + // Response to a request + const pending = this.pendingRequests.get(message.id); + if (pending) { + this.pendingRequests.delete(message.id); + clearTimeout(pending.timeoutId); + + if (message.ok) { + pending.resolve((message as IpcSuccessResponse).payload); + } else { + const error = (message as IpcErrorResponse).error; + pending.reject(new Error(`${error.code}: ${error.message}`)); + } + } + } else if (message.type === "event") { + // Event from daemon + const event = message as IpcEvent; + const payload = event.payload as TerminalDataEvent | TerminalExitEvent; + + if (payload.type === "data") { + this.emit("data", event.sessionId, (payload as TerminalDataEvent).data); + } else if (payload.type === "exit") { + const exitPayload = payload as TerminalExitEvent; + this.emit( + "exit", + event.sessionId, + exitPayload.exitCode, + exitPayload.signal, + ); + } + } + } + + /** + * Handle socket disconnect + */ + private handleDisconnect(): void { + this.socket = null; + this.authenticated = false; + + // Reject all pending requests + for (const [id, pending] of this.pendingRequests.entries()) { + clearTimeout(pending.timeoutId); + pending.reject(new Error("Connection lost")); + this.pendingRequests.delete(id); + } + + this.emit("disconnected"); + } + + /** + * Authenticate with the daemon + */ + private async authenticate(): Promise { + if (!existsSync(TOKEN_PATH)) { + throw new Error("Auth token not found - daemon may not be running"); + } + + const token = readFileSync(TOKEN_PATH, "utf-8").trim(); + + const response = (await this.sendRequest("hello", { + token, + protocolVersion: PROTOCOL_VERSION, + })) as HelloResponse; + + if (response.protocolVersion !== PROTOCOL_VERSION) { + throw new Error( + `Protocol version mismatch: client=${PROTOCOL_VERSION}, daemon=${response.protocolVersion}`, + ); + } + + this.authenticated = true; + this.emit("connected"); + } + + // =========================================================================== + // Daemon Spawning + // =========================================================================== + + /** + * Spawn the daemon process if not running + */ + private async spawnDaemon(): Promise { + // Check if daemon is already running via PID file + if (this.isDaemonRunning()) { + console.log( + "[TerminalHostClient] Daemon already running (PID file exists)", + ); + // Daemon is running but socket might be stale + // Give it a moment and return + await this.sleep(500); + return; + } + + // Clean up stale socket file if it exists + if (existsSync(SOCKET_PATH)) { + console.log("[TerminalHostClient] Removing stale socket file"); + try { + unlinkSync(SOCKET_PATH); + } catch { + // Ignore - might not have permission + } + } + + // Get path to daemon script + const daemonScript = this.getDaemonScriptPath(); + console.log(`[TerminalHostClient] Daemon script path: ${daemonScript}`); + console.log( + `[TerminalHostClient] Script exists: ${existsSync(daemonScript)}`, + ); + + if (!existsSync(daemonScript)) { + throw new Error(`Daemon script not found: ${daemonScript}`); + } + + console.log( + `[TerminalHostClient] Spawning daemon with execPath: ${process.execPath}`, + ); + + // Spawn daemon as detached process + const child = spawn(process.execPath, [daemonScript], { + detached: true, + stdio: "ignore", + env: { + ...process.env, + ELECTRON_RUN_AS_NODE: "1", + NODE_ENV: process.env.NODE_ENV, + }, + }); + + console.log(`[TerminalHostClient] Daemon spawned with PID: ${child.pid}`); + + // Unref to allow parent to exit independently + child.unref(); + + // Wait for daemon to start + console.log("[TerminalHostClient] Waiting for daemon to start..."); + await this.waitForDaemon(); + console.log("[TerminalHostClient] Daemon started successfully"); + } + + /** + * Check if daemon process is running + */ + private isDaemonRunning(): boolean { + if (!existsSync(PID_PATH)) { + return false; + } + + try { + const pid = Number.parseInt(readFileSync(PID_PATH, "utf-8").trim(), 10); + // Check if process exists (kill with signal 0) + process.kill(pid, 0); + return true; + } catch { + // Process doesn't exist or no permission + return false; + } + } + + /** + * Get path to daemon script + */ + private getDaemonScriptPath(): string { + if (app.isPackaged) { + // Production: script is in app resources + return join(app.getAppPath(), "dist", "main", "terminal-host.js"); + } + + // Development: electron-vite outputs to dist/main/ + const appPath = app.getAppPath(); + return join(appPath, "dist", "main", "terminal-host.js"); + } + + /** + * Wait for daemon to be ready + */ + private async waitForDaemon(): Promise { + const startTime = Date.now(); + + while (Date.now() - startTime < SPAWN_WAIT_MS) { + if (existsSync(SOCKET_PATH)) { + // Give it a moment to start listening + await this.sleep(200); + return; + } + await this.sleep(100); + } + + throw new Error("Daemon failed to start in time"); + } + + private sleep(ms: number): Promise { + return new Promise((resolve) => setTimeout(resolve, ms)); + } + + // =========================================================================== + // Request/Response + // =========================================================================== + + /** + * Send a request to the daemon and wait for response + */ + private sendRequest(type: string, payload: unknown): Promise { + return new Promise((resolve, reject) => { + if (!this.socket) { + reject(new Error("Not connected")); + return; + } + + const id = `req_${++this.requestCounter}`; + + const timeoutId = setTimeout(() => { + this.pendingRequests.delete(id); + reject(new Error(`Request timeout: ${type}`)); + }, REQUEST_TIMEOUT_MS); + + this.pendingRequests.set(id, { resolve, reject, timeoutId }); + + const message = `${JSON.stringify({ id, type, payload })}\n`; + this.socket.write(message); + }); + } + + // =========================================================================== + // Public API + // =========================================================================== + + /** + * Create or attach to a terminal session + */ + async createOrAttach( + request: CreateOrAttachRequest, + ): Promise { + await this.ensureConnected(); + return (await this.sendRequest( + "createOrAttach", + request, + )) as CreateOrAttachResponse; + } + + /** + * Write data to a terminal session + */ + async write(request: WriteRequest): Promise { + await this.ensureConnected(); + return (await this.sendRequest("write", request)) as EmptyResponse; + } + + /** + * Resize a terminal session + */ + async resize(request: ResizeRequest): Promise { + await this.ensureConnected(); + return (await this.sendRequest("resize", request)) as EmptyResponse; + } + + /** + * Detach from a terminal session + */ + async detach(request: DetachRequest): Promise { + await this.ensureConnected(); + return (await this.sendRequest("detach", request)) as EmptyResponse; + } + + /** + * Kill a terminal session + */ + async kill(request: KillRequest): Promise { + await this.ensureConnected(); + return (await this.sendRequest("kill", request)) as EmptyResponse; + } + + /** + * Kill all terminal sessions + */ + async killAll(request: KillAllRequest): Promise { + await this.ensureConnected(); + return (await this.sendRequest("killAll", request)) as EmptyResponse; + } + + /** + * List all sessions + */ + async listSessions(): Promise { + await this.ensureConnected(); + return (await this.sendRequest( + "listSessions", + undefined, + )) as ListSessionsResponse; + } + + /** + * Clear scrollback for a session + */ + async clearScrollback( + request: ClearScrollbackRequest, + ): Promise { + await this.ensureConnected(); + return (await this.sendRequest( + "clearScrollback", + request, + )) as EmptyResponse; + } + + /** + * Disconnect from daemon (but don't stop it) + */ + disconnect(): void { + if (this.socket) { + this.socket.destroy(); + this.socket = null; + } + this.authenticated = false; + } + + /** + * Dispose of the client + */ + dispose(): void { + if (this.disposed) return; + this.disposed = true; + this.disconnect(); + this.removeAllListeners(); + } +} + +// ============================================================================= +// Singleton Instance +// ============================================================================= + +let clientInstance: TerminalHostClient | null = null; + +/** + * Get the singleton terminal host client instance + */ +export function getTerminalHostClient(): TerminalHostClient { + if (!clientInstance) { + clientInstance = new TerminalHostClient(); + } + return clientInstance; +} + +/** + * Dispose of the singleton client + */ +export function disposeTerminalHostClient(): void { + if (clientInstance) { + clientInstance.dispose(); + clientInstance = null; + } +} diff --git a/apps/desktop/src/main/lib/terminal-host/headless-emulator.ts b/apps/desktop/src/main/lib/terminal-host/headless-emulator.ts new file mode 100644 index 00000000000..d9f432b6b9d --- /dev/null +++ b/apps/desktop/src/main/lib/terminal-host/headless-emulator.ts @@ -0,0 +1,437 @@ +/** + * Headless Terminal Emulator + * + * Wraps @xterm/headless with: + * - Mode tracking (DECSET/DECRST parsing) + * - Snapshot generation via @xterm/addon-serialize + * - Rehydration sequence generation for mode restoration + */ + +import { SerializeAddon } from "@xterm/addon-serialize"; +import { Terminal } from "@xterm/headless"; +import { + DEFAULT_MODES, + type TerminalModes, + type TerminalSnapshot, +} from "./types"; + +// ============================================================================= +// Mode Tracking Constants +// ============================================================================= + +// Escape character +const ESC = "\x1b"; +const BEL = "\x07"; + +/** + * DECSET/DECRST mode numbers we track + */ +const MODE_MAP: Record = { + 1: "applicationCursorKeys", + 6: "originMode", + 7: "autoWrap", + 9: "mouseTrackingX10", + 25: "cursorVisible", + 47: "alternateScreen", // Legacy alternate screen + 1000: "mouseTrackingNormal", + 1001: "mouseTrackingHighlight", + 1002: "mouseTrackingButtonEvent", + 1003: "mouseTrackingAnyEvent", + 1004: "focusReporting", + 1005: "mouseUtf8", + 1006: "mouseSgr", + 1049: "alternateScreen", // Modern alternate screen with save/restore + 2004: "bracketedPaste", +}; + +// ============================================================================= +// Headless Emulator Class +// ============================================================================= + +export interface HeadlessEmulatorOptions { + cols?: number; + rows?: number; + scrollback?: number; +} + +export class HeadlessEmulator { + private terminal: Terminal; + private serializeAddon: SerializeAddon; + private modes: TerminalModes; + private cwd: string | null = null; + private disposed = false; + + // Pending output buffer for query responses + private pendingOutput: string[] = []; + private onDataCallback?: (data: string) => void; + + constructor(options: HeadlessEmulatorOptions = {}) { + const { cols = 80, rows = 24, scrollback = 10000 } = options; + + this.terminal = new Terminal({ + cols, + rows, + scrollback, + allowProposedApi: true, + }); + + this.serializeAddon = new SerializeAddon(); + this.terminal.loadAddon(this.serializeAddon); + + // Initialize mode state + this.modes = { ...DEFAULT_MODES }; + + // Listen for terminal output (query responses) + this.terminal.onData((data) => { + this.pendingOutput.push(data); + this.onDataCallback?.(data); + }); + } + + /** + * Set callback for terminal-generated output (query responses) + */ + onData(callback: (data: string) => void): void { + this.onDataCallback = callback; + } + + /** + * Get and clear pending output (query responses) + */ + flushPendingOutput(): string[] { + const output = this.pendingOutput; + this.pendingOutput = []; + return output; + } + + /** + * Write data to the terminal emulator (synchronous, non-blocking) + * Data is buffered and will be processed asynchronously. + * Use writeSync() if you need to wait for the write to complete. + */ + write(data: string): void { + if (this.disposed) return; + + // Parse for mode changes before writing to terminal + this.parseModeChanges(data); + + // Parse for OSC-7 (CWD) sequences + this.parseOsc7(data); + + // Write to headless terminal (buffered/async) + this.terminal.write(data); + } + + /** + * Write data to the terminal emulator and wait for completion. + * Use this when you need to ensure data is processed before reading state. + */ + async writeSync(data: string): Promise { + if (this.disposed) return; + + // Parse for mode changes before writing to terminal + this.parseModeChanges(data); + + // Parse for OSC-7 (CWD) sequences + this.parseOsc7(data); + + // Write to headless terminal and wait for completion + return new Promise((resolve) => { + this.terminal.write(data, () => resolve()); + }); + } + + /** + * Resize the terminal + */ + resize(cols: number, rows: number): void { + if (this.disposed) return; + this.terminal.resize(cols, rows); + } + + /** + * Get current terminal dimensions + */ + getDimensions(): { cols: number; rows: number } { + return { + cols: this.terminal.cols, + rows: this.terminal.rows, + }; + } + + /** + * Get current terminal modes + */ + getModes(): TerminalModes { + return { ...this.modes }; + } + + /** + * Get current working directory (from OSC-7) + */ + getCwd(): string | null { + return this.cwd; + } + + /** + * Set CWD directly (for initial session setup) + */ + setCwd(cwd: string): void { + this.cwd = cwd; + } + + /** + * Get scrollback line count + */ + getScrollbackLines(): number { + return this.terminal.buffer.active.length; + } + + /** + * Flush all pending writes to the terminal. + * Call this before getSnapshot() if you've written data without waiting. + */ + async flush(): Promise { + if (this.disposed) return; + // Write an empty string with callback to ensure all pending writes are processed + return new Promise((resolve) => { + this.terminal.write("", () => resolve()); + }); + } + + /** + * Generate a complete snapshot for session restore. + * Note: Call flush() first if you have pending async writes. + */ + getSnapshot(): TerminalSnapshot { + const snapshotAnsi = this.serializeAddon.serialize({ + scrollback: this.terminal.options.scrollback ?? 10000, + }); + + const rehydrateSequences = this.generateRehydrateSequences(); + + return { + snapshotAnsi, + rehydrateSequences, + cwd: this.cwd, + modes: { ...this.modes }, + cols: this.terminal.cols, + rows: this.terminal.rows, + scrollbackLines: this.getScrollbackLines(), + }; + } + + /** + * Generate a complete snapshot after flushing pending writes. + * This is the preferred method for getting consistent snapshots. + */ + async getSnapshotAsync(): Promise { + await this.flush(); + return this.getSnapshot(); + } + + /** + * Clear terminal buffer + */ + clear(): void { + if (this.disposed) return; + this.terminal.clear(); + } + + /** + * Reset terminal to default state + */ + reset(): void { + if (this.disposed) return; + this.terminal.reset(); + this.modes = { ...DEFAULT_MODES }; + } + + /** + * Dispose of the terminal + */ + dispose(): void { + if (this.disposed) return; + this.disposed = true; + this.terminal.dispose(); + } + + // =========================================================================== + // Private Methods + // =========================================================================== + + /** + * Parse DECSET/DECRST sequences from terminal data + */ + private parseModeChanges(data: string): void { + // Match CSI ? Pm h (DECSET) and CSI ? Pm l (DECRST) + // Examples: ESC[?1h (enable app cursor), ESC[?2004l (disable bracketed paste) + // Also handles multiple modes: ESC[?1;2004h + // Using string-based regex to avoid control character linter errors + const modeRegex = new RegExp( + `${escapeRegex(ESC)}\\[\\?([0-9;]+)([hl])`, + "g", + ); + + for (const match of data.matchAll(modeRegex)) { + const modesStr = match[1]; + const action = match[2]; // 'h' = set (enable), 'l' = reset (disable) + const enable = action === "h"; + + // Split on semicolons for multiple modes + const modeNumbers = modesStr + .split(";") + .map((s) => Number.parseInt(s, 10)); + + for (const modeNum of modeNumbers) { + const modeName = MODE_MAP[modeNum]; + if (modeName) { + // For cursor visibility and auto-wrap, 'h' means true, 'l' means false + // But their defaults are different (cursorVisible=true, autoWrap=true) + this.modes[modeName] = enable; + } + } + } + } + + /** + * Parse OSC-7 sequences for CWD tracking + * Format: ESC]7;file://hostname/path BEL or ESC]7;file://hostname/path ESC\ + * + * The path part starts after the hostname (after file://hostname). + * Hostname can be empty, localhost, or a machine name. + */ + private parseOsc7(data: string): void { + // OSC-7 format: \x1b]7;file://hostname/path\x07 + // We need to extract the /path portion after the hostname + // Hostname ends at the first / after file:// + + // Pattern explanation: + // - ESC ]7;file:// - the OSC-7 prefix + // - [^/]* - the hostname (anything that's not a slash) + // - (/.+?) - capture the path (starts with /, non-greedy) + // - (?:BEL|ESC\\) - terminated by BEL or ST + + // Using string building to avoid control character linter issues + const escEscaped = escapeRegex(ESC); + const belEscaped = escapeRegex(BEL); + + // Match OSC-7 with either terminator + const osc7Pattern = `${escEscaped}\\]7;file://[^/]*(/.+?)(?:${belEscaped}|${escEscaped}\\\\)`; + const osc7Regex = new RegExp(osc7Pattern, "g"); + + for (const match of data.matchAll(osc7Regex)) { + if (match[1]) { + try { + this.cwd = decodeURIComponent(match[1]); + } catch { + // If decoding fails, use the raw path + this.cwd = match[1]; + } + } + } + } + + /** + * Generate escape sequences to restore current mode state + * These sequences should be written to a fresh xterm instance before + * writing the snapshot to ensure input behavior matches. + */ + private generateRehydrateSequences(): string { + const sequences: string[] = []; + + // Helper to add DECSET/DECRST sequence + const addModeSequence = ( + modeNum: number, + enabled: boolean, + defaultEnabled: boolean, + ) => { + // Only add sequence if different from default + if (enabled !== defaultEnabled) { + sequences.push(`${ESC}[?${modeNum}${enabled ? "h" : "l"}`); + } + }; + + // Application cursor keys (mode 1) + addModeSequence(1, this.modes.applicationCursorKeys, false); + + // Origin mode (mode 6) + addModeSequence(6, this.modes.originMode, false); + + // Auto-wrap mode (mode 7) + addModeSequence(7, this.modes.autoWrap, true); + + // Cursor visibility (mode 25) + addModeSequence(25, this.modes.cursorVisible, true); + + // Mouse tracking modes (mutually exclusive typically, but we track all) + addModeSequence(9, this.modes.mouseTrackingX10, false); + addModeSequence(1000, this.modes.mouseTrackingNormal, false); + addModeSequence(1001, this.modes.mouseTrackingHighlight, false); + addModeSequence(1002, this.modes.mouseTrackingButtonEvent, false); + addModeSequence(1003, this.modes.mouseTrackingAnyEvent, false); + + // Mouse encoding modes + addModeSequence(1005, this.modes.mouseUtf8, false); + addModeSequence(1006, this.modes.mouseSgr, false); + + // Focus reporting (mode 1004) + addModeSequence(1004, this.modes.focusReporting, false); + + // Bracketed paste (mode 2004) + addModeSequence(2004, this.modes.bracketedPaste, false); + + // Note: We don't restore alternate screen mode (1049/47) here because + // the serialized snapshot already contains the correct screen buffer. + // Restoring it would cause incorrect behavior. + + return sequences.join(""); + } +} + +// ============================================================================= +// Utility Functions +// ============================================================================= + +/** + * Escape special regex characters in a string + */ +function escapeRegex(str: string): string { + return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); +} + +/** + * Apply a snapshot to a headless emulator (for testing round-trip) + */ +export function applySnapshot( + emulator: HeadlessEmulator, + snapshot: TerminalSnapshot, +): void { + // First, write the rehydrate sequences to restore mode state + emulator.write(snapshot.rehydrateSequences); + + // Then write the serialized screen content + emulator.write(snapshot.snapshotAnsi); +} + +/** + * Compare two mode states for equality + */ +export function modesEqual(a: TerminalModes, b: TerminalModes): boolean { + return ( + a.applicationCursorKeys === b.applicationCursorKeys && + a.bracketedPaste === b.bracketedPaste && + a.mouseTrackingX10 === b.mouseTrackingX10 && + a.mouseTrackingNormal === b.mouseTrackingNormal && + a.mouseTrackingHighlight === b.mouseTrackingHighlight && + a.mouseTrackingButtonEvent === b.mouseTrackingButtonEvent && + a.mouseTrackingAnyEvent === b.mouseTrackingAnyEvent && + a.focusReporting === b.focusReporting && + a.mouseUtf8 === b.mouseUtf8 && + a.mouseSgr === b.mouseSgr && + a.alternateScreen === b.alternateScreen && + a.cursorVisible === b.cursorVisible && + a.originMode === b.originMode && + a.autoWrap === b.autoWrap + ); +} diff --git a/apps/desktop/src/main/lib/terminal-host/prototype/headless-roundtrip.test.ts b/apps/desktop/src/main/lib/terminal-host/prototype/headless-roundtrip.test.ts new file mode 100644 index 00000000000..c04e6a023f1 --- /dev/null +++ b/apps/desktop/src/main/lib/terminal-host/prototype/headless-roundtrip.test.ts @@ -0,0 +1,529 @@ +/** + * Headless Terminal Round-Trip Test + * + * This test proves that we can: + * 1. Feed terminal output into a headless emulator + * 2. Capture mode state changes (application cursor keys, bracketed paste, mouse tracking) + * 3. Serialize the terminal state + * 4. Apply that state to a fresh emulator + * 5. Verify the restored terminal has matching visual content and mode flags + * + * This is the foundational proof for "perfect resume" - the ability to restore + * terminal sessions across app restarts. + */ + +import { afterEach, beforeEach, describe, expect, test } from "bun:test"; +import { HeadlessEmulator, modesEqual } from "../headless-emulator"; +import { DEFAULT_MODES } from "../types"; + +// Escape sequences for testing +const ESC = "\x1b"; +const CSI = `${ESC}[`; +const OSC = `${ESC}]`; +const BEL = "\x07"; + +// Mode enable/disable sequences +const ENABLE_APP_CURSOR = `${CSI}?1h`; +const DISABLE_APP_CURSOR = `${CSI}?1l`; +const ENABLE_BRACKETED_PASTE = `${CSI}?2004h`; +const DISABLE_BRACKETED_PASTE = `${CSI}?2004l`; +const ENABLE_MOUSE_SGR = `${CSI}?1006h`; +const DISABLE_MOUSE_SGR = `${CSI}?1006l`; +const ENABLE_MOUSE_NORMAL = `${CSI}?1000h`; +const DISABLE_MOUSE_NORMAL = `${CSI}?1000l`; +const ENABLE_FOCUS_REPORTING = `${CSI}?1004h`; +const HIDE_CURSOR = `${CSI}?25l`; +const SHOW_CURSOR = `${CSI}?25h`; +const ENTER_ALT_SCREEN = `${CSI}?1049h`; +const EXIT_ALT_SCREEN = `${CSI}?1049l`; + +// Cursor movement +const MOVE_CURSOR = (row: number, col: number) => `${CSI}${row};${col}H`; +const CLEAR_SCREEN = `${CSI}2J`; + +// OSC-7 CWD reporting - format is file://hostname/path (path is NOT URL-encoded) +const OSC7_CWD = (path: string) => `${OSC}7;file://localhost${path}${BEL}`; + +describe("HeadlessEmulator", () => { + let emulator: HeadlessEmulator; + + beforeEach(() => { + emulator = new HeadlessEmulator({ cols: 80, rows: 24, scrollback: 1000 }); + }); + + afterEach(() => { + emulator.dispose(); + }); + + describe("basic functionality", () => { + test("should initialize with default modes", () => { + const modes = emulator.getModes(); + expect(modesEqual(modes, DEFAULT_MODES)).toBe(true); + }); + + test("should write text to terminal", async () => { + await emulator.writeSync("Hello, World!\r\n"); + const snapshot = emulator.getSnapshot(); + expect(snapshot.snapshotAnsi).toContain("Hello, World!"); + }); + + test("should track dimensions", () => { + const dims = emulator.getDimensions(); + expect(dims.cols).toBe(80); + expect(dims.rows).toBe(24); + }); + + test("should resize terminal", () => { + emulator.resize(120, 40); + const dims = emulator.getDimensions(); + expect(dims.cols).toBe(120); + expect(dims.rows).toBe(40); + }); + }); + + describe("mode tracking", () => { + test("should track application cursor keys mode", async () => { + expect(emulator.getModes().applicationCursorKeys).toBe(false); + + await emulator.writeSync(ENABLE_APP_CURSOR); + expect(emulator.getModes().applicationCursorKeys).toBe(true); + + await emulator.writeSync(DISABLE_APP_CURSOR); + expect(emulator.getModes().applicationCursorKeys).toBe(false); + }); + + test("should track bracketed paste mode", async () => { + expect(emulator.getModes().bracketedPaste).toBe(false); + + await emulator.writeSync(ENABLE_BRACKETED_PASTE); + expect(emulator.getModes().bracketedPaste).toBe(true); + + await emulator.writeSync(DISABLE_BRACKETED_PASTE); + expect(emulator.getModes().bracketedPaste).toBe(false); + }); + + test("should track mouse SGR mode", async () => { + expect(emulator.getModes().mouseSgr).toBe(false); + + await emulator.writeSync(ENABLE_MOUSE_SGR); + expect(emulator.getModes().mouseSgr).toBe(true); + + await emulator.writeSync(DISABLE_MOUSE_SGR); + expect(emulator.getModes().mouseSgr).toBe(false); + }); + + test("should track mouse normal tracking mode", async () => { + expect(emulator.getModes().mouseTrackingNormal).toBe(false); + + await emulator.writeSync(ENABLE_MOUSE_NORMAL); + expect(emulator.getModes().mouseTrackingNormal).toBe(true); + + await emulator.writeSync(DISABLE_MOUSE_NORMAL); + expect(emulator.getModes().mouseTrackingNormal).toBe(false); + }); + + test("should track focus reporting mode", async () => { + expect(emulator.getModes().focusReporting).toBe(false); + + await emulator.writeSync(ENABLE_FOCUS_REPORTING); + expect(emulator.getModes().focusReporting).toBe(true); + }); + + test("should track cursor visibility", async () => { + expect(emulator.getModes().cursorVisible).toBe(true); // Default is visible + + await emulator.writeSync(HIDE_CURSOR); + expect(emulator.getModes().cursorVisible).toBe(false); + + await emulator.writeSync(SHOW_CURSOR); + expect(emulator.getModes().cursorVisible).toBe(true); + }); + + test("should track alternate screen mode", async () => { + expect(emulator.getModes().alternateScreen).toBe(false); + + await emulator.writeSync(ENTER_ALT_SCREEN); + expect(emulator.getModes().alternateScreen).toBe(true); + + await emulator.writeSync(EXIT_ALT_SCREEN); + expect(emulator.getModes().alternateScreen).toBe(false); + }); + + test("should handle multiple modes in single sequence", async () => { + // Enable both app cursor and bracketed paste in one sequence + await emulator.writeSync(`${CSI}?1;2004h`); + + const modes = emulator.getModes(); + expect(modes.applicationCursorKeys).toBe(true); + expect(modes.bracketedPaste).toBe(true); + }); + }); + + describe("CWD tracking via OSC-7", () => { + test("should parse OSC-7 with BEL terminator", async () => { + expect(emulator.getCwd()).toBeNull(); + + await emulator.writeSync(OSC7_CWD("/Users/test/project")); + expect(emulator.getCwd()).toBe("/Users/test/project"); + }); + + test("should update CWD on directory change", async () => { + await emulator.writeSync(OSC7_CWD("/Users/test")); + expect(emulator.getCwd()).toBe("/Users/test"); + + await emulator.writeSync(OSC7_CWD("/Users/test/subdir")); + expect(emulator.getCwd()).toBe("/Users/test/subdir"); + }); + + test("should handle paths with spaces", async () => { + await emulator.writeSync(OSC7_CWD("/Users/test/my project")); + expect(emulator.getCwd()).toBe("/Users/test/my project"); + }); + }); + + describe("snapshot generation", () => { + test("should generate snapshot with screen content", async () => { + await emulator.writeSync("Line 1\r\nLine 2\r\nLine 3\r\n"); + + const snapshot = emulator.getSnapshot(); + + expect(snapshot.snapshotAnsi).toBeDefined(); + expect(snapshot.snapshotAnsi.length).toBeGreaterThan(0); + expect(snapshot.cols).toBe(80); + expect(snapshot.rows).toBe(24); + }); + + test("should include mode state in snapshot", async () => { + await emulator.writeSync(ENABLE_APP_CURSOR); + await emulator.writeSync(ENABLE_BRACKETED_PASTE); + await emulator.writeSync(ENABLE_MOUSE_SGR); + + const snapshot = emulator.getSnapshot(); + + expect(snapshot.modes.applicationCursorKeys).toBe(true); + expect(snapshot.modes.bracketedPaste).toBe(true); + expect(snapshot.modes.mouseSgr).toBe(true); + }); + + test("should include CWD in snapshot", async () => { + await emulator.writeSync(OSC7_CWD("/home/user/workspace")); + + const snapshot = emulator.getSnapshot(); + + expect(snapshot.cwd).toBe("/home/user/workspace"); + }); + + test("should generate rehydrate sequences for non-default modes", async () => { + await emulator.writeSync(ENABLE_APP_CURSOR); + await emulator.writeSync(ENABLE_BRACKETED_PASTE); + + const snapshot = emulator.getSnapshot(); + + // Rehydrate sequences should contain mode-setting escapes + expect(snapshot.rehydrateSequences).toContain("?1h"); // app cursor + expect(snapshot.rehydrateSequences).toContain("?2004h"); // bracketed paste + }); + + test("should not generate rehydrate sequences for default modes", async () => { + // Don't change any modes - use defaults + await emulator.writeSync("Some text\r\n"); + + const snapshot = emulator.getSnapshot(); + + // Should have empty or minimal rehydrate sequences + expect(snapshot.rehydrateSequences).toBe(""); + }); + }); +}); + +describe("Snapshot Round-Trip", () => { + test("should restore simple text content", async () => { + const source = new HeadlessEmulator({ cols: 80, rows: 24 }); + const target = new HeadlessEmulator({ cols: 80, rows: 24 }); + + try { + // Write content to source + await source.writeSync("Hello, World!\r\n"); + await source.writeSync("This is line 2\r\n"); + await source.writeSync("And line 3\r\n"); + + // Get snapshot and apply to target + const snapshot = source.getSnapshot(); + await target.writeSync(snapshot.rehydrateSequences); + await target.writeSync(snapshot.snapshotAnsi); + + // Verify content matches + const targetSnapshot = target.getSnapshot(); + expect(targetSnapshot.snapshotAnsi).toContain("Hello, World!"); + expect(targetSnapshot.snapshotAnsi).toContain("This is line 2"); + expect(targetSnapshot.snapshotAnsi).toContain("And line 3"); + } finally { + source.dispose(); + target.dispose(); + } + }); + + test("should restore mode state", async () => { + const source = new HeadlessEmulator({ cols: 80, rows: 24 }); + const target = new HeadlessEmulator({ cols: 80, rows: 24 }); + + try { + // Set up modes in source + await source.writeSync(ENABLE_APP_CURSOR); + await source.writeSync(ENABLE_BRACKETED_PASTE); + await source.writeSync(ENABLE_MOUSE_NORMAL); + await source.writeSync(ENABLE_MOUSE_SGR); + + // Get snapshot + const snapshot = source.getSnapshot(); + + // Verify source modes + expect(snapshot.modes.applicationCursorKeys).toBe(true); + expect(snapshot.modes.bracketedPaste).toBe(true); + expect(snapshot.modes.mouseTrackingNormal).toBe(true); + expect(snapshot.modes.mouseSgr).toBe(true); + + // Apply snapshot to target using applySnapshot helper + await applySnapshotAsync(target, snapshot); + + // Verify target modes match + const targetModes = target.getModes(); + expect(targetModes.applicationCursorKeys).toBe(true); + expect(targetModes.bracketedPaste).toBe(true); + expect(targetModes.mouseTrackingNormal).toBe(true); + expect(targetModes.mouseSgr).toBe(true); + } finally { + source.dispose(); + target.dispose(); + } + }); + + test("should restore cursor position and screen state", async () => { + const source = new HeadlessEmulator({ cols: 80, rows: 24 }); + const target = new HeadlessEmulator({ cols: 80, rows: 24 }); + + try { + // Draw a simple screen with cursor at specific position + await source.writeSync(CLEAR_SCREEN); + await source.writeSync(MOVE_CURSOR(1, 1)); + await source.writeSync("Top left"); + await source.writeSync(MOVE_CURSOR(12, 40)); + await source.writeSync("Center"); + await source.writeSync(MOVE_CURSOR(24, 70)); + await source.writeSync("Bottom right"); + + // Get snapshot and apply + const snapshot = source.getSnapshot(); + await applySnapshotAsync(target, snapshot); + + // Verify screen content + const targetSnapshot = target.getSnapshot(); + expect(targetSnapshot.snapshotAnsi).toContain("Top left"); + expect(targetSnapshot.snapshotAnsi).toContain("Center"); + expect(targetSnapshot.snapshotAnsi).toContain("Bottom right"); + } finally { + source.dispose(); + target.dispose(); + } + }); + + test("should handle TUI-like screen with modes enabled", async () => { + const source = new HeadlessEmulator({ cols: 80, rows: 24 }); + const target = new HeadlessEmulator({ cols: 80, rows: 24 }); + + try { + // Simulate a TUI application setup (like vim, htop, etc.) + // Enter alternate screen + await source.writeSync(ENTER_ALT_SCREEN); + // Enable application cursor keys + await source.writeSync(ENABLE_APP_CURSOR); + // Enable bracketed paste + await source.writeSync(ENABLE_BRACKETED_PASTE); + // Enable mouse tracking with SGR encoding + await source.writeSync(ENABLE_MOUSE_NORMAL); + await source.writeSync(ENABLE_MOUSE_SGR); + // Hide cursor + await source.writeSync(HIDE_CURSOR); + // Clear and draw + await source.writeSync(CLEAR_SCREEN); + await source.writeSync(MOVE_CURSOR(1, 1)); + await source.writeSync("=== TUI Application ==="); + await source.writeSync(MOVE_CURSOR(3, 1)); + await source.writeSync("Press q to quit"); + await source.writeSync(MOVE_CURSOR(24, 1)); + await source.writeSync("[Status Bar]"); + + // Get snapshot + const snapshot = source.getSnapshot(); + + // Verify all modes are captured + expect(snapshot.modes.alternateScreen).toBe(true); + expect(snapshot.modes.applicationCursorKeys).toBe(true); + expect(snapshot.modes.bracketedPaste).toBe(true); + expect(snapshot.modes.mouseTrackingNormal).toBe(true); + expect(snapshot.modes.mouseSgr).toBe(true); + expect(snapshot.modes.cursorVisible).toBe(false); + + // Apply to target + await applySnapshotAsync(target, snapshot); + + // Verify target modes + const targetModes = target.getModes(); + expect(targetModes.applicationCursorKeys).toBe(true); + expect(targetModes.bracketedPaste).toBe(true); + expect(targetModes.mouseTrackingNormal).toBe(true); + expect(targetModes.mouseSgr).toBe(true); + expect(targetModes.cursorVisible).toBe(false); + + // Note: alternateScreen mode is handled by the snapshot itself, + // not by rehydrate sequences (since the serialized content already + // represents the correct screen buffer) + + // Verify content + const targetSnapshot = target.getSnapshot(); + expect(targetSnapshot.snapshotAnsi).toContain("TUI Application"); + expect(targetSnapshot.snapshotAnsi).toContain("Press q to quit"); + expect(targetSnapshot.snapshotAnsi).toContain("[Status Bar]"); + } finally { + source.dispose(); + target.dispose(); + } + }); + + test("should preserve scrollback content", async () => { + const source = new HeadlessEmulator({ + cols: 80, + rows: 5, + scrollback: 100, + }); + const target = new HeadlessEmulator({ + cols: 80, + rows: 5, + scrollback: 100, + }); + + try { + // Write many lines to create scrollback + for (let i = 1; i <= 20; i++) { + await source.writeSync(`Line ${i}\r\n`); + } + + const snapshot = source.getSnapshot(); + + // Verify scrollback is captured + expect(snapshot.scrollbackLines).toBeGreaterThan(5); + + // Apply to target + await applySnapshotAsync(target, snapshot); + + // Verify scrollback content is restored + const targetSnapshot = target.getSnapshot(); + expect(targetSnapshot.snapshotAnsi).toContain("Line 1"); + expect(targetSnapshot.snapshotAnsi).toContain("Line 10"); + expect(targetSnapshot.snapshotAnsi).toContain("Line 20"); + } finally { + source.dispose(); + target.dispose(); + } + }); +}); + +describe("Edge Cases", () => { + test("should handle rapid mode toggling", async () => { + const emulator = new HeadlessEmulator({ cols: 80, rows: 24 }); + + try { + // Rapidly toggle modes + for (let i = 0; i < 10; i++) { + await emulator.writeSync(ENABLE_APP_CURSOR); + await emulator.writeSync(DISABLE_APP_CURSOR); + await emulator.writeSync(ENABLE_BRACKETED_PASTE); + await emulator.writeSync(DISABLE_BRACKETED_PASTE); + } + + // Should end at default state + const modes = emulator.getModes(); + expect(modes.applicationCursorKeys).toBe(false); + expect(modes.bracketedPaste).toBe(false); + } finally { + emulator.dispose(); + } + }); + + test("should handle interleaved content and mode changes", async () => { + const emulator = new HeadlessEmulator({ cols: 80, rows: 24 }); + + try { + await emulator.writeSync("Before modes\r\n"); + await emulator.writeSync(ENABLE_APP_CURSOR); + await emulator.writeSync("After app cursor\r\n"); + await emulator.writeSync(ENABLE_BRACKETED_PASTE); + await emulator.writeSync("After bracketed paste\r\n"); + await emulator.writeSync(OSC7_CWD("/test/path")); + await emulator.writeSync("After CWD\r\n"); + + const snapshot = emulator.getSnapshot(); + + expect(snapshot.modes.applicationCursorKeys).toBe(true); + expect(snapshot.modes.bracketedPaste).toBe(true); + expect(snapshot.cwd).toBe("/test/path"); + expect(snapshot.snapshotAnsi).toContain("Before modes"); + expect(snapshot.snapshotAnsi).toContain("After CWD"); + } finally { + emulator.dispose(); + } + }); + + test("should handle empty terminal", async () => { + const emulator = new HeadlessEmulator({ cols: 80, rows: 24 }); + + try { + // Flush to ensure terminal is ready + await emulator.flush(); + const snapshot = emulator.getSnapshot(); + + expect(snapshot.cols).toBe(80); + expect(snapshot.rows).toBe(24); + expect(snapshot.cwd).toBeNull(); + expect(modesEqual(snapshot.modes, DEFAULT_MODES)).toBe(true); + } finally { + emulator.dispose(); + } + }); + + test("should handle resize during session", async () => { + const source = new HeadlessEmulator({ cols: 80, rows: 24 }); + const target = new HeadlessEmulator({ cols: 80, rows: 24 }); + + try { + await source.writeSync("Initial content\r\n"); + source.resize(120, 40); + await source.writeSync("After resize\r\n"); + + const snapshot = source.getSnapshot(); + + expect(snapshot.cols).toBe(120); + expect(snapshot.rows).toBe(40); + + // Resize target to match before applying + target.resize(120, 40); + await applySnapshotAsync(target, snapshot); + + const targetSnapshot = target.getSnapshot(); + expect(targetSnapshot.snapshotAnsi).toContain("Initial content"); + expect(targetSnapshot.snapshotAnsi).toContain("After resize"); + } finally { + source.dispose(); + target.dispose(); + } + }); +}); + +// Helper function to apply snapshot asynchronously +async function applySnapshotAsync( + emulator: HeadlessEmulator, + snapshot: { rehydrateSequences: string; snapshotAnsi: string }, +): Promise { + await emulator.writeSync(snapshot.rehydrateSequences); + await emulator.writeSync(snapshot.snapshotAnsi); +} diff --git a/apps/desktop/src/main/lib/terminal-host/types.ts b/apps/desktop/src/main/lib/terminal-host/types.ts new file mode 100644 index 00000000000..7ee82f8d96a --- /dev/null +++ b/apps/desktop/src/main/lib/terminal-host/types.ts @@ -0,0 +1,303 @@ +/** + * Terminal Host Daemon Protocol Types + * + * This file defines the IPC protocol between the Electron main process + * and the terminal host daemon. Changes must be additive-only for + * backwards compatibility. + */ + +// Protocol version - increment for breaking changes +export const PROTOCOL_VERSION = 1; + +// ============================================================================= +// Mode Tracking +// ============================================================================= + +/** + * Terminal modes that affect input behavior and must be restored on attach. + * These correspond to DECSET/DECRST (CSI ? Pm h/l) escape sequences. + */ +export interface TerminalModes { + /** DECCKM - Application cursor keys (mode 1) */ + applicationCursorKeys: boolean; + /** Bracketed paste mode (mode 2004) */ + bracketedPaste: boolean; + /** X10 mouse tracking (mode 9) */ + mouseTrackingX10: boolean; + /** Normal mouse tracking - button events (mode 1000) */ + mouseTrackingNormal: boolean; + /** Highlight mouse tracking (mode 1001) */ + mouseTrackingHighlight: boolean; + /** Button-event mouse tracking (mode 1002) */ + mouseTrackingButtonEvent: boolean; + /** Any-event mouse tracking (mode 1003) */ + mouseTrackingAnyEvent: boolean; + /** Focus reporting (mode 1004) */ + focusReporting: boolean; + /** UTF-8 mouse mode (mode 1005) */ + mouseUtf8: boolean; + /** SGR mouse mode (mode 1006) */ + mouseSgr: boolean; + /** Alternate screen buffer (mode 1049 or 47) */ + alternateScreen: boolean; + /** Cursor visibility (mode 25) */ + cursorVisible: boolean; + /** Origin mode (mode 6) */ + originMode: boolean; + /** Auto-wrap mode (mode 7) */ + autoWrap: boolean; +} + +/** + * Default terminal modes (standard terminal state) + */ +export const DEFAULT_MODES: TerminalModes = { + applicationCursorKeys: false, + bracketedPaste: false, + mouseTrackingX10: false, + mouseTrackingNormal: false, + mouseTrackingHighlight: false, + mouseTrackingButtonEvent: false, + mouseTrackingAnyEvent: false, + focusReporting: false, + mouseUtf8: false, + mouseSgr: false, + alternateScreen: false, + cursorVisible: true, + originMode: false, + autoWrap: true, +}; + +// ============================================================================= +// Snapshot Types +// ============================================================================= + +/** + * Snapshot payload returned when attaching to a session. + * Contains everything needed to restore terminal state in the renderer. + */ +export interface TerminalSnapshot { + /** Serialized screen state (ANSI sequences to reproduce screen) */ + snapshotAnsi: string; + /** Control sequences to restore input-affecting modes */ + rehydrateSequences: string; + /** Current working directory (from OSC-7, may be null) */ + cwd: string | null; + /** Current terminal modes */ + modes: TerminalModes; + /** Terminal dimensions */ + cols: number; + rows: number; + /** Scrollback line count */ + scrollbackLines: number; +} + +// ============================================================================= +// Session Types +// ============================================================================= + +/** + * Session metadata stored on disk + */ +export interface SessionMeta { + sessionId: string; + workspaceId: string; + paneId: string; + cwd: string; + cols: number; + rows: number; + createdAt: string; + lastAttachedAt: string; + shell: string; +} + +// ============================================================================= +// IPC Protocol Types +// ============================================================================= + +/** + * Hello request - initial handshake with daemon + */ +export interface HelloRequest { + token: string; + protocolVersion: number; +} + +export interface HelloResponse { + protocolVersion: number; + daemonVersion: string; + daemonPid: number; +} + +/** + * Create or attach to a terminal session + */ +export interface CreateOrAttachRequest { + sessionId: string; + cols: number; + rows: number; + cwd?: string; + env?: Record; + shell?: string; + workspaceId: string; + paneId: string; + tabId: string; + workspaceName?: string; + workspacePath?: string; + rootPath?: string; + initialCommands?: string[]; +} + +export interface CreateOrAttachResponse { + isNew: boolean; + snapshot: TerminalSnapshot; + wasRecovered: boolean; +} + +/** + * Write data to a terminal session + */ +export interface WriteRequest { + sessionId: string; + data: string; +} + +/** + * Resize terminal session + */ +export interface ResizeRequest { + sessionId: string; + cols: number; + rows: number; +} + +/** + * Detach from a terminal session (keep running) + */ +export interface DetachRequest { + sessionId: string; +} + +/** + * Kill a terminal session + */ +export interface KillRequest { + sessionId: string; + deleteHistory?: boolean; +} + +/** + * Kill all terminal sessions + */ +export interface KillAllRequest { + deleteHistory?: boolean; +} + +/** + * List all active sessions + */ +export interface ListSessionsResponse { + sessions: Array<{ + sessionId: string; + workspaceId: string; + paneId: string; + isAlive: boolean; + attachedClients: number; + }>; +} + +/** + * Clear scrollback for a session + */ +export interface ClearScrollbackRequest { + sessionId: string; +} + +// ============================================================================= +// IPC Message Framing +// ============================================================================= + +/** + * Request message format (client -> daemon) + */ +export interface IpcRequest { + id: string; + type: string; + payload: unknown; +} + +/** + * Success response format (daemon -> client) + */ +export interface IpcSuccessResponse { + id: string; + ok: true; + payload: unknown; +} + +/** + * Error response format (daemon -> client) + */ +export interface IpcErrorResponse { + id: string; + ok: false; + error: { + code: string; + message: string; + }; +} + +export type IpcResponse = IpcSuccessResponse | IpcErrorResponse; + +/** + * Event message format (daemon -> client, unsolicited) + */ +export interface IpcEvent { + type: "event"; + event: string; + sessionId: string; + payload: unknown; +} + +/** + * Terminal data event + */ +export interface TerminalDataEvent { + type: "data"; + data: string; +} + +/** + * Terminal exit event + */ +export interface TerminalExitEvent { + type: "exit"; + exitCode: number; + signal?: number; +} + +export type TerminalEvent = TerminalDataEvent | TerminalExitEvent; + +// ============================================================================= +// Request/Response Type Map +// ============================================================================= + +/** Empty response for operations that don't return data */ +export interface EmptyResponse { + success: true; +} + +export type RequestTypeMap = { + hello: { request: HelloRequest; response: HelloResponse }; + createOrAttach: { + request: CreateOrAttachRequest; + response: CreateOrAttachResponse; + }; + write: { request: WriteRequest; response: EmptyResponse }; + resize: { request: ResizeRequest; response: EmptyResponse }; + detach: { request: DetachRequest; response: EmptyResponse }; + kill: { request: KillRequest; response: EmptyResponse }; + killAll: { request: KillAllRequest; response: EmptyResponse }; + listSessions: { request: undefined; response: ListSessionsResponse }; + clearScrollback: { request: ClearScrollbackRequest; response: EmptyResponse }; +}; diff --git a/apps/desktop/src/main/lib/terminal/daemon-manager.ts b/apps/desktop/src/main/lib/terminal/daemon-manager.ts new file mode 100644 index 00000000000..a06c33945b4 --- /dev/null +++ b/apps/desktop/src/main/lib/terminal/daemon-manager.ts @@ -0,0 +1,446 @@ +/** + * Daemon-based Terminal Manager + * + * This version of TerminalManager delegates PTY operations to the + * terminal host daemon for persistence across app restarts. + * + * The daemon owns the PTYs and maintains terminal state. This manager + * maintains the same EventEmitter interface as the original for + * compatibility with existing TRPC router and renderer code. + */ + +import { EventEmitter } from "node:events"; +import { track } from "main/lib/analytics"; +import { + disposeTerminalHostClient, + getTerminalHostClient, + type TerminalHostClient, +} from "../terminal-host/client"; +import { buildTerminalEnv, getDefaultShell } from "./env"; +import { portManager } from "./port-manager"; +import type { CreateSessionParams, SessionResult } from "./types"; + +// ============================================================================= +// Types +// ============================================================================= + +interface SessionInfo { + paneId: string; + workspaceId: string; + isAlive: boolean; + lastActive: number; + cwd: string; +} + +// ============================================================================= +// DaemonTerminalManager +// ============================================================================= + +export class DaemonTerminalManager extends EventEmitter { + private client: TerminalHostClient; + private sessions = new Map(); + private pendingSessions = new Map>(); + + constructor() { + super(); + this.client = getTerminalHostClient(); + this.setupClientEventHandlers(); + } + + /** + * Set up event handlers to forward daemon events to local EventEmitter + */ + private setupClientEventHandlers(): void { + // Forward data events + this.client.on("data", (sessionId: string, data: string) => { + // The sessionId from daemon is the paneId + const paneId = sessionId; + + // Update session state + const session = this.sessions.get(paneId); + if (session) { + session.lastActive = Date.now(); + } + + // Scan for port patterns + const workspaceId = session?.workspaceId; + if (workspaceId) { + portManager.scanOutput(data, paneId, workspaceId); + } + + // Emit to listeners (TRPC router subscription) + this.emit(`data:${paneId}`, data); + }); + + // Forward exit events + this.client.on( + "exit", + (sessionId: string, exitCode: number, signal?: number) => { + const paneId = sessionId; + + // Update session state + const session = this.sessions.get(paneId); + if (session) { + session.isAlive = false; + } + + // Clean up detected ports + portManager.removePortsForPane(paneId); + + // Emit exit event + this.emit(`exit:${paneId}`, exitCode, signal); + + // Clean up session after delay + setTimeout(() => { + this.sessions.delete(paneId); + }, 5000); + }, + ); + + // Handle client disconnection + this.client.on("disconnected", () => { + console.warn("[DaemonTerminalManager] Disconnected from daemon"); + }); + + this.client.on("error", (error: Error) => { + console.error("[DaemonTerminalManager] Client error:", error.message); + }); + } + + // =========================================================================== + // Public API (matches original TerminalManager interface) + // =========================================================================== + + async createOrAttach(params: CreateSessionParams): Promise { + const { paneId } = params; + + // Deduplicate concurrent calls + const pending = this.pendingSessions.get(paneId); + if (pending) { + return pending; + } + + const creationPromise = this.doCreateOrAttach(params); + this.pendingSessions.set(paneId, creationPromise); + + try { + return await creationPromise; + } finally { + this.pendingSessions.delete(paneId); + } + } + + private async doCreateOrAttach( + params: CreateSessionParams, + ): Promise { + const { + paneId, + tabId, + workspaceId, + workspaceName, + workspacePath, + rootPath, + cwd, + cols = 80, + rows = 24, + initialCommands, + } = params; + + console.log( + `[DaemonTerminalManager] createOrAttach called for paneId: ${paneId}`, + ); + + // Build environment for the terminal + const shell = getDefaultShell(); + const env = buildTerminalEnv({ + shell, + paneId, + tabId, + workspaceId, + workspaceName, + workspacePath, + rootPath, + }); + + // Call daemon + console.log( + `[DaemonTerminalManager] Calling daemon createOrAttach with sessionId: ${paneId}`, + ); + const response = await this.client.createOrAttach({ + sessionId: paneId, // Use paneId as sessionId for simplicity + paneId, + tabId, + workspaceId, + workspaceName, + workspacePath, + rootPath, + cols, + rows, + cwd, + env, + shell, + initialCommands, + }); + + console.log( + `[DaemonTerminalManager] Daemon response: isNew=${response.isNew}, wasRecovered=${response.wasRecovered}`, + ); + + // Track session locally + this.sessions.set(paneId, { + paneId, + workspaceId, + isAlive: true, + lastActive: Date.now(), + cwd: response.snapshot.cwd || cwd || "", + }); + + // Track terminal opened + if (response.isNew) { + track("terminal_opened", { workspace_id: workspaceId, pane_id: paneId }); + } + + return { + isNew: response.isNew, + // For backwards compatibility, provide scrollback from snapshot + scrollback: response.snapshot.snapshotAnsi, + wasRecovered: response.wasRecovered, + snapshot: { + snapshotAnsi: response.snapshot.snapshotAnsi, + rehydrateSequences: response.snapshot.rehydrateSequences, + cwd: response.snapshot.cwd, + modes: response.snapshot.modes as unknown as Record, + cols: response.snapshot.cols, + rows: response.snapshot.rows, + scrollbackLines: response.snapshot.scrollbackLines, + }, + }; + } + + write(params: { paneId: string; data: string }): void { + const { paneId, data } = params; + + const session = this.sessions.get(paneId); + if (!session || !session.isAlive) { + throw new Error(`Terminal session ${paneId} not found or not alive`); + } + + // Fire and forget - daemon will handle the write + this.client.write({ sessionId: paneId, data }).catch((error) => { + console.error( + `[DaemonTerminalManager] Write failed for ${paneId}:`, + error, + ); + }); + + session.lastActive = Date.now(); + } + + resize(params: { paneId: string; cols: number; rows: number }): void { + const { paneId, cols, rows } = params; + + // Validate geometry + if ( + !Number.isInteger(cols) || + !Number.isInteger(rows) || + cols <= 0 || + rows <= 0 + ) { + console.warn( + `[DaemonTerminalManager] Invalid resize geometry for ${paneId}: cols=${cols}, rows=${rows}`, + ); + return; + } + + const session = this.sessions.get(paneId); + if (!session || !session.isAlive) { + console.warn( + `Cannot resize terminal ${paneId}: session not found or not alive`, + ); + return; + } + + // Fire and forget + this.client.resize({ sessionId: paneId, cols, rows }).catch((error) => { + console.error( + `[DaemonTerminalManager] Resize failed for ${paneId}:`, + error, + ); + }); + + session.lastActive = Date.now(); + } + + signal(params: { paneId: string; signal?: string }): void { + const { paneId, signal = "SIGTERM" } = params; + const session = this.sessions.get(paneId); + + if (!session || !session.isAlive) { + console.warn( + `Cannot signal terminal ${paneId}: session not found or not alive`, + ); + return; + } + + // Daemon doesn't have a signal method, use kill + // For now, just log - we may need to add signal support to daemon + console.warn( + `[DaemonTerminalManager] Signal ${signal} not yet supported for daemon sessions`, + ); + } + + async kill(params: { + paneId: string; + deleteHistory?: boolean; + }): Promise { + const { paneId, deleteHistory = false } = params; + + await this.client.kill({ sessionId: paneId, deleteHistory }); + + const session = this.sessions.get(paneId); + if (session) { + session.isAlive = false; + } + } + + detach(params: { paneId: string }): void { + const { paneId } = params; + + const session = this.sessions.get(paneId); + if (!session) { + console.warn(`Cannot detach terminal ${paneId}: session not found`); + return; + } + + // Fire and forget + this.client.detach({ sessionId: paneId }).catch((error) => { + console.error( + `[DaemonTerminalManager] Detach failed for ${paneId}:`, + error, + ); + }); + + session.lastActive = Date.now(); + } + + async clearScrollback(params: { paneId: string }): Promise { + const { paneId } = params; + + await this.client.clearScrollback({ sessionId: paneId }); + + const session = this.sessions.get(paneId); + if (session) { + session.lastActive = Date.now(); + } + } + + getSession( + paneId: string, + ): { isAlive: boolean; cwd: string; lastActive: number } | null { + const session = this.sessions.get(paneId); + if (!session) { + return null; + } + + return { + isAlive: session.isAlive, + cwd: session.cwd, + lastActive: session.lastActive, + }; + } + + async killByWorkspaceId( + workspaceId: string, + ): Promise<{ killed: number; failed: number }> { + const sessionsToKill = Array.from(this.sessions.entries()).filter( + ([, session]) => session.workspaceId === workspaceId, + ); + + if (sessionsToKill.length === 0) { + return { killed: 0, failed: 0 }; + } + + let killed = 0; + let failed = 0; + + for (const [paneId] of sessionsToKill) { + try { + await this.kill({ paneId, deleteHistory: true }); + killed++; + } catch { + failed++; + } + } + + return { killed, failed }; + } + + getSessionCountByWorkspaceId(workspaceId: string): number { + return Array.from(this.sessions.values()).filter( + (session) => session.workspaceId === workspaceId && session.isAlive, + ).length; + } + + /** + * Send a newline to all terminals in a workspace to refresh their prompts. + */ + refreshPromptsForWorkspace(workspaceId: string): void { + for (const [paneId, session] of this.sessions.entries()) { + if (session.workspaceId === workspaceId && session.isAlive) { + this.client.write({ sessionId: paneId, data: "\n" }).catch((error) => { + console.warn( + `[DaemonTerminalManager] Failed to refresh prompt for pane ${paneId}:`, + error, + ); + }); + } + } + } + + detachAllListeners(): void { + for (const event of this.eventNames()) { + const name = String(event); + if (name.startsWith("data:") || name.startsWith("exit:")) { + this.removeAllListeners(event); + } + } + } + + /** + * Cleanup on app quit. + * + * IMPORTANT: In daemon mode, we intentionally do NOT kill sessions. + * The whole point of the daemon is to persist terminals across app restarts. + * We only disconnect from the daemon and clear local state. + */ + async cleanup(): Promise { + // Disconnect from daemon but DON'T kill sessions - they should persist + // across app restarts. This is the core feature of daemon mode. + this.sessions.clear(); + this.removeAllListeners(); + disposeTerminalHostClient(); + } + + /** + * Forcefully kill all sessions in the daemon. + * Only use this when you explicitly want to destroy all terminals, + * not during normal app shutdown. + */ + async forceKillAll(): Promise { + await this.client.killAll({}); + this.sessions.clear(); + } +} + +// ============================================================================= +// Singleton Instance +// ============================================================================= + +let daemonManager: DaemonTerminalManager | null = null; + +export function getDaemonTerminalManager(): DaemonTerminalManager { + if (!daemonManager) { + daemonManager = new DaemonTerminalManager(); + } + return daemonManager; +} diff --git a/apps/desktop/src/main/lib/terminal/index.ts b/apps/desktop/src/main/lib/terminal/index.ts index 190aa9dd342..0786956d98e 100644 --- a/apps/desktop/src/main/lib/terminal/index.ts +++ b/apps/desktop/src/main/lib/terminal/index.ts @@ -1,4 +1,11 @@ -export { TerminalManager, terminalManager } from "./manager"; +import { + DaemonTerminalManager, + getDaemonTerminalManager, +} from "./daemon-manager"; +import { TerminalManager, terminalManager } from "./manager"; + +export { TerminalManager, terminalManager }; +export { DaemonTerminalManager, getDaemonTerminalManager }; export type { CreateSessionParams, SessionResult, @@ -6,3 +13,39 @@ export type { TerminalEvent, TerminalExitEvent, } from "./types"; + +// ============================================================================= +// Terminal Manager Selection +// ============================================================================= + +/** + * Check if daemon mode is enabled. + * For now, this is controlled by an environment variable. + * Later, this will be read from user settings. + */ +export function isDaemonModeEnabled(): boolean { + // Enable daemon mode via environment variable for testing + // In production, this will be read from user settings + // + // Note: SUPERSET_TERMINAL_DAEMON is baked in at build time via electron.vite.config.ts + // Set it before running `bun dev` or `bun build`: + // SUPERSET_TERMINAL_DAEMON=1 bun dev + const enabled = process.env.SUPERSET_TERMINAL_DAEMON === "1"; + console.log( + `[TerminalManager] Daemon mode: ${enabled ? "ENABLED" : "DISABLED"} (SUPERSET_TERMINAL_DAEMON="${process.env.SUPERSET_TERMINAL_DAEMON}")`, + ); + return enabled; +} + +/** + * Get the active terminal manager based on current settings. + * Returns either the in-process manager or the daemon-based manager. + */ +export function getActiveTerminalManager(): + | TerminalManager + | DaemonTerminalManager { + if (isDaemonModeEnabled()) { + return getDaemonTerminalManager(); + } + return terminalManager; +} diff --git a/apps/desktop/src/main/lib/terminal/types.ts b/apps/desktop/src/main/lib/terminal/types.ts index 0a53eb35a78..64ee71ba1ee 100644 --- a/apps/desktop/src/main/lib/terminal/types.ts +++ b/apps/desktop/src/main/lib/terminal/types.ts @@ -38,6 +38,16 @@ export interface SessionResult { isNew: boolean; scrollback: string; wasRecovered: boolean; + /** Snapshot from daemon (if using daemon mode) */ + snapshot?: { + snapshotAnsi: string; + rehydrateSequences: string; + cwd: string | null; + modes: Record; + cols: number; + rows: number; + scrollbackLines: number; + }; } export interface CreateSessionParams { diff --git a/apps/desktop/src/main/terminal-host/daemon.test.ts b/apps/desktop/src/main/terminal-host/daemon.test.ts new file mode 100644 index 00000000000..69049f10d50 --- /dev/null +++ b/apps/desktop/src/main/terminal-host/daemon.test.ts @@ -0,0 +1,429 @@ +/** + * Terminal Host Daemon Integration Tests + * + * These tests verify the daemon can: + * 1. Start and listen on a Unix socket + * 2. Accept connections and handle NDJSON protocol + * 3. Authenticate clients with token + * 4. Respond to hello requests + */ + +import { afterEach, beforeEach, describe, expect, it } from "bun:test"; +import type { ChildProcess } from "node:child_process"; +import { spawn } from "node:child_process"; +import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs"; +import { connect, type Socket } from "node:net"; +import { homedir } from "node:os"; +import { join, resolve } from "node:path"; +import { + type HelloResponse, + type IpcRequest, + type IpcResponse, + PROTOCOL_VERSION, +} from "../lib/terminal-host/types"; + +// Test uses development paths +const SUPERSET_DIR_NAME = ".superset-dev"; +const SUPERSET_HOME_DIR = join(homedir(), SUPERSET_DIR_NAME); +const SOCKET_PATH = join(SUPERSET_HOME_DIR, "terminal-host.sock"); +const TOKEN_PATH = join(SUPERSET_HOME_DIR, "terminal-host.token"); +const PID_PATH = join(SUPERSET_HOME_DIR, "terminal-host.pid"); + +// Path to the daemon source file +const DAEMON_PATH = resolve(__dirname, "index.ts"); + +// Timeout for daemon operations +const DAEMON_TIMEOUT = 10000; +const CONNECT_TIMEOUT = 5000; + +describe("Terminal Host Daemon", () => { + let daemonProcess: ChildProcess | null = null; + + /** + * Clean up any existing daemon artifacts + */ + function cleanup() { + // Kill any existing daemon + if (existsSync(PID_PATH)) { + try { + const pid = Number.parseInt(readFileSync(PID_PATH, "utf-8").trim(), 10); + if (pid > 0) { + process.kill(pid, "SIGTERM"); + } + } catch { + // Process might not exist + } + } + + // Remove socket file + if (existsSync(SOCKET_PATH)) { + try { + rmSync(SOCKET_PATH); + } catch { + // Ignore + } + } + + // Remove PID file + if (existsSync(PID_PATH)) { + try { + rmSync(PID_PATH); + } catch { + // Ignore + } + } + + // Remove token file (so we get a fresh one) + if (existsSync(TOKEN_PATH)) { + try { + rmSync(TOKEN_PATH); + } catch { + // Ignore + } + } + } + + /** + * Start the daemon process + */ + async function startDaemon(): Promise { + return new Promise((resolve, reject) => { + // Ensure home directory exists + if (!existsSync(SUPERSET_HOME_DIR)) { + mkdirSync(SUPERSET_HOME_DIR, { recursive: true, mode: 0o700 }); + } + + // Start daemon with tsx (bun's typescript runner) + daemonProcess = spawn("bun", ["run", DAEMON_PATH], { + env: { + ...process.env, + NODE_ENV: "development", + }, + stdio: ["ignore", "pipe", "pipe"], + detached: true, + }); + + let output = ""; + + daemonProcess.stdout?.on("data", (data) => { + output += data.toString(); + // Check if daemon is ready + if (output.includes("Daemon started")) { + resolve(); + } + }); + + daemonProcess.stderr?.on("data", (data) => { + console.error("Daemon stderr:", data.toString()); + }); + + daemonProcess.on("error", (error) => { + reject(new Error(`Failed to start daemon: ${error.message}`)); + }); + + daemonProcess.on("exit", (code, signal) => { + if (code !== 0 && code !== null) { + reject( + new Error(`Daemon exited with code ${code}, signal ${signal}`), + ); + } + }); + + // Timeout if daemon doesn't start + setTimeout(() => { + reject( + new Error( + `Daemon failed to start within ${DAEMON_TIMEOUT}ms. Output: ${output}`, + ), + ); + }, DAEMON_TIMEOUT); + }); + } + + /** + * Stop the daemon process + */ + async function stopDaemon(): Promise { + if (daemonProcess) { + return new Promise((resolve) => { + daemonProcess?.on("exit", () => { + daemonProcess = null; + resolve(); + }); + + daemonProcess?.kill("SIGTERM"); + + // Force kill if it doesn't exit gracefully + setTimeout(() => { + if (daemonProcess) { + daemonProcess.kill("SIGKILL"); + daemonProcess = null; + resolve(); + } + }, 2000); + }); + } + } + + /** + * Connect to the daemon socket + */ + function connectToDaemon(): Promise { + return new Promise((resolve, reject) => { + const socket = connect(SOCKET_PATH); + + socket.on("connect", () => { + resolve(socket); + }); + + socket.on("error", (error) => { + reject(new Error(`Failed to connect to daemon: ${error.message}`)); + }); + + setTimeout(() => { + reject(new Error(`Connection timed out after ${CONNECT_TIMEOUT}ms`)); + }, CONNECT_TIMEOUT); + }); + } + + /** + * Send a request and wait for response + */ + function sendRequest( + socket: Socket, + request: IpcRequest, + ): Promise { + return new Promise((resolve, reject) => { + let buffer = ""; + + const onData = (data: Buffer) => { + buffer += data.toString(); + const newlineIndex = buffer.indexOf("\n"); + if (newlineIndex !== -1) { + const line = buffer.slice(0, newlineIndex); + socket.off("data", onData); + try { + resolve(JSON.parse(line)); + } catch (_error) { + reject(new Error(`Failed to parse response: ${line}`)); + } + } + }; + + socket.on("data", onData); + + socket.write(`${JSON.stringify(request)}\n`); + + setTimeout(() => { + socket.off("data", onData); + reject(new Error("Request timed out")); + }, 5000); + }); + } + + beforeEach(async () => { + cleanup(); + await startDaemon(); + }); + + afterEach(async () => { + await stopDaemon(); + cleanup(); + }); + + describe("hello handshake", () => { + it("should accept valid hello request with correct token", async () => { + const socket = await connectToDaemon(); + + try { + // Read the token that the daemon generated + const token = readFileSync(TOKEN_PATH, "utf-8").trim(); + expect(token).toHaveLength(64); // 32 bytes = 64 hex chars + + // Send hello request + const request: IpcRequest = { + id: "test-1", + type: "hello", + payload: { + token, + protocolVersion: PROTOCOL_VERSION, + }, + }; + + const response = await sendRequest(socket, request); + + expect(response.id).toBe("test-1"); + expect(response.ok).toBe(true); + + if (response.ok) { + const payload = response.payload as HelloResponse; + expect(payload.protocolVersion).toBe(PROTOCOL_VERSION); + expect(payload.daemonVersion).toBe("1.0.0"); + expect(payload.daemonPid).toBeGreaterThan(0); + } + } finally { + socket.destroy(); + } + }); + + it("should reject hello request with invalid token", async () => { + const socket = await connectToDaemon(); + + try { + const request: IpcRequest = { + id: "test-2", + type: "hello", + payload: { + token: "invalid-token", + protocolVersion: PROTOCOL_VERSION, + }, + }; + + const response = await sendRequest(socket, request); + + expect(response.id).toBe("test-2"); + expect(response.ok).toBe(false); + + if (!response.ok) { + expect(response.error.code).toBe("AUTH_FAILED"); + } + } finally { + socket.destroy(); + } + }); + + it("should reject hello request with wrong protocol version", async () => { + const socket = await connectToDaemon(); + + try { + const token = readFileSync(TOKEN_PATH, "utf-8").trim(); + + const request: IpcRequest = { + id: "test-3", + type: "hello", + payload: { + token, + protocolVersion: 999, // Invalid version + }, + }; + + const response = await sendRequest(socket, request); + + expect(response.id).toBe("test-3"); + expect(response.ok).toBe(false); + + if (!response.ok) { + expect(response.error.code).toBe("PROTOCOL_MISMATCH"); + } + } finally { + socket.destroy(); + } + }); + }); + + describe("authentication requirement", () => { + it("should reject requests before authentication", async () => { + const socket = await connectToDaemon(); + + try { + // Try to list sessions without authenticating first + const request: IpcRequest = { + id: "test-4", + type: "listSessions", + payload: undefined, + }; + + const response = await sendRequest(socket, request); + + expect(response.id).toBe("test-4"); + expect(response.ok).toBe(false); + + if (!response.ok) { + expect(response.error.code).toBe("NOT_AUTHENTICATED"); + } + } finally { + socket.destroy(); + } + }); + + it("should allow listSessions after authentication", async () => { + const socket = await connectToDaemon(); + + try { + const token = readFileSync(TOKEN_PATH, "utf-8").trim(); + + // Authenticate first + const helloRequest: IpcRequest = { + id: "test-5a", + type: "hello", + payload: { + token, + protocolVersion: PROTOCOL_VERSION, + }, + }; + + const helloResponse = await sendRequest(socket, helloRequest); + expect(helloResponse.ok).toBe(true); + + // Now list sessions + const listRequest: IpcRequest = { + id: "test-5b", + type: "listSessions", + payload: undefined, + }; + + const listResponse = await sendRequest(socket, listRequest); + + expect(listResponse.id).toBe("test-5b"); + expect(listResponse.ok).toBe(true); + + if (listResponse.ok) { + const payload = listResponse.payload as { sessions: unknown[] }; + expect(payload.sessions).toEqual([]); + } + } finally { + socket.destroy(); + } + }); + }); + + describe("unknown requests", () => { + it("should return error for unknown request type", async () => { + const socket = await connectToDaemon(); + + try { + const token = readFileSync(TOKEN_PATH, "utf-8").trim(); + + // Authenticate first + const helloRequest: IpcRequest = { + id: "test-6a", + type: "hello", + payload: { + token, + protocolVersion: PROTOCOL_VERSION, + }, + }; + + await sendRequest(socket, helloRequest); + + // Send unknown request + const unknownRequest: IpcRequest = { + id: "test-6b", + type: "unknownRequestType", + payload: {}, + }; + + const response = await sendRequest(socket, unknownRequest); + + expect(response.id).toBe("test-6b"); + expect(response.ok).toBe(false); + + if (!response.ok) { + expect(response.error.code).toBe("UNKNOWN_REQUEST"); + } + } finally { + socket.destroy(); + } + }); + }); +}); diff --git a/apps/desktop/src/main/terminal-host/index.ts b/apps/desktop/src/main/terminal-host/index.ts new file mode 100644 index 00000000000..642d926f141 --- /dev/null +++ b/apps/desktop/src/main/terminal-host/index.ts @@ -0,0 +1,495 @@ +/** + * Terminal Host Daemon + * + * A persistent background process that owns PTYs and terminal emulator state. + * This allows terminal sessions to survive app restarts and updates. + * + * Run with: ELECTRON_RUN_AS_NODE=1 electron dist/main/terminal-host.js + * + * IPC Protocol: + * - Uses NDJSON (newline-delimited JSON) over Unix domain socket + * - Socket: ~/.superset/terminal-host.sock + * - Auth token: ~/.superset/terminal-host.token + */ + +import { randomBytes } from "node:crypto"; +import { + chmodSync, + existsSync, + mkdirSync, + readFileSync, + unlinkSync, + writeFileSync, +} from "node:fs"; +import { createServer, type Server, type Socket } from "node:net"; +import { homedir } from "node:os"; +import { join } from "node:path"; +import { + type ClearScrollbackRequest, + type CreateOrAttachRequest, + type DetachRequest, + type HelloRequest, + type HelloResponse, + type IpcErrorResponse, + type IpcRequest, + type IpcSuccessResponse, + type KillAllRequest, + type KillRequest, + PROTOCOL_VERSION, + type ResizeRequest, + type WriteRequest, +} from "../lib/terminal-host/types"; +import { TerminalHost } from "./terminal-host"; + +// ============================================================================= +// Configuration +// ============================================================================= + +const DAEMON_VERSION = "1.0.0"; + +// Determine superset directory based on NODE_ENV +const SUPERSET_DIR_NAME = + process.env.NODE_ENV === "development" ? ".superset-dev" : ".superset"; +const SUPERSET_HOME_DIR = join(homedir(), SUPERSET_DIR_NAME); + +// Socket and token paths +const SOCKET_PATH = join(SUPERSET_HOME_DIR, "terminal-host.sock"); +const TOKEN_PATH = join(SUPERSET_HOME_DIR, "terminal-host.token"); +const PID_PATH = join(SUPERSET_HOME_DIR, "terminal-host.pid"); + +// ============================================================================= +// Logging +// ============================================================================= + +function log( + level: "info" | "warn" | "error", + message: string, + data?: unknown, +) { + const timestamp = new Date().toISOString(); + const prefix = `[${timestamp}] [terminal-host] [${level.toUpperCase()}]`; + if (data !== undefined) { + console.log(`${prefix} ${message}`, data); + } else { + console.log(`${prefix} ${message}`); + } +} + +// ============================================================================= +// Token Management +// ============================================================================= + +let authToken: string; + +function ensureAuthToken(): string { + if (existsSync(TOKEN_PATH)) { + // Read existing token + return readFileSync(TOKEN_PATH, "utf-8").trim(); + } + + // Generate new token (32 bytes = 64 hex chars) + const token = randomBytes(32).toString("hex"); + writeFileSync(TOKEN_PATH, token, { mode: 0o600 }); + log("info", "Generated new auth token"); + return token; +} + +function validateToken(token: string): boolean { + return token === authToken; +} + +// ============================================================================= +// NDJSON Framing +// ============================================================================= + +class NdjsonParser { + private buffer = ""; + + parse(chunk: string): IpcRequest[] { + this.buffer += chunk; + const messages: IpcRequest[] = []; + + let newlineIndex = this.buffer.indexOf("\n"); + while (newlineIndex !== -1) { + const line = this.buffer.slice(0, newlineIndex); + this.buffer = this.buffer.slice(newlineIndex + 1); + + if (line.trim()) { + try { + messages.push(JSON.parse(line)); + } catch { + log("warn", "Failed to parse NDJSON line", { line }); + } + } + + newlineIndex = this.buffer.indexOf("\n"); + } + + return messages; + } +} + +function sendResponse( + socket: Socket, + response: IpcSuccessResponse | IpcErrorResponse, +) { + socket.write(`${JSON.stringify(response)}\n`); +} + +function sendSuccess(socket: Socket, id: string, payload: unknown) { + sendResponse(socket, { id, ok: true, payload }); +} + +function sendError(socket: Socket, id: string, code: string, message: string) { + sendResponse(socket, { id, ok: false, error: { code, message } }); +} + +// ============================================================================= +// Terminal Host Instance +// ============================================================================= + +let terminalHost: TerminalHost; + +// ============================================================================= +// Request Handlers +// ============================================================================= + +type RequestHandler = ( + socket: Socket, + id: string, + payload: unknown, + clientState: ClientState, +) => void; + +interface ClientState { + authenticated: boolean; +} + +const handlers: Record = { + hello: (socket, id, payload, clientState) => { + const request = payload as HelloRequest; + + // Validate protocol version + if (request.protocolVersion !== PROTOCOL_VERSION) { + sendError( + socket, + id, + "PROTOCOL_MISMATCH", + `Protocol version mismatch. Expected ${PROTOCOL_VERSION}, got ${request.protocolVersion}`, + ); + return; + } + + // Validate token + if (!validateToken(request.token)) { + sendError(socket, id, "AUTH_FAILED", "Invalid auth token"); + return; + } + + clientState.authenticated = true; + + const response: HelloResponse = { + protocolVersion: PROTOCOL_VERSION, + daemonVersion: DAEMON_VERSION, + daemonPid: process.pid, + }; + + sendSuccess(socket, id, response); + log("info", "Client authenticated successfully"); + }, + + createOrAttach: (socket, id, payload, clientState) => { + if (!clientState.authenticated) { + sendError(socket, id, "NOT_AUTHENTICATED", "Must authenticate first"); + return; + } + + const request = payload as CreateOrAttachRequest; + log("info", `Creating/attaching session: ${request.sessionId}`); + + const response = terminalHost.createOrAttach(socket, request); + sendSuccess(socket, id, response); + + log( + "info", + `Session ${request.sessionId} ${response.isNew ? "created" : "attached"}`, + ); + }, + + write: (socket, id, payload, clientState) => { + if (!clientState.authenticated) { + sendError(socket, id, "NOT_AUTHENTICATED", "Must authenticate first"); + return; + } + + const request = payload as WriteRequest; + const response = terminalHost.write(request); + sendSuccess(socket, id, response); + }, + + resize: (socket, id, payload, clientState) => { + if (!clientState.authenticated) { + sendError(socket, id, "NOT_AUTHENTICATED", "Must authenticate first"); + return; + } + + const request = payload as ResizeRequest; + const response = terminalHost.resize(request); + sendSuccess(socket, id, response); + }, + + detach: (socket, id, payload, clientState) => { + if (!clientState.authenticated) { + sendError(socket, id, "NOT_AUTHENTICATED", "Must authenticate first"); + return; + } + + const request = payload as DetachRequest; + const response = terminalHost.detach(socket, request); + sendSuccess(socket, id, response); + }, + + kill: (socket, id, payload, clientState) => { + if (!clientState.authenticated) { + sendError(socket, id, "NOT_AUTHENTICATED", "Must authenticate first"); + return; + } + + const request = payload as KillRequest; + const response = terminalHost.kill(request); + sendSuccess(socket, id, response); + log("info", `Session ${request.sessionId} killed`); + }, + + killAll: (socket, id, payload, clientState) => { + if (!clientState.authenticated) { + sendError(socket, id, "NOT_AUTHENTICATED", "Must authenticate first"); + return; + } + + const request = payload as KillAllRequest; + const response = terminalHost.killAll(request); + sendSuccess(socket, id, response); + log("info", "All sessions killed"); + }, + + listSessions: (socket, id, _payload, clientState) => { + if (!clientState.authenticated) { + sendError(socket, id, "NOT_AUTHENTICATED", "Must authenticate first"); + return; + } + + const response = terminalHost.listSessions(); + sendSuccess(socket, id, response); + }, + + clearScrollback: (socket, id, payload, clientState) => { + if (!clientState.authenticated) { + sendError(socket, id, "NOT_AUTHENTICATED", "Must authenticate first"); + return; + } + + const request = payload as ClearScrollbackRequest; + const response = terminalHost.clearScrollback(request); + sendSuccess(socket, id, response); + }, +}; + +function handleRequest( + socket: Socket, + request: IpcRequest, + clientState: ClientState, +) { + const handler = handlers[request.type]; + + if (!handler) { + sendError( + socket, + request.id, + "UNKNOWN_REQUEST", + `Unknown request type: ${request.type}`, + ); + return; + } + + try { + handler(socket, request.id, request.payload, clientState); + } catch (error) { + const message = error instanceof Error ? error.message : String(error); + sendError(socket, request.id, "INTERNAL_ERROR", message); + log("error", `Handler error for ${request.type}`, { error: message }); + } +} + +// ============================================================================= +// Socket Server +// ============================================================================= + +let server: Server | null = null; + +function handleConnection(socket: Socket) { + const parser = new NdjsonParser(); + const clientState: ClientState = { authenticated: false }; + const remoteId = `${socket.remoteAddress || "local"}:${Date.now()}`; + + log("info", `Client connected: ${remoteId}`); + + socket.setEncoding("utf-8"); + + socket.on("data", (data: string) => { + const messages = parser.parse(data); + for (const message of messages) { + handleRequest(socket, message, clientState); + } + }); + + socket.on("close", () => { + log("info", `Client disconnected: ${remoteId}`); + }); + + socket.on("error", (error) => { + log("error", `Socket error for ${remoteId}`, { error: error.message }); + }); +} + +function startServer(): Promise { + return new Promise((resolve, reject) => { + // Ensure superset directory exists with proper permissions + if (!existsSync(SUPERSET_HOME_DIR)) { + mkdirSync(SUPERSET_HOME_DIR, { recursive: true, mode: 0o700 }); + log("info", `Created directory: ${SUPERSET_HOME_DIR}`); + } + + // Ensure directory has correct permissions + try { + chmodSync(SUPERSET_HOME_DIR, 0o700); + } catch { + // May fail if not owner, that's okay + } + + // Remove stale socket if it exists + if (existsSync(SOCKET_PATH)) { + try { + unlinkSync(SOCKET_PATH); + log("info", "Removed stale socket file"); + } catch (error) { + reject(new Error(`Failed to remove stale socket: ${error}`)); + return; + } + } + + // Initialize auth token + authToken = ensureAuthToken(); + + // Initialize terminal host + terminalHost = new TerminalHost(); + + // Create server + server = createServer(handleConnection); + + server.on("error", (error: NodeJS.ErrnoException) => { + if (error.code === "EADDRINUSE") { + log("error", "Socket already in use - another daemon may be running"); + reject(new Error("Socket already in use")); + } else { + log("error", "Server error", { error: error.message }); + reject(error); + } + }); + + server.listen(SOCKET_PATH, () => { + // Set socket permissions (readable/writable by owner only) + try { + chmodSync(SOCKET_PATH, 0o600); + } catch { + // May fail on some systems, that's okay - directory permissions protect us + } + + // Write PID file + writeFileSync(PID_PATH, String(process.pid), { mode: 0o600 }); + + log("info", `Daemon started`); + log("info", `Socket: ${SOCKET_PATH}`); + log("info", `PID: ${process.pid}`); + resolve(); + }); + }); +} + +function stopServer(): Promise { + return new Promise((resolve) => { + // Dispose terminal host (kills all sessions) + if (terminalHost) { + terminalHost.dispose(); + log("info", "Terminal host disposed"); + } + + if (server) { + server.close(() => { + log("info", "Server closed"); + resolve(); + }); + } else { + resolve(); + } + + // Clean up socket and PID files + try { + if (existsSync(SOCKET_PATH)) unlinkSync(SOCKET_PATH); + if (existsSync(PID_PATH)) unlinkSync(PID_PATH); + } catch { + // Best effort cleanup + } + }); +} + +// ============================================================================= +// Signal Handling +// ============================================================================= + +function setupSignalHandlers() { + const shutdown = async (signal: string) => { + log("info", `Received ${signal}, shutting down...`); + await stopServer(); + process.exit(0); + }; + + process.on("SIGINT", () => shutdown("SIGINT")); + process.on("SIGTERM", () => shutdown("SIGTERM")); + process.on("SIGHUP", () => shutdown("SIGHUP")); + + // Handle uncaught errors + process.on("uncaughtException", (error) => { + log("error", "Uncaught exception", { + error: error.message, + stack: error.stack, + }); + stopServer().then(() => process.exit(1)); + }); + + process.on("unhandledRejection", (reason) => { + log("error", "Unhandled rejection", { reason }); + stopServer().then(() => process.exit(1)); + }); +} + +// ============================================================================= +// Main +// ============================================================================= + +async function main() { + log("info", "Terminal Host Daemon starting..."); + log("info", `Environment: ${process.env.NODE_ENV || "production"}`); + log("info", `Home directory: ${SUPERSET_HOME_DIR}`); + + setupSignalHandlers(); + + try { + await startServer(); + } catch (error) { + log("error", "Failed to start server", { error }); + process.exit(1); + } +} + +main(); diff --git a/apps/desktop/src/main/terminal-host/session-lifecycle.test.ts b/apps/desktop/src/main/terminal-host/session-lifecycle.test.ts new file mode 100644 index 00000000000..ebd13ad5aab --- /dev/null +++ b/apps/desktop/src/main/terminal-host/session-lifecycle.test.ts @@ -0,0 +1,642 @@ +/** + * Terminal Host Session Lifecycle Integration Tests + * + * Tests the full session lifecycle: + * 1. Create session with PTY + * 2. Write data to terminal + * 3. Receive output events + * 4. Resize terminal + * 5. List sessions + * 6. Kill session + */ + +import { afterEach, beforeEach, describe, expect, it } from "bun:test"; +import type { ChildProcess } from "node:child_process"; +import { spawn } from "node:child_process"; +import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs"; +import { connect, type Socket } from "node:net"; +import { homedir } from "node:os"; +import { join, resolve } from "node:path"; +import { + type CreateOrAttachRequest, + type CreateOrAttachResponse, + type IpcEvent, + type IpcRequest, + type IpcResponse, + type ListSessionsResponse, + PROTOCOL_VERSION, + type TerminalDataEvent, +} from "../lib/terminal-host/types"; + +// Test uses development paths +const SUPERSET_DIR_NAME = ".superset-dev"; +const SUPERSET_HOME_DIR = join(homedir(), SUPERSET_DIR_NAME); +const SOCKET_PATH = join(SUPERSET_HOME_DIR, "terminal-host.sock"); +const TOKEN_PATH = join(SUPERSET_HOME_DIR, "terminal-host.token"); +const PID_PATH = join(SUPERSET_HOME_DIR, "terminal-host.pid"); + +// Path to the daemon source file +const DAEMON_PATH = resolve(__dirname, "index.ts"); + +// Timeouts +const DAEMON_TIMEOUT = 10000; +const CONNECT_TIMEOUT = 5000; + +describe("Terminal Host Session Lifecycle", () => { + let daemonProcess: ChildProcess | null = null; + + /** + * Clean up any existing daemon artifacts + */ + function cleanup() { + if (existsSync(PID_PATH)) { + try { + const pid = Number.parseInt(readFileSync(PID_PATH, "utf-8").trim(), 10); + if (pid > 0) { + process.kill(pid, "SIGTERM"); + } + } catch { + // Process might not exist + } + } + + if (existsSync(SOCKET_PATH)) { + try { + rmSync(SOCKET_PATH); + } catch { + // Ignore + } + } + + if (existsSync(PID_PATH)) { + try { + rmSync(PID_PATH); + } catch { + // Ignore + } + } + + if (existsSync(TOKEN_PATH)) { + try { + rmSync(TOKEN_PATH); + } catch { + // Ignore + } + } + } + + /** + * Start the daemon process + */ + async function startDaemon(): Promise { + return new Promise((resolve, reject) => { + if (!existsSync(SUPERSET_HOME_DIR)) { + mkdirSync(SUPERSET_HOME_DIR, { recursive: true, mode: 0o700 }); + } + + daemonProcess = spawn("bun", ["run", DAEMON_PATH], { + env: { + ...process.env, + NODE_ENV: "development", + }, + stdio: ["ignore", "pipe", "pipe"], + detached: true, + }); + + let output = ""; + + daemonProcess.stdout?.on("data", (data) => { + output += data.toString(); + if (output.includes("Daemon started")) { + resolve(); + } + }); + + daemonProcess.stderr?.on("data", (data) => { + console.error("Daemon stderr:", data.toString()); + }); + + daemonProcess.on("error", (error) => { + reject(new Error(`Failed to start daemon: ${error.message}`)); + }); + + daemonProcess.on("exit", (code, signal) => { + if (code !== 0 && code !== null) { + reject( + new Error(`Daemon exited with code ${code}, signal ${signal}`), + ); + } + }); + + setTimeout(() => { + reject( + new Error( + `Daemon failed to start within ${DAEMON_TIMEOUT}ms. Output: ${output}`, + ), + ); + }, DAEMON_TIMEOUT); + }); + } + + /** + * Stop the daemon process + */ + async function stopDaemon(): Promise { + if (daemonProcess) { + return new Promise((resolve) => { + daemonProcess?.on("exit", () => { + daemonProcess = null; + resolve(); + }); + + daemonProcess?.kill("SIGTERM"); + + setTimeout(() => { + if (daemonProcess) { + daemonProcess.kill("SIGKILL"); + daemonProcess = null; + resolve(); + } + }, 2000); + }); + } + } + + /** + * Connect to the daemon socket + */ + function connectToDaemon(): Promise { + return new Promise((resolve, reject) => { + const socket = connect(SOCKET_PATH); + + socket.on("connect", () => { + resolve(socket); + }); + + socket.on("error", (error) => { + reject(new Error(`Failed to connect to daemon: ${error.message}`)); + }); + + setTimeout(() => { + reject(new Error(`Connection timed out after ${CONNECT_TIMEOUT}ms`)); + }, CONNECT_TIMEOUT); + }); + } + + /** + * Send a request and wait for response + */ + function sendRequest( + socket: Socket, + request: IpcRequest, + ): Promise { + return new Promise((resolve, reject) => { + let buffer = ""; + + const onData = (data: Buffer) => { + buffer += data.toString(); + const newlineIndex = buffer.indexOf("\n"); + if (newlineIndex !== -1) { + const line = buffer.slice(0, newlineIndex); + buffer = buffer.slice(newlineIndex + 1); + socket.off("data", onData); + try { + resolve(JSON.parse(line)); + } catch (_error) { + reject(new Error(`Failed to parse response: ${line}`)); + } + } + }; + + socket.on("data", onData); + socket.write(`${JSON.stringify(request)}\n`); + + setTimeout(() => { + socket.off("data", onData); + reject(new Error("Request timed out")); + }, 5000); + }); + } + + /** + * Authenticate with the daemon + */ + async function authenticate(socket: Socket): Promise { + const token = readFileSync(TOKEN_PATH, "utf-8").trim(); + + const request: IpcRequest = { + id: `auth-${Date.now()}`, + type: "hello", + payload: { + token, + protocolVersion: PROTOCOL_VERSION, + }, + }; + + const response = await sendRequest(socket, request); + if (!response.ok) { + throw new Error(`Authentication failed: ${JSON.stringify(response)}`); + } + } + + /** + * Wait for events from the socket + */ + function waitForEvent( + socket: Socket, + eventType: string, + timeout = 5000, + ): Promise { + return new Promise((resolve, reject) => { + let buffer = ""; + + const onData = (data: Buffer) => { + buffer += data.toString(); + let newlineIndex = buffer.indexOf("\n"); + while (newlineIndex !== -1) { + const line = buffer.slice(0, newlineIndex); + buffer = buffer.slice(newlineIndex + 1); + + try { + const message = JSON.parse(line); + if (message.type === "event" && message.event === eventType) { + socket.off("data", onData); + resolve(message); + return; + } + } catch { + // Ignore parse errors + } + + newlineIndex = buffer.indexOf("\n"); + } + }; + + socket.on("data", onData); + + setTimeout(() => { + socket.off("data", onData); + reject(new Error(`Event '${eventType}' timed out after ${timeout}ms`)); + }, timeout); + }); + } + + beforeEach(async () => { + cleanup(); + await startDaemon(); + }); + + afterEach(async () => { + await stopDaemon(); + cleanup(); + }); + + describe("session creation", () => { + it("should create a new session and return snapshot", async () => { + const socket = await connectToDaemon(); + + try { + await authenticate(socket); + + const createRequest: IpcRequest = { + id: "test-create-1", + type: "createOrAttach", + payload: { + sessionId: "test-session-1", + workspaceId: "workspace-1", + paneId: "pane-1", + tabId: "tab-1", + cols: 80, + rows: 24, + cwd: process.env.HOME, + } satisfies CreateOrAttachRequest, + }; + + const response = await sendRequest(socket, createRequest); + + expect(response.id).toBe("test-create-1"); + expect(response.ok).toBe(true); + + if (response.ok) { + const payload = response.payload as CreateOrAttachResponse; + expect(payload.isNew).toBe(true); + expect(payload.snapshot).toBeDefined(); + expect(payload.snapshot.cols).toBe(80); + expect(payload.snapshot.rows).toBe(24); + } + } finally { + socket.destroy(); + } + }); + + it("should attach to existing session", async () => { + const socket = await connectToDaemon(); + + try { + await authenticate(socket); + + // Create first session + const createRequest1: IpcRequest = { + id: "test-create-2a", + type: "createOrAttach", + payload: { + sessionId: "test-session-2", + workspaceId: "workspace-1", + paneId: "pane-2", + tabId: "tab-1", + cols: 80, + rows: 24, + cwd: process.env.HOME, + } satisfies CreateOrAttachRequest, + }; + + const response1 = await sendRequest(socket, createRequest1); + expect(response1.ok).toBe(true); + if (response1.ok) { + expect((response1.payload as CreateOrAttachResponse).isNew).toBe( + true, + ); + } + + // Attach to same session + const createRequest2: IpcRequest = { + id: "test-create-2b", + type: "createOrAttach", + payload: { + sessionId: "test-session-2", + workspaceId: "workspace-1", + paneId: "pane-2", + tabId: "tab-1", + cols: 80, + rows: 24, + cwd: process.env.HOME, + } satisfies CreateOrAttachRequest, + }; + + const response2 = await sendRequest(socket, createRequest2); + expect(response2.ok).toBe(true); + if (response2.ok) { + const payload = response2.payload as CreateOrAttachResponse; + expect(payload.isNew).toBe(false); + expect(payload.wasRecovered).toBe(true); + } + } finally { + socket.destroy(); + } + }); + }); + + describe("session operations", () => { + // Note: PTY operations may fail in test environment due to bun/node-pty compatibility + // The daemon infrastructure is tested separately in daemon.test.ts + it.skip("should write data to terminal and receive output", async () => { + const socket = await connectToDaemon(); + + try { + await authenticate(socket); + + // Create session + const createRequest: IpcRequest = { + id: "test-write-1", + type: "createOrAttach", + payload: { + sessionId: "test-session-write", + workspaceId: "workspace-1", + paneId: "pane-write", + tabId: "tab-1", + cols: 80, + rows: 24, + cwd: process.env.HOME, + } satisfies CreateOrAttachRequest, + }; + + await sendRequest(socket, createRequest); + + // Wait for shell prompt (data event) + const dataPromise = waitForEvent(socket, "data", 10000); + + // Write a simple echo command + const writeRequest: IpcRequest = { + id: "test-write-2", + type: "write", + payload: { + sessionId: "test-session-write", + data: "echo hello\n", + }, + }; + + const writeResponse = await sendRequest(socket, writeRequest); + if (!writeResponse.ok) { + console.error("Write failed:", writeResponse); + } + expect(writeResponse.ok).toBe(true); + + // Wait for output + const event = await dataPromise; + expect(event.sessionId).toBe("test-session-write"); + expect(event.event).toBe("data"); + + const payload = event.payload as TerminalDataEvent; + expect(payload.type).toBe("data"); + expect(typeof payload.data).toBe("string"); + } finally { + socket.destroy(); + } + }); + + // Note: PTY operations may fail in test environment due to bun/node-pty compatibility + it.skip("should resize terminal", async () => { + const socket = await connectToDaemon(); + + try { + await authenticate(socket); + + // Create session + const createRequest: IpcRequest = { + id: "test-resize-1", + type: "createOrAttach", + payload: { + sessionId: "test-session-resize", + workspaceId: "workspace-1", + paneId: "pane-resize", + tabId: "tab-1", + cols: 80, + rows: 24, + cwd: process.env.HOME, + } satisfies CreateOrAttachRequest, + }; + + await sendRequest(socket, createRequest); + + // Resize + const resizeRequest: IpcRequest = { + id: "test-resize-2", + type: "resize", + payload: { + sessionId: "test-session-resize", + cols: 120, + rows: 40, + }, + }; + + const resizeResponse = await sendRequest(socket, resizeRequest); + expect(resizeResponse.ok).toBe(true); + } finally { + socket.destroy(); + } + }); + }); + + describe("session listing", () => { + // Note: PTY operations may fail in test environment due to bun/node-pty compatibility + it.skip("should list all sessions", async () => { + const socket = await connectToDaemon(); + + try { + await authenticate(socket); + + // Create two sessions + for (const id of ["session-list-1", "session-list-2"]) { + const createRequest: IpcRequest = { + id: `create-${id}`, + type: "createOrAttach", + payload: { + sessionId: id, + workspaceId: "workspace-1", + paneId: `pane-${id}`, + tabId: "tab-1", + cols: 80, + rows: 24, + cwd: process.env.HOME, + } satisfies CreateOrAttachRequest, + }; + await sendRequest(socket, createRequest); + } + + // List sessions + const listRequest: IpcRequest = { + id: "test-list", + type: "listSessions", + payload: undefined, + }; + + const listResponse = await sendRequest(socket, listRequest); + expect(listResponse.ok).toBe(true); + + if (listResponse.ok) { + const payload = listResponse.payload as ListSessionsResponse; + expect(payload.sessions.length).toBeGreaterThanOrEqual(2); + + const sessionIds = payload.sessions.map((s) => s.sessionId); + expect(sessionIds).toContain("session-list-1"); + expect(sessionIds).toContain("session-list-2"); + } + } finally { + socket.destroy(); + } + }); + }); + + describe("session termination", () => { + it("should kill a specific session", async () => { + const socket = await connectToDaemon(); + + try { + await authenticate(socket); + + // Create session + const createRequest: IpcRequest = { + id: "test-kill-1", + type: "createOrAttach", + payload: { + sessionId: "test-session-kill", + workspaceId: "workspace-1", + paneId: "pane-kill", + tabId: "tab-1", + cols: 80, + rows: 24, + cwd: process.env.HOME, + } satisfies CreateOrAttachRequest, + }; + + await sendRequest(socket, createRequest); + + // Kill session + const killRequest: IpcRequest = { + id: "test-kill-2", + type: "kill", + payload: { + sessionId: "test-session-kill", + }, + }; + + const killResponse = await sendRequest(socket, killRequest); + expect(killResponse.ok).toBe(true); + + // Wait for exit event + const exitEvent = await waitForEvent(socket, "exit", 5000); + expect(exitEvent.sessionId).toBe("test-session-kill"); + } finally { + socket.destroy(); + } + }); + + // Note: PTY operations may fail in test environment due to bun/node-pty compatibility + it.skip("should kill all sessions", async () => { + const socket = await connectToDaemon(); + + try { + await authenticate(socket); + + // Create sessions + for (const id of ["kill-all-1", "kill-all-2"]) { + const createRequest: IpcRequest = { + id: `create-${id}`, + type: "createOrAttach", + payload: { + sessionId: id, + workspaceId: "workspace-1", + paneId: `pane-${id}`, + tabId: "tab-1", + cols: 80, + rows: 24, + cwd: process.env.HOME, + } satisfies CreateOrAttachRequest, + }; + await sendRequest(socket, createRequest); + } + + // Kill all + const killAllRequest: IpcRequest = { + id: "test-killall", + type: "killAll", + payload: {}, + }; + + const killAllResponse = await sendRequest(socket, killAllRequest); + expect(killAllResponse.ok).toBe(true); + + // Wait a bit for exits to propagate + await new Promise((resolve) => setTimeout(resolve, 1000)); + + // List should show no alive sessions + const listRequest: IpcRequest = { + id: "test-list-after-kill", + type: "listSessions", + payload: undefined, + }; + + const listResponse = await sendRequest(socket, listRequest); + expect(listResponse.ok).toBe(true); + + if (listResponse.ok) { + const payload = listResponse.payload as ListSessionsResponse; + const aliveSessions = payload.sessions.filter((s) => s.isAlive); + expect(aliveSessions.length).toBe(0); + } + } finally { + socket.destroy(); + } + }); + }); +}); diff --git a/apps/desktop/src/main/terminal-host/session.ts b/apps/desktop/src/main/terminal-host/session.ts new file mode 100644 index 00000000000..d5271cd49ba --- /dev/null +++ b/apps/desktop/src/main/terminal-host/session.ts @@ -0,0 +1,388 @@ +/** + * Terminal Host Session + * + * A session owns: + * - A PTY process (node-pty) + * - A HeadlessEmulator instance for state tracking + * - A set of attached clients + * - Output capture to disk + */ + +import type { Socket } from "node:net"; +import * as pty from "node-pty"; +import { HeadlessEmulator } from "../lib/terminal-host/headless-emulator"; +import type { + CreateOrAttachRequest, + IpcEvent, + SessionMeta, + TerminalDataEvent, + TerminalExitEvent, + TerminalSnapshot, +} from "../lib/terminal-host/types"; + +// ============================================================================= +// Types +// ============================================================================= + +export interface SessionOptions { + sessionId: string; + workspaceId: string; + paneId: string; + tabId: string; + cols: number; + rows: number; + cwd: string; + env?: Record; + shell?: string; + workspaceName?: string; + workspacePath?: string; + rootPath?: string; + scrollbackLines?: number; +} + +export interface AttachedClient { + socket: Socket; + attachedAt: number; +} + +// ============================================================================= +// Session Class +// ============================================================================= + +export class Session { + readonly sessionId: string; + readonly workspaceId: string; + readonly paneId: string; + readonly tabId: string; + readonly shell: string; + readonly createdAt: Date; + + private ptyProcess: pty.IPty | null = null; + private emulator: HeadlessEmulator; + private attachedClients: Map = new Map(); + private lastAttachedAt: Date; + private exitCode: number | null = null; + private disposed = false; + + // Callbacks + private onSessionExit?: ( + sessionId: string, + exitCode: number, + signal?: number, + ) => void; + + constructor(options: SessionOptions) { + this.sessionId = options.sessionId; + this.workspaceId = options.workspaceId; + this.paneId = options.paneId; + this.tabId = options.tabId; + this.shell = options.shell || this.getDefaultShell(); + this.createdAt = new Date(); + this.lastAttachedAt = new Date(); + + // Create headless emulator + this.emulator = new HeadlessEmulator({ + cols: options.cols, + rows: options.rows, + scrollback: options.scrollbackLines ?? 10000, + }); + + // Set initial CWD + this.emulator.setCwd(options.cwd); + + // Listen for emulator output (query responses) + this.emulator.onData((data) => { + // If no clients attached, send responses back to PTY + // This allows TUIs to function while app is closed + if (this.attachedClients.size === 0 && this.ptyProcess) { + this.ptyProcess.write(data); + } + // When clients are attached, the renderer handles responses + }); + } + + /** + * Spawn the PTY process + */ + spawn(options: { + cwd: string; + cols: number; + rows: number; + env?: Record; + }): void { + if (this.ptyProcess) { + throw new Error("PTY already spawned"); + } + + const { cwd, cols, rows, env = {} } = options; + + // Build environment - filter out undefined values and ELECTRON_RUN_AS_NODE + const processEnv: Record = {}; + for (const [key, value] of Object.entries(process.env)) { + // Skip ELECTRON_RUN_AS_NODE (daemon runs with this, but spawned shells shouldn't) + if (key === "ELECTRON_RUN_AS_NODE") continue; + if (value !== undefined) { + processEnv[key] = value; + } + } + // Add custom env vars + Object.assign(processEnv, env); + // Ensure TERM is set + processEnv.TERM = "xterm-256color"; + + // Get shell args + const shellArgs = this.getShellArgs(this.shell); + + this.ptyProcess = pty.spawn(this.shell, shellArgs, { + name: "xterm-256color", + cols, + rows, + cwd, + env: processEnv, + }); + + // Handle PTY data + this.ptyProcess.onData((data) => { + // Feed data to emulator for state tracking + this.emulator.write(data); + + // Send to all attached clients + this.broadcastEvent("data", { + type: "data", + data, + } satisfies TerminalDataEvent); + }); + + // Handle PTY exit + this.ptyProcess.onExit(({ exitCode, signal }) => { + this.exitCode = exitCode; + + // Notify attached clients + this.broadcastEvent("exit", { + type: "exit", + exitCode, + signal, + } satisfies TerminalExitEvent); + + // Notify session manager + this.onSessionExit?.(this.sessionId, exitCode, signal); + }); + } + + /** + * Check if session is alive (PTY running) + */ + get isAlive(): boolean { + return this.ptyProcess !== null && this.exitCode === null; + } + + /** + * Get number of attached clients + */ + get clientCount(): number { + return this.attachedClients.size; + } + + /** + * Attach a client to this session + */ + attach(socket: Socket): TerminalSnapshot { + if (this.disposed) { + throw new Error("Session disposed"); + } + + // Track client + this.attachedClients.set(socket, { + socket, + attachedAt: Date.now(), + }); + this.lastAttachedAt = new Date(); + + // Handle client disconnect + const cleanup = () => { + this.attachedClients.delete(socket); + }; + socket.once("close", cleanup); + socket.once("error", cleanup); + + // Return current snapshot + return this.emulator.getSnapshot(); + } + + /** + * Detach a client from this session + */ + detach(socket: Socket): void { + this.attachedClients.delete(socket); + } + + /** + * Write data to PTY + */ + write(data: string): void { + if (!this.ptyProcess) { + throw new Error("PTY not spawned"); + } + this.ptyProcess.write(data); + } + + /** + * Resize PTY and emulator + */ + resize(cols: number, rows: number): void { + if (this.ptyProcess) { + this.ptyProcess.resize(cols, rows); + } + this.emulator.resize(cols, rows); + } + + /** + * Clear scrollback buffer + */ + clearScrollback(): void { + this.emulator.clear(); + } + + /** + * Get session snapshot (for debugging/inspection) + */ + getSnapshot(): TerminalSnapshot { + return this.emulator.getSnapshot(); + } + + /** + * Get session metadata + */ + getMeta(): SessionMeta { + const dims = this.emulator.getDimensions(); + return { + sessionId: this.sessionId, + workspaceId: this.workspaceId, + paneId: this.paneId, + cwd: this.emulator.getCwd() || "", + cols: dims.cols, + rows: dims.rows, + createdAt: this.createdAt.toISOString(), + lastAttachedAt: this.lastAttachedAt.toISOString(), + shell: this.shell, + }; + } + + /** + * Kill the PTY process + */ + kill(signal: string = "SIGTERM"): void { + if (this.ptyProcess) { + try { + this.ptyProcess.kill(signal); + } catch { + // Process might already be dead + } + } + } + + /** + * Dispose of the session + */ + dispose(): void { + if (this.disposed) return; + this.disposed = true; + + // Kill PTY + this.kill("SIGKILL"); + this.ptyProcess = null; + + // Dispose emulator + this.emulator.dispose(); + + // Clear clients + this.attachedClients.clear(); + } + + /** + * Set exit callback + */ + onExit( + callback: (sessionId: string, exitCode: number, signal?: number) => void, + ): void { + this.onSessionExit = callback; + } + + // =========================================================================== + // Private Methods + // =========================================================================== + + /** + * Broadcast an event to all attached clients + */ + private broadcastEvent( + eventType: string, + payload: TerminalDataEvent | TerminalExitEvent, + ): void { + const event: IpcEvent = { + type: "event", + event: eventType, + sessionId: this.sessionId, + payload, + }; + + const message = `${JSON.stringify(event)}\n`; + + for (const { socket } of this.attachedClients.values()) { + try { + socket.write(message); + } catch { + // Client might have disconnected + this.attachedClients.delete(socket); + } + } + } + + /** + * Get default shell for the platform + */ + private getDefaultShell(): string { + if (process.platform === "win32") { + return process.env.COMSPEC || "cmd.exe"; + } + return process.env.SHELL || "/bin/zsh"; + } + + /** + * Get shell arguments for login shell + */ + private getShellArgs(shell: string): string[] { + const shellName = shell.split("/").pop() || ""; + + // Common shells that support login shell + if (["zsh", "bash", "sh", "ksh", "fish"].includes(shellName)) { + return ["-l"]; // Login shell + } + + return []; + } +} + +// ============================================================================= +// Factory Functions +// ============================================================================= + +/** + * Create a new session from request parameters + */ +export function createSession(request: CreateOrAttachRequest): Session { + return new Session({ + sessionId: request.sessionId, + workspaceId: request.workspaceId, + paneId: request.paneId, + tabId: request.tabId, + cols: request.cols, + rows: request.rows, + cwd: request.cwd || process.env.HOME || "/", + env: request.env, + shell: request.shell, + workspaceName: request.workspaceName, + workspacePath: request.workspacePath, + rootPath: request.rootPath, + }); +} diff --git a/apps/desktop/src/main/terminal-host/terminal-host.ts b/apps/desktop/src/main/terminal-host/terminal-host.ts new file mode 100644 index 00000000000..ac1b75452d7 --- /dev/null +++ b/apps/desktop/src/main/terminal-host/terminal-host.ts @@ -0,0 +1,206 @@ +/** + * Terminal Host Manager + * + * Manages all terminal sessions in the daemon. + * Responsible for: + * - Session lifecycle (create, attach, detach, kill) + * - Session lookup and listing + * - Cleanup on shutdown + */ + +import type { Socket } from "node:net"; +import type { + ClearScrollbackRequest, + CreateOrAttachRequest, + CreateOrAttachResponse, + DetachRequest, + EmptyResponse, + KillAllRequest, + KillRequest, + ListSessionsResponse, + ResizeRequest, + WriteRequest, +} from "../lib/terminal-host/types"; +import { createSession, type Session } from "./session"; + +// ============================================================================= +// TerminalHost Class +// ============================================================================= + +export class TerminalHost { + private sessions: Map = new Map(); + + /** + * Create or attach to a terminal session + */ + createOrAttach( + socket: Socket, + request: CreateOrAttachRequest, + ): CreateOrAttachResponse { + const { sessionId } = request; + + let session = this.sessions.get(sessionId); + let isNew = false; + + if (!session) { + // Create new session + session = createSession(request); + + // Set up exit handler + session.onExit((id, exitCode, signal) => { + this.handleSessionExit(id, exitCode, signal); + }); + + // Spawn PTY + session.spawn({ + cwd: request.cwd || process.env.HOME || "/", + cols: request.cols, + rows: request.rows, + env: request.env, + }); + + // Run initial commands if provided + if (request.initialCommands && request.initialCommands.length > 0) { + // Wait a bit for shell to initialize, then run commands + setTimeout(() => { + if (session?.isAlive) { + const cmdString = `${request.initialCommands?.join(" && ")}\n`; + session.write(cmdString); + } + }, 100); + } + + this.sessions.set(sessionId, session); + isNew = true; + } + + // Attach client to session + const snapshot = session.attach(socket); + + return { + isNew, + snapshot, + wasRecovered: !isNew && session.isAlive, + }; + } + + /** + * Write data to a terminal session + */ + write(request: WriteRequest): EmptyResponse { + const session = this.getSession(request.sessionId); + session.write(request.data); + return { success: true }; + } + + /** + * Resize a terminal session + */ + resize(request: ResizeRequest): EmptyResponse { + const session = this.getSession(request.sessionId); + session.resize(request.cols, request.rows); + return { success: true }; + } + + /** + * Detach a client from a session + */ + detach(socket: Socket, request: DetachRequest): EmptyResponse { + const session = this.sessions.get(request.sessionId); + if (session) { + session.detach(socket); + } + return { success: true }; + } + + /** + * Kill a terminal session + */ + kill(request: KillRequest): EmptyResponse { + const session = this.sessions.get(request.sessionId); + if (session) { + session.kill(); + // Session will be removed on exit event + } + return { success: true }; + } + + /** + * Kill all terminal sessions + */ + killAll(_request: KillAllRequest): EmptyResponse { + for (const session of this.sessions.values()) { + session.kill(); + } + // Sessions will be removed on exit events + return { success: true }; + } + + /** + * List all sessions + */ + listSessions(): ListSessionsResponse { + const sessions = Array.from(this.sessions.values()).map((session) => ({ + sessionId: session.sessionId, + workspaceId: session.workspaceId, + paneId: session.paneId, + isAlive: session.isAlive, + attachedClients: session.clientCount, + })); + + return { sessions }; + } + + /** + * Clear scrollback for a session + */ + clearScrollback(request: ClearScrollbackRequest): EmptyResponse { + const session = this.getSession(request.sessionId); + session.clearScrollback(); + return { success: true }; + } + + /** + * Clean up all sessions on shutdown + */ + dispose(): void { + for (const session of this.sessions.values()) { + session.dispose(); + } + this.sessions.clear(); + } + + // =========================================================================== + // Private Methods + // =========================================================================== + + /** + * Get a session by ID, throw if not found + */ + private getSession(sessionId: string): Session { + const session = this.sessions.get(sessionId); + if (!session) { + throw new Error(`Session not found: ${sessionId}`); + } + return session; + } + + /** + * Handle session exit + */ + private handleSessionExit( + sessionId: string, + _exitCode: number, + _signal?: number, + ): void { + // Keep session around for a bit so clients can see exit status + // Then clean up + setTimeout(() => { + const session = this.sessions.get(sessionId); + if (session && !session.isAlive && session.clientCount === 0) { + session.dispose(); + this.sessions.delete(sessionId); + } + }, 5000); + } +} diff --git a/bun.lock b/bun.lock index 4b961cccc2d..23d7b50fbfd 100644 --- a/bun.lock +++ b/bun.lock @@ -156,6 +156,7 @@ "@xterm/addon-unicode11": "^0.8.0", "@xterm/addon-web-links": "^0.11.0", "@xterm/addon-webgl": "^0.18.0", + "@xterm/headless": "^5.5.0", "@xterm/xterm": "^5.5.0", "better-sqlite3": "12.5.0", "bindings": "^1.5.0", @@ -1635,6 +1636,8 @@ "@xterm/addon-webgl": ["@xterm/addon-webgl@0.18.0", "", { "peerDependencies": { "@xterm/xterm": "^5.0.0" } }, "sha512-xCnfMBTI+/HKPdRnSOHaJDRqEpq2Ugy8LEj9GiY4J3zJObo3joylIFaMvzBwbYRg8zLtkO0KQaStCeSfoaI2/w=="], + "@xterm/headless": ["@xterm/headless@5.5.0", "", {}, "sha512-5xXB7kdQlFBP82ViMJTwwEc3gKCLGKR/eoxQm4zge7GPBl86tCdI0IdPJjoKd8mUSFXz5V7i/25sfsEkP4j46g=="], + "@xterm/xterm": ["@xterm/xterm@5.5.0", "", {}, "sha512-hqJHYaQb5OptNunnyAnkHyM8aCjZ1MEIDTQu1iIbbTD/xops91NB5yq1ZK/dC2JDbVWtF23zUtl9JE2NqwT87A=="], "@xtuc/ieee754": ["@xtuc/ieee754@1.2.0", "", {}, "sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA=="], From 56e2ae0c53d6f3093bcc8b75f5b839a0c578ac6e Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Mon, 29 Dec 2025 21:17:19 +0200 Subject: [PATCH 44/98] feat(desktop): add settings UI toggle and TUI mode rehydration - Add 'Terminal' settings section with persistence toggle - Settings UI allows enabling terminal persistence without env var - Add TRPC endpoints for terminalPersistence setting (get/set) - Add local-db migration for terminal_persistence column - isDaemonModeEnabled now reads from settings (cached at startup) - Apply rehydrateSequences in Terminal.tsx for TUI app restore - Env var SUPERSET_TERMINAL_DAEMON=1 still works as override --- .../src/lib/trpc/routers/settings/index.ts | 21 + apps/desktop/src/main/lib/terminal/index.ts | 52 +- .../SettingsView/SettingsContent.tsx | 2 + .../SettingsSidebar/GeneralSettings.tsx | 6 + .../SettingsView/TerminalSettings.tsx | 75 ++ .../TabsContent/Terminal/Terminal.tsx | 15 + apps/desktop/src/renderer/stores/app-state.ts | 3 +- ...004_add_terminal_link_behavior_setting.sql | 1 - .../0004_settings_workspace_improvements.sql | 4 + .../drizzle/0005_add_navigation_style.sql | 1 - ...0006_add_unique_branch_workspace_index.sql | 46 - .../drizzle/0007_add_workspace_is_unread.sql | 1 - .../local-db/drizzle/meta/0004_snapshot.json | 24 +- .../local-db/drizzle/meta/0005_snapshot.json | 984 ----------------- .../local-db/drizzle/meta/0006_snapshot.json | 984 ----------------- .../local-db/drizzle/meta/0007_snapshot.json | 992 ------------------ packages/local-db/drizzle/meta/_journal.json | 25 +- packages/local-db/src/schema/schema.ts | 1 + 18 files changed, 190 insertions(+), 3047 deletions(-) create mode 100644 apps/desktop/src/renderer/screens/main/components/SettingsView/TerminalSettings.tsx delete mode 100644 packages/local-db/drizzle/0004_add_terminal_link_behavior_setting.sql create mode 100644 packages/local-db/drizzle/0004_settings_workspace_improvements.sql delete mode 100644 packages/local-db/drizzle/0005_add_navigation_style.sql delete mode 100644 packages/local-db/drizzle/0006_add_unique_branch_workspace_index.sql delete mode 100644 packages/local-db/drizzle/0007_add_workspace_is_unread.sql delete mode 100644 packages/local-db/drizzle/meta/0005_snapshot.json delete mode 100644 packages/local-db/drizzle/meta/0006_snapshot.json delete mode 100644 packages/local-db/drizzle/meta/0007_snapshot.json diff --git a/apps/desktop/src/lib/trpc/routers/settings/index.ts b/apps/desktop/src/lib/trpc/routers/settings/index.ts index abc5cd8f903..c75eab773cd 100644 --- a/apps/desktop/src/lib/trpc/routers/settings/index.ts +++ b/apps/desktop/src/lib/trpc/routers/settings/index.ts @@ -228,5 +228,26 @@ export const createSettingsRouter = () => { return { success: true }; }), + + getTerminalPersistence: publicProcedure.query(() => { + const row = getSettings(); + // Default to false (terminal persistence disabled by default) + return row.terminalPersistence ?? false; + }), + + setTerminalPersistence: publicProcedure + .input(z.object({ enabled: z.boolean() })) + .mutation(({ input }) => { + localDb + .insert(settings) + .values({ id: 1, terminalPersistence: input.enabled }) + .onConflictDoUpdate({ + target: settings.id, + set: { terminalPersistence: input.enabled }, + }) + .run(); + + return { success: true }; + }), }); }; diff --git a/apps/desktop/src/main/lib/terminal/index.ts b/apps/desktop/src/main/lib/terminal/index.ts index 0786956d98e..8d71a4fcc32 100644 --- a/apps/desktop/src/main/lib/terminal/index.ts +++ b/apps/desktop/src/main/lib/terminal/index.ts @@ -1,3 +1,5 @@ +import { settings } from "@superset/local-db"; +import { localDb } from "main/lib/local-db"; import { DaemonTerminalManager, getDaemonTerminalManager, @@ -18,23 +20,47 @@ export type { // Terminal Manager Selection // ============================================================================= +// Cache the daemon mode setting to avoid repeated DB reads +// This is set once at app startup and doesn't change until restart +let cachedDaemonMode: boolean | null = null; + /** * Check if daemon mode is enabled. - * For now, this is controlled by an environment variable. - * Later, this will be read from user settings. + * Reads from user settings (terminalPersistence) or falls back to env var. + * The value is cached since it requires app restart to take effect. */ export function isDaemonModeEnabled(): boolean { - // Enable daemon mode via environment variable for testing - // In production, this will be read from user settings - // - // Note: SUPERSET_TERMINAL_DAEMON is baked in at build time via electron.vite.config.ts - // Set it before running `bun dev` or `bun build`: - // SUPERSET_TERMINAL_DAEMON=1 bun dev - const enabled = process.env.SUPERSET_TERMINAL_DAEMON === "1"; - console.log( - `[TerminalManager] Daemon mode: ${enabled ? "ENABLED" : "DISABLED"} (SUPERSET_TERMINAL_DAEMON="${process.env.SUPERSET_TERMINAL_DAEMON}")`, - ); - return enabled; + // Return cached value if available + if (cachedDaemonMode !== null) { + return cachedDaemonMode; + } + + // First check environment variable override (for development/testing) + if (process.env.SUPERSET_TERMINAL_DAEMON === "1") { + console.log( + "[TerminalManager] Daemon mode: ENABLED (via SUPERSET_TERMINAL_DAEMON env var)", + ); + cachedDaemonMode = true; + return true; + } + + // Read from user settings + try { + const row = localDb.select().from(settings).get(); + const enabled = row?.terminalPersistence ?? false; + console.log( + `[TerminalManager] Daemon mode: ${enabled ? "ENABLED" : "DISABLED"} (via settings.terminalPersistence)`, + ); + cachedDaemonMode = enabled; + return enabled; + } catch (error) { + console.warn( + "[TerminalManager] Failed to read settings, defaulting to disabled:", + error, + ); + cachedDaemonMode = false; + return false; + } } /** diff --git a/apps/desktop/src/renderer/screens/main/components/SettingsView/SettingsContent.tsx b/apps/desktop/src/renderer/screens/main/components/SettingsView/SettingsContent.tsx index 2af699cd289..e8cdd79e3d9 100644 --- a/apps/desktop/src/renderer/screens/main/components/SettingsView/SettingsContent.tsx +++ b/apps/desktop/src/renderer/screens/main/components/SettingsView/SettingsContent.tsx @@ -6,6 +6,7 @@ import { KeyboardShortcutsSettings } from "./KeyboardShortcutsSettings"; import { PresetsSettings } from "./PresetsSettings"; import { ProjectSettings } from "./ProjectSettings"; import { RingtonesSettings } from "./RingtonesSettings"; +import { TerminalSettings } from "./TerminalSettings"; import { WorkspaceSettings } from "./WorkspaceSettings"; interface SettingsContentProps { @@ -22,6 +23,7 @@ export function SettingsContent({ activeSection }: SettingsContentProps) { {activeSection === "ringtones" && } {activeSection === "keyboard" && } {activeSection === "presets" && } + {activeSection === "terminal" && } {activeSection === "behavior" && }
); diff --git a/apps/desktop/src/renderer/screens/main/components/SettingsView/SettingsSidebar/GeneralSettings.tsx b/apps/desktop/src/renderer/screens/main/components/SettingsView/SettingsSidebar/GeneralSettings.tsx index 7803fa3b11f..eea13a7db7c 100644 --- a/apps/desktop/src/renderer/screens/main/components/SettingsView/SettingsSidebar/GeneralSettings.tsx +++ b/apps/desktop/src/renderer/screens/main/components/SettingsView/SettingsSidebar/GeneralSettings.tsx @@ -4,6 +4,7 @@ import { HiOutlineBell, HiOutlineCog6Tooth, HiOutlineCommandLine, + HiOutlineComputerDesktop, HiOutlinePaintBrush, HiOutlineUser, } from "react-icons/hi2"; @@ -44,6 +45,11 @@ const GENERAL_SECTIONS: { label: "Presets", icon: , }, + { + id: "terminal", + label: "Terminal", + icon: , + }, { id: "behavior", label: "Behavior", diff --git a/apps/desktop/src/renderer/screens/main/components/SettingsView/TerminalSettings.tsx b/apps/desktop/src/renderer/screens/main/components/SettingsView/TerminalSettings.tsx new file mode 100644 index 00000000000..c93d97fe9d1 --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/SettingsView/TerminalSettings.tsx @@ -0,0 +1,75 @@ +import { Label } from "@superset/ui/label"; +import { Switch } from "@superset/ui/switch"; +import { trpc } from "renderer/lib/trpc"; + +export function TerminalSettings() { + const utils = trpc.useUtils(); + const { data: terminalPersistence, isLoading } = + trpc.settings.getTerminalPersistence.useQuery(); + const setTerminalPersistence = + trpc.settings.setTerminalPersistence.useMutation({ + onMutate: async ({ enabled }) => { + // Cancel outgoing fetches + await utils.settings.getTerminalPersistence.cancel(); + // Snapshot previous value + const previous = utils.settings.getTerminalPersistence.getData(); + // Optimistically update + utils.settings.getTerminalPersistence.setData(undefined, enabled); + return { previous }; + }, + onError: (_err, _vars, context) => { + // Rollback on error + if (context?.previous !== undefined) { + utils.settings.getTerminalPersistence.setData( + undefined, + context.previous, + ); + } + }, + onSettled: () => { + // Refetch to ensure sync with server + utils.settings.getTerminalPersistence.invalidate(); + }, + }); + + const handleToggle = (enabled: boolean) => { + setTerminalPersistence.mutate({ enabled }); + }; + + return ( +
+
+

Terminal

+

+ Configure terminal behavior and persistence +

+
+ +
+
+
+ +

+ Keep terminal sessions alive across app restarts. TUI apps like + Claude Code will resume exactly where you left off. +

+

+ Requires app restart to take effect. +

+
+ +
+
+
+ ); +} diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index bb4d776297e..f4f7359ef5e 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -314,9 +314,24 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { wasRecovered: boolean; isNew: boolean; scrollback: string; + snapshot?: { + snapshotAnsi: string; + rehydrateSequences: string; + cwd: string | null; + modes: Record; + cols: number; + rows: number; + scrollbackLines: number; + }; }) => { xterm.write(result.scrollback); updateCwdRef.current(result.scrollback); + + // Apply rehydration sequences to restore terminal modes (e.g., alternate screen for TUI apps) + // This must come after the scrollback content to properly restore the terminal state + if (result.snapshot?.rehydrateSequences) { + xterm.write(result.snapshot.rehydrateSequences); + } }; const restartTerminal = () => { diff --git a/apps/desktop/src/renderer/stores/app-state.ts b/apps/desktop/src/renderer/stores/app-state.ts index 296752c34d8..613d68052af 100644 --- a/apps/desktop/src/renderer/stores/app-state.ts +++ b/apps/desktop/src/renderer/stores/app-state.ts @@ -10,7 +10,8 @@ export type SettingsSection = | "keyboard" | "presets" | "ringtones" - | "behavior"; + | "behavior" + | "terminal"; interface AppState { currentView: AppView; diff --git a/packages/local-db/drizzle/0004_add_terminal_link_behavior_setting.sql b/packages/local-db/drizzle/0004_add_terminal_link_behavior_setting.sql deleted file mode 100644 index ad70f21f3fe..00000000000 --- a/packages/local-db/drizzle/0004_add_terminal_link_behavior_setting.sql +++ /dev/null @@ -1 +0,0 @@ -ALTER TABLE `settings` ADD `terminal_link_behavior` text; \ No newline at end of file diff --git a/packages/local-db/drizzle/0004_settings_workspace_improvements.sql b/packages/local-db/drizzle/0004_settings_workspace_improvements.sql new file mode 100644 index 00000000000..cd5007742b4 --- /dev/null +++ b/packages/local-db/drizzle/0004_settings_workspace_improvements.sql @@ -0,0 +1,4 @@ +ALTER TABLE `settings` ADD `terminal_link_behavior` text;--> statement-breakpoint +ALTER TABLE `settings` ADD `navigation_style` text;--> statement-breakpoint +ALTER TABLE `settings` ADD `terminal_persistence` integer;--> statement-breakpoint +ALTER TABLE `workspaces` ADD `is_unread` integer DEFAULT false; \ No newline at end of file diff --git a/packages/local-db/drizzle/0005_add_navigation_style.sql b/packages/local-db/drizzle/0005_add_navigation_style.sql deleted file mode 100644 index c3c175a0327..00000000000 --- a/packages/local-db/drizzle/0005_add_navigation_style.sql +++ /dev/null @@ -1 +0,0 @@ -ALTER TABLE `settings` ADD `navigation_style` text; \ No newline at end of file diff --git a/packages/local-db/drizzle/0006_add_unique_branch_workspace_index.sql b/packages/local-db/drizzle/0006_add_unique_branch_workspace_index.sql deleted file mode 100644 index 6945d545ce6..00000000000 --- a/packages/local-db/drizzle/0006_add_unique_branch_workspace_index.sql +++ /dev/null @@ -1,46 +0,0 @@ --- Dedupe existing duplicate branch workspaces before creating unique index. --- Keep the most recently used one (highest last_opened_at), with id ASC as tiebreaker. --- First, update settings.last_active_workspace_id if it points to a workspace we're about to delete -UPDATE settings -SET last_active_workspace_id = ( - SELECT w1.id FROM workspaces w1 - WHERE w1.type = 'branch' - AND w1.project_id = ( - SELECT w2.project_id FROM workspaces w2 WHERE w2.id = settings.last_active_workspace_id - ) - ORDER BY w1.last_opened_at DESC NULLS LAST, w1.id ASC - LIMIT 1 -) -WHERE last_active_workspace_id IN ( - SELECT w1.id FROM workspaces w1 - WHERE w1.type = 'branch' - AND EXISTS ( - SELECT 1 FROM workspaces w2 - WHERE w2.type = 'branch' - AND w2.project_id = w1.project_id - AND ( - w2.last_opened_at > w1.last_opened_at - OR (w2.last_opened_at = w1.last_opened_at AND w2.id < w1.id) - OR (w2.last_opened_at IS NOT NULL AND w1.last_opened_at IS NULL) - ) - ) -); - --- Delete duplicate branch workspaces, keeping the most recently used per project --- Survivor selection: highest last_opened_at, then lowest id as tiebreaker -DELETE FROM workspaces -WHERE type = 'branch' -AND id NOT IN ( - SELECT id FROM ( - SELECT id, ROW_NUMBER() OVER ( - PARTITION BY project_id - ORDER BY last_opened_at DESC NULLS LAST, id ASC - ) as rn - FROM workspaces - WHERE type = 'branch' - ) ranked - WHERE rn = 1 -); - --- Now safe to create the unique index -CREATE UNIQUE INDEX IF NOT EXISTS `workspaces_unique_branch_per_project` ON `workspaces` (`project_id`) WHERE `type` = 'branch'; diff --git a/packages/local-db/drizzle/0007_add_workspace_is_unread.sql b/packages/local-db/drizzle/0007_add_workspace_is_unread.sql deleted file mode 100644 index 9f3ca8ec300..00000000000 --- a/packages/local-db/drizzle/0007_add_workspace_is_unread.sql +++ /dev/null @@ -1 +0,0 @@ -ALTER TABLE `workspaces` ADD `is_unread` integer DEFAULT false; diff --git a/packages/local-db/drizzle/meta/0004_snapshot.json b/packages/local-db/drizzle/meta/0004_snapshot.json index 991b5469eb5..a51da6b146a 100644 --- a/packages/local-db/drizzle/meta/0004_snapshot.json +++ b/packages/local-db/drizzle/meta/0004_snapshot.json @@ -1,7 +1,7 @@ { "version": "6", "dialect": "sqlite", - "id": "bb9f9f85-bcbb-4003-b20f-4c172a1c6fc8", + "id": "334d24a4-5204-4d61-904a-bdd0498a401d", "prevId": "d5a52ac9-bc1e-4529-89bf-5748d4df5006", "tables": { "organization_members": { @@ -340,6 +340,20 @@ "primaryKey": false, "notNull": false, "autoincrement": false + }, + "navigation_style": { + "name": "navigation_style", + "type": "text", + "primaryKey": false, + "notNull": false, + "autoincrement": false + }, + "terminal_persistence": { + "name": "terminal_persistence", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false } }, "indexes": {}, @@ -811,6 +825,14 @@ "primaryKey": false, "notNull": true, "autoincrement": false + }, + "is_unread": { + "name": "is_unread", + "type": "integer", + "primaryKey": false, + "notNull": false, + "autoincrement": false, + "default": false } }, "indexes": { diff --git a/packages/local-db/drizzle/meta/0005_snapshot.json b/packages/local-db/drizzle/meta/0005_snapshot.json deleted file mode 100644 index 14c02c328fd..00000000000 --- a/packages/local-db/drizzle/meta/0005_snapshot.json +++ /dev/null @@ -1,984 +0,0 @@ -{ - "version": "6", - "dialect": "sqlite", - "id": "ac200b80-657f-4cd7-b338-2d6adeb925e7", - "prevId": "bb9f9f85-bcbb-4003-b20f-4c172a1c6fc8", - "tables": { - "organization_members": { - "name": "organization_members", - "columns": { - "id": { - "name": "id", - "type": "text", - "primaryKey": true, - "notNull": true, - "autoincrement": false - }, - "organization_id": { - "name": "organization_id", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "user_id": { - "name": "user_id", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "role": { - "name": "role", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "created_at": { - "name": "created_at", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - } - }, - "indexes": { - "organization_members_organization_id_idx": { - "name": "organization_members_organization_id_idx", - "columns": [ - "organization_id" - ], - "isUnique": false - }, - "organization_members_user_id_idx": { - "name": "organization_members_user_id_idx", - "columns": [ - "user_id" - ], - "isUnique": false - } - }, - "foreignKeys": { - "organization_members_organization_id_organizations_id_fk": { - "name": "organization_members_organization_id_organizations_id_fk", - "tableFrom": "organization_members", - "tableTo": "organizations", - "columnsFrom": [ - "organization_id" - ], - "columnsTo": [ - "id" - ], - "onDelete": "cascade", - "onUpdate": "no action" - }, - "organization_members_user_id_users_id_fk": { - "name": "organization_members_user_id_users_id_fk", - "tableFrom": "organization_members", - "tableTo": "users", - "columnsFrom": [ - "user_id" - ], - "columnsTo": [ - "id" - ], - "onDelete": "cascade", - "onUpdate": "no action" - } - }, - "compositePrimaryKeys": {}, - "uniqueConstraints": {}, - "checkConstraints": {} - }, - "organizations": { - "name": "organizations", - "columns": { - "id": { - "name": "id", - "type": "text", - "primaryKey": true, - "notNull": true, - "autoincrement": false - }, - "clerk_org_id": { - "name": "clerk_org_id", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "name": { - "name": "name", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "slug": { - "name": "slug", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "github_org": { - "name": "github_org", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "avatar_url": { - "name": "avatar_url", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "created_at": { - "name": "created_at", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "updated_at": { - "name": "updated_at", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - } - }, - "indexes": { - "organizations_clerk_org_id_unique": { - "name": "organizations_clerk_org_id_unique", - "columns": [ - "clerk_org_id" - ], - "isUnique": true - }, - "organizations_slug_unique": { - "name": "organizations_slug_unique", - "columns": [ - "slug" - ], - "isUnique": true - }, - "organizations_slug_idx": { - "name": "organizations_slug_idx", - "columns": [ - "slug" - ], - "isUnique": false - }, - "organizations_clerk_org_id_idx": { - "name": "organizations_clerk_org_id_idx", - "columns": [ - "clerk_org_id" - ], - "isUnique": false - } - }, - "foreignKeys": {}, - "compositePrimaryKeys": {}, - "uniqueConstraints": {}, - "checkConstraints": {} - }, - "projects": { - "name": "projects", - "columns": { - "id": { - "name": "id", - "type": "text", - "primaryKey": true, - "notNull": true, - "autoincrement": false - }, - "main_repo_path": { - "name": "main_repo_path", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "name": { - "name": "name", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "color": { - "name": "color", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "tab_order": { - "name": "tab_order", - "type": "integer", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "last_opened_at": { - "name": "last_opened_at", - "type": "integer", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "created_at": { - "name": "created_at", - "type": "integer", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "config_toast_dismissed": { - "name": "config_toast_dismissed", - "type": "integer", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "default_branch": { - "name": "default_branch", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - } - }, - "indexes": { - "projects_main_repo_path_idx": { - "name": "projects_main_repo_path_idx", - "columns": [ - "main_repo_path" - ], - "isUnique": false - }, - "projects_last_opened_at_idx": { - "name": "projects_last_opened_at_idx", - "columns": [ - "last_opened_at" - ], - "isUnique": false - } - }, - "foreignKeys": {}, - "compositePrimaryKeys": {}, - "uniqueConstraints": {}, - "checkConstraints": {} - }, - "settings": { - "name": "settings", - "columns": { - "id": { - "name": "id", - "type": "integer", - "primaryKey": true, - "notNull": true, - "autoincrement": false, - "default": 1 - }, - "last_active_workspace_id": { - "name": "last_active_workspace_id", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "last_used_app": { - "name": "last_used_app", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "terminal_presets": { - "name": "terminal_presets", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "terminal_presets_initialized": { - "name": "terminal_presets_initialized", - "type": "integer", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "selected_ringtone_id": { - "name": "selected_ringtone_id", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "active_organization_id": { - "name": "active_organization_id", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "confirm_on_quit": { - "name": "confirm_on_quit", - "type": "integer", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "terminal_link_behavior": { - "name": "terminal_link_behavior", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "navigation_style": { - "name": "navigation_style", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - } - }, - "indexes": {}, - "foreignKeys": {}, - "compositePrimaryKeys": {}, - "uniqueConstraints": {}, - "checkConstraints": {} - }, - "tasks": { - "name": "tasks", - "columns": { - "id": { - "name": "id", - "type": "text", - "primaryKey": true, - "notNull": true, - "autoincrement": false - }, - "slug": { - "name": "slug", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "title": { - "name": "title", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "description": { - "name": "description", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "status": { - "name": "status", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "status_color": { - "name": "status_color", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "status_type": { - "name": "status_type", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "status_position": { - "name": "status_position", - "type": "integer", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "priority": { - "name": "priority", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "organization_id": { - "name": "organization_id", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "repository_id": { - "name": "repository_id", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "assignee_id": { - "name": "assignee_id", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "creator_id": { - "name": "creator_id", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "estimate": { - "name": "estimate", - "type": "integer", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "due_date": { - "name": "due_date", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "labels": { - "name": "labels", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "branch": { - "name": "branch", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "pr_url": { - "name": "pr_url", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "external_provider": { - "name": "external_provider", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "external_id": { - "name": "external_id", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "external_key": { - "name": "external_key", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "external_url": { - "name": "external_url", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "last_synced_at": { - "name": "last_synced_at", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "sync_error": { - "name": "sync_error", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "started_at": { - "name": "started_at", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "completed_at": { - "name": "completed_at", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "deleted_at": { - "name": "deleted_at", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "created_at": { - "name": "created_at", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "updated_at": { - "name": "updated_at", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - } - }, - "indexes": { - "tasks_slug_unique": { - "name": "tasks_slug_unique", - "columns": [ - "slug" - ], - "isUnique": true - }, - "tasks_slug_idx": { - "name": "tasks_slug_idx", - "columns": [ - "slug" - ], - "isUnique": false - }, - "tasks_organization_id_idx": { - "name": "tasks_organization_id_idx", - "columns": [ - "organization_id" - ], - "isUnique": false - }, - "tasks_assignee_id_idx": { - "name": "tasks_assignee_id_idx", - "columns": [ - "assignee_id" - ], - "isUnique": false - }, - "tasks_status_idx": { - "name": "tasks_status_idx", - "columns": [ - "status" - ], - "isUnique": false - }, - "tasks_created_at_idx": { - "name": "tasks_created_at_idx", - "columns": [ - "created_at" - ], - "isUnique": false - } - }, - "foreignKeys": { - "tasks_organization_id_organizations_id_fk": { - "name": "tasks_organization_id_organizations_id_fk", - "tableFrom": "tasks", - "tableTo": "organizations", - "columnsFrom": [ - "organization_id" - ], - "columnsTo": [ - "id" - ], - "onDelete": "cascade", - "onUpdate": "no action" - }, - "tasks_assignee_id_users_id_fk": { - "name": "tasks_assignee_id_users_id_fk", - "tableFrom": "tasks", - "tableTo": "users", - "columnsFrom": [ - "assignee_id" - ], - "columnsTo": [ - "id" - ], - "onDelete": "set null", - "onUpdate": "no action" - }, - "tasks_creator_id_users_id_fk": { - "name": "tasks_creator_id_users_id_fk", - "tableFrom": "tasks", - "tableTo": "users", - "columnsFrom": [ - "creator_id" - ], - "columnsTo": [ - "id" - ], - "onDelete": "cascade", - "onUpdate": "no action" - } - }, - "compositePrimaryKeys": {}, - "uniqueConstraints": {}, - "checkConstraints": {} - }, - "users": { - "name": "users", - "columns": { - "id": { - "name": "id", - "type": "text", - "primaryKey": true, - "notNull": true, - "autoincrement": false - }, - "clerk_id": { - "name": "clerk_id", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "name": { - "name": "name", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "email": { - "name": "email", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "avatar_url": { - "name": "avatar_url", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "deleted_at": { - "name": "deleted_at", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "created_at": { - "name": "created_at", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "updated_at": { - "name": "updated_at", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - } - }, - "indexes": { - "users_clerk_id_unique": { - "name": "users_clerk_id_unique", - "columns": [ - "clerk_id" - ], - "isUnique": true - }, - "users_email_unique": { - "name": "users_email_unique", - "columns": [ - "email" - ], - "isUnique": true - }, - "users_email_idx": { - "name": "users_email_idx", - "columns": [ - "email" - ], - "isUnique": false - }, - "users_clerk_id_idx": { - "name": "users_clerk_id_idx", - "columns": [ - "clerk_id" - ], - "isUnique": false - } - }, - "foreignKeys": {}, - "compositePrimaryKeys": {}, - "uniqueConstraints": {}, - "checkConstraints": {} - }, - "workspaces": { - "name": "workspaces", - "columns": { - "id": { - "name": "id", - "type": "text", - "primaryKey": true, - "notNull": true, - "autoincrement": false - }, - "project_id": { - "name": "project_id", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "worktree_id": { - "name": "worktree_id", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "type": { - "name": "type", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "branch": { - "name": "branch", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "name": { - "name": "name", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "tab_order": { - "name": "tab_order", - "type": "integer", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "created_at": { - "name": "created_at", - "type": "integer", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "updated_at": { - "name": "updated_at", - "type": "integer", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "last_opened_at": { - "name": "last_opened_at", - "type": "integer", - "primaryKey": false, - "notNull": true, - "autoincrement": false - } - }, - "indexes": { - "workspaces_project_id_idx": { - "name": "workspaces_project_id_idx", - "columns": [ - "project_id" - ], - "isUnique": false - }, - "workspaces_worktree_id_idx": { - "name": "workspaces_worktree_id_idx", - "columns": [ - "worktree_id" - ], - "isUnique": false - }, - "workspaces_last_opened_at_idx": { - "name": "workspaces_last_opened_at_idx", - "columns": [ - "last_opened_at" - ], - "isUnique": false - } - }, - "foreignKeys": { - "workspaces_project_id_projects_id_fk": { - "name": "workspaces_project_id_projects_id_fk", - "tableFrom": "workspaces", - "tableTo": "projects", - "columnsFrom": [ - "project_id" - ], - "columnsTo": [ - "id" - ], - "onDelete": "cascade", - "onUpdate": "no action" - }, - "workspaces_worktree_id_worktrees_id_fk": { - "name": "workspaces_worktree_id_worktrees_id_fk", - "tableFrom": "workspaces", - "tableTo": "worktrees", - "columnsFrom": [ - "worktree_id" - ], - "columnsTo": [ - "id" - ], - "onDelete": "cascade", - "onUpdate": "no action" - } - }, - "compositePrimaryKeys": {}, - "uniqueConstraints": {}, - "checkConstraints": {} - }, - "worktrees": { - "name": "worktrees", - "columns": { - "id": { - "name": "id", - "type": "text", - "primaryKey": true, - "notNull": true, - "autoincrement": false - }, - "project_id": { - "name": "project_id", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "path": { - "name": "path", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "branch": { - "name": "branch", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "base_branch": { - "name": "base_branch", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "created_at": { - "name": "created_at", - "type": "integer", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "git_status": { - "name": "git_status", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "github_status": { - "name": "github_status", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - } - }, - "indexes": { - "worktrees_project_id_idx": { - "name": "worktrees_project_id_idx", - "columns": [ - "project_id" - ], - "isUnique": false - }, - "worktrees_branch_idx": { - "name": "worktrees_branch_idx", - "columns": [ - "branch" - ], - "isUnique": false - } - }, - "foreignKeys": { - "worktrees_project_id_projects_id_fk": { - "name": "worktrees_project_id_projects_id_fk", - "tableFrom": "worktrees", - "tableTo": "projects", - "columnsFrom": [ - "project_id" - ], - "columnsTo": [ - "id" - ], - "onDelete": "cascade", - "onUpdate": "no action" - } - }, - "compositePrimaryKeys": {}, - "uniqueConstraints": {}, - "checkConstraints": {} - } - }, - "views": {}, - "enums": {}, - "_meta": { - "schemas": {}, - "tables": {}, - "columns": {} - }, - "internal": { - "indexes": {} - } -} \ No newline at end of file diff --git a/packages/local-db/drizzle/meta/0006_snapshot.json b/packages/local-db/drizzle/meta/0006_snapshot.json deleted file mode 100644 index 5362480f6e2..00000000000 --- a/packages/local-db/drizzle/meta/0006_snapshot.json +++ /dev/null @@ -1,984 +0,0 @@ -{ - "version": "6", - "dialect": "sqlite", - "id": "f1e2d3c4-b5a6-7890-abcd-ef1234567890", - "prevId": "ac200b80-657f-4cd7-b338-2d6adeb925e7", - "tables": { - "organization_members": { - "name": "organization_members", - "columns": { - "id": { - "name": "id", - "type": "text", - "primaryKey": true, - "notNull": true, - "autoincrement": false - }, - "organization_id": { - "name": "organization_id", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "user_id": { - "name": "user_id", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "role": { - "name": "role", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "created_at": { - "name": "created_at", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - } - }, - "indexes": { - "organization_members_organization_id_idx": { - "name": "organization_members_organization_id_idx", - "columns": [ - "organization_id" - ], - "isUnique": false - }, - "organization_members_user_id_idx": { - "name": "organization_members_user_id_idx", - "columns": [ - "user_id" - ], - "isUnique": false - } - }, - "foreignKeys": { - "organization_members_organization_id_organizations_id_fk": { - "name": "organization_members_organization_id_organizations_id_fk", - "tableFrom": "organization_members", - "tableTo": "organizations", - "columnsFrom": [ - "organization_id" - ], - "columnsTo": [ - "id" - ], - "onDelete": "cascade", - "onUpdate": "no action" - }, - "organization_members_user_id_users_id_fk": { - "name": "organization_members_user_id_users_id_fk", - "tableFrom": "organization_members", - "tableTo": "users", - "columnsFrom": [ - "user_id" - ], - "columnsTo": [ - "id" - ], - "onDelete": "cascade", - "onUpdate": "no action" - } - }, - "compositePrimaryKeys": {}, - "uniqueConstraints": {}, - "checkConstraints": {} - }, - "organizations": { - "name": "organizations", - "columns": { - "id": { - "name": "id", - "type": "text", - "primaryKey": true, - "notNull": true, - "autoincrement": false - }, - "clerk_org_id": { - "name": "clerk_org_id", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "name": { - "name": "name", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "slug": { - "name": "slug", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "github_org": { - "name": "github_org", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "avatar_url": { - "name": "avatar_url", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "created_at": { - "name": "created_at", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "updated_at": { - "name": "updated_at", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - } - }, - "indexes": { - "organizations_clerk_org_id_unique": { - "name": "organizations_clerk_org_id_unique", - "columns": [ - "clerk_org_id" - ], - "isUnique": true - }, - "organizations_slug_unique": { - "name": "organizations_slug_unique", - "columns": [ - "slug" - ], - "isUnique": true - }, - "organizations_slug_idx": { - "name": "organizations_slug_idx", - "columns": [ - "slug" - ], - "isUnique": false - }, - "organizations_clerk_org_id_idx": { - "name": "organizations_clerk_org_id_idx", - "columns": [ - "clerk_org_id" - ], - "isUnique": false - } - }, - "foreignKeys": {}, - "compositePrimaryKeys": {}, - "uniqueConstraints": {}, - "checkConstraints": {} - }, - "projects": { - "name": "projects", - "columns": { - "id": { - "name": "id", - "type": "text", - "primaryKey": true, - "notNull": true, - "autoincrement": false - }, - "main_repo_path": { - "name": "main_repo_path", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "name": { - "name": "name", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "color": { - "name": "color", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "tab_order": { - "name": "tab_order", - "type": "integer", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "last_opened_at": { - "name": "last_opened_at", - "type": "integer", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "created_at": { - "name": "created_at", - "type": "integer", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "config_toast_dismissed": { - "name": "config_toast_dismissed", - "type": "integer", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "default_branch": { - "name": "default_branch", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - } - }, - "indexes": { - "projects_main_repo_path_idx": { - "name": "projects_main_repo_path_idx", - "columns": [ - "main_repo_path" - ], - "isUnique": false - }, - "projects_last_opened_at_idx": { - "name": "projects_last_opened_at_idx", - "columns": [ - "last_opened_at" - ], - "isUnique": false - } - }, - "foreignKeys": {}, - "compositePrimaryKeys": {}, - "uniqueConstraints": {}, - "checkConstraints": {} - }, - "settings": { - "name": "settings", - "columns": { - "id": { - "name": "id", - "type": "integer", - "primaryKey": true, - "notNull": true, - "autoincrement": false, - "default": 1 - }, - "last_active_workspace_id": { - "name": "last_active_workspace_id", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "last_used_app": { - "name": "last_used_app", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "terminal_presets": { - "name": "terminal_presets", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "terminal_presets_initialized": { - "name": "terminal_presets_initialized", - "type": "integer", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "selected_ringtone_id": { - "name": "selected_ringtone_id", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "active_organization_id": { - "name": "active_organization_id", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "confirm_on_quit": { - "name": "confirm_on_quit", - "type": "integer", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "terminal_link_behavior": { - "name": "terminal_link_behavior", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "navigation_style": { - "name": "navigation_style", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - } - }, - "indexes": {}, - "foreignKeys": {}, - "compositePrimaryKeys": {}, - "uniqueConstraints": {}, - "checkConstraints": {} - }, - "tasks": { - "name": "tasks", - "columns": { - "id": { - "name": "id", - "type": "text", - "primaryKey": true, - "notNull": true, - "autoincrement": false - }, - "slug": { - "name": "slug", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "title": { - "name": "title", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "description": { - "name": "description", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "status": { - "name": "status", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "status_color": { - "name": "status_color", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "status_type": { - "name": "status_type", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "status_position": { - "name": "status_position", - "type": "integer", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "priority": { - "name": "priority", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "organization_id": { - "name": "organization_id", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "repository_id": { - "name": "repository_id", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "assignee_id": { - "name": "assignee_id", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "creator_id": { - "name": "creator_id", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "estimate": { - "name": "estimate", - "type": "integer", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "due_date": { - "name": "due_date", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "labels": { - "name": "labels", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "branch": { - "name": "branch", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "pr_url": { - "name": "pr_url", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "external_provider": { - "name": "external_provider", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "external_id": { - "name": "external_id", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "external_key": { - "name": "external_key", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "external_url": { - "name": "external_url", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "last_synced_at": { - "name": "last_synced_at", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "sync_error": { - "name": "sync_error", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "started_at": { - "name": "started_at", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "completed_at": { - "name": "completed_at", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "deleted_at": { - "name": "deleted_at", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "created_at": { - "name": "created_at", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "updated_at": { - "name": "updated_at", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - } - }, - "indexes": { - "tasks_slug_unique": { - "name": "tasks_slug_unique", - "columns": [ - "slug" - ], - "isUnique": true - }, - "tasks_slug_idx": { - "name": "tasks_slug_idx", - "columns": [ - "slug" - ], - "isUnique": false - }, - "tasks_organization_id_idx": { - "name": "tasks_organization_id_idx", - "columns": [ - "organization_id" - ], - "isUnique": false - }, - "tasks_assignee_id_idx": { - "name": "tasks_assignee_id_idx", - "columns": [ - "assignee_id" - ], - "isUnique": false - }, - "tasks_status_idx": { - "name": "tasks_status_idx", - "columns": [ - "status" - ], - "isUnique": false - }, - "tasks_created_at_idx": { - "name": "tasks_created_at_idx", - "columns": [ - "created_at" - ], - "isUnique": false - } - }, - "foreignKeys": { - "tasks_organization_id_organizations_id_fk": { - "name": "tasks_organization_id_organizations_id_fk", - "tableFrom": "tasks", - "tableTo": "organizations", - "columnsFrom": [ - "organization_id" - ], - "columnsTo": [ - "id" - ], - "onDelete": "cascade", - "onUpdate": "no action" - }, - "tasks_assignee_id_users_id_fk": { - "name": "tasks_assignee_id_users_id_fk", - "tableFrom": "tasks", - "tableTo": "users", - "columnsFrom": [ - "assignee_id" - ], - "columnsTo": [ - "id" - ], - "onDelete": "set null", - "onUpdate": "no action" - }, - "tasks_creator_id_users_id_fk": { - "name": "tasks_creator_id_users_id_fk", - "tableFrom": "tasks", - "tableTo": "users", - "columnsFrom": [ - "creator_id" - ], - "columnsTo": [ - "id" - ], - "onDelete": "cascade", - "onUpdate": "no action" - } - }, - "compositePrimaryKeys": {}, - "uniqueConstraints": {}, - "checkConstraints": {} - }, - "users": { - "name": "users", - "columns": { - "id": { - "name": "id", - "type": "text", - "primaryKey": true, - "notNull": true, - "autoincrement": false - }, - "clerk_id": { - "name": "clerk_id", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "name": { - "name": "name", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "email": { - "name": "email", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "avatar_url": { - "name": "avatar_url", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "deleted_at": { - "name": "deleted_at", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "created_at": { - "name": "created_at", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "updated_at": { - "name": "updated_at", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - } - }, - "indexes": { - "users_clerk_id_unique": { - "name": "users_clerk_id_unique", - "columns": [ - "clerk_id" - ], - "isUnique": true - }, - "users_email_unique": { - "name": "users_email_unique", - "columns": [ - "email" - ], - "isUnique": true - }, - "users_email_idx": { - "name": "users_email_idx", - "columns": [ - "email" - ], - "isUnique": false - }, - "users_clerk_id_idx": { - "name": "users_clerk_id_idx", - "columns": [ - "clerk_id" - ], - "isUnique": false - } - }, - "foreignKeys": {}, - "compositePrimaryKeys": {}, - "uniqueConstraints": {}, - "checkConstraints": {} - }, - "workspaces": { - "name": "workspaces", - "columns": { - "id": { - "name": "id", - "type": "text", - "primaryKey": true, - "notNull": true, - "autoincrement": false - }, - "project_id": { - "name": "project_id", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "worktree_id": { - "name": "worktree_id", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "type": { - "name": "type", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "branch": { - "name": "branch", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "name": { - "name": "name", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "tab_order": { - "name": "tab_order", - "type": "integer", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "created_at": { - "name": "created_at", - "type": "integer", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "updated_at": { - "name": "updated_at", - "type": "integer", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "last_opened_at": { - "name": "last_opened_at", - "type": "integer", - "primaryKey": false, - "notNull": true, - "autoincrement": false - } - }, - "indexes": { - "workspaces_project_id_idx": { - "name": "workspaces_project_id_idx", - "columns": [ - "project_id" - ], - "isUnique": false - }, - "workspaces_worktree_id_idx": { - "name": "workspaces_worktree_id_idx", - "columns": [ - "worktree_id" - ], - "isUnique": false - }, - "workspaces_last_opened_at_idx": { - "name": "workspaces_last_opened_at_idx", - "columns": [ - "last_opened_at" - ], - "isUnique": false - } - }, - "foreignKeys": { - "workspaces_project_id_projects_id_fk": { - "name": "workspaces_project_id_projects_id_fk", - "tableFrom": "workspaces", - "tableTo": "projects", - "columnsFrom": [ - "project_id" - ], - "columnsTo": [ - "id" - ], - "onDelete": "cascade", - "onUpdate": "no action" - }, - "workspaces_worktree_id_worktrees_id_fk": { - "name": "workspaces_worktree_id_worktrees_id_fk", - "tableFrom": "workspaces", - "tableTo": "worktrees", - "columnsFrom": [ - "worktree_id" - ], - "columnsTo": [ - "id" - ], - "onDelete": "cascade", - "onUpdate": "no action" - } - }, - "compositePrimaryKeys": {}, - "uniqueConstraints": {}, - "checkConstraints": {} - }, - "worktrees": { - "name": "worktrees", - "columns": { - "id": { - "name": "id", - "type": "text", - "primaryKey": true, - "notNull": true, - "autoincrement": false - }, - "project_id": { - "name": "project_id", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "path": { - "name": "path", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "branch": { - "name": "branch", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "base_branch": { - "name": "base_branch", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "created_at": { - "name": "created_at", - "type": "integer", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "git_status": { - "name": "git_status", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "github_status": { - "name": "github_status", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - } - }, - "indexes": { - "worktrees_project_id_idx": { - "name": "worktrees_project_id_idx", - "columns": [ - "project_id" - ], - "isUnique": false - }, - "worktrees_branch_idx": { - "name": "worktrees_branch_idx", - "columns": [ - "branch" - ], - "isUnique": false - } - }, - "foreignKeys": { - "worktrees_project_id_projects_id_fk": { - "name": "worktrees_project_id_projects_id_fk", - "tableFrom": "worktrees", - "tableTo": "projects", - "columnsFrom": [ - "project_id" - ], - "columnsTo": [ - "id" - ], - "onDelete": "cascade", - "onUpdate": "no action" - } - }, - "compositePrimaryKeys": {}, - "uniqueConstraints": {}, - "checkConstraints": {} - } - }, - "views": {}, - "enums": {}, - "_meta": { - "schemas": {}, - "tables": {}, - "columns": {} - }, - "internal": { - "indexes": {} - } -} diff --git a/packages/local-db/drizzle/meta/0007_snapshot.json b/packages/local-db/drizzle/meta/0007_snapshot.json deleted file mode 100644 index dbf24a697c3..00000000000 --- a/packages/local-db/drizzle/meta/0007_snapshot.json +++ /dev/null @@ -1,992 +0,0 @@ -{ - "version": "6", - "dialect": "sqlite", - "id": "a7b8c9d0-e1f2-3456-7890-abcdef123456", - "prevId": "f1e2d3c4-b5a6-7890-abcd-ef1234567890", - "tables": { - "organization_members": { - "name": "organization_members", - "columns": { - "id": { - "name": "id", - "type": "text", - "primaryKey": true, - "notNull": true, - "autoincrement": false - }, - "organization_id": { - "name": "organization_id", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "user_id": { - "name": "user_id", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "role": { - "name": "role", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "created_at": { - "name": "created_at", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - } - }, - "indexes": { - "organization_members_organization_id_idx": { - "name": "organization_members_organization_id_idx", - "columns": [ - "organization_id" - ], - "isUnique": false - }, - "organization_members_user_id_idx": { - "name": "organization_members_user_id_idx", - "columns": [ - "user_id" - ], - "isUnique": false - } - }, - "foreignKeys": { - "organization_members_organization_id_organizations_id_fk": { - "name": "organization_members_organization_id_organizations_id_fk", - "tableFrom": "organization_members", - "tableTo": "organizations", - "columnsFrom": [ - "organization_id" - ], - "columnsTo": [ - "id" - ], - "onDelete": "cascade", - "onUpdate": "no action" - }, - "organization_members_user_id_users_id_fk": { - "name": "organization_members_user_id_users_id_fk", - "tableFrom": "organization_members", - "tableTo": "users", - "columnsFrom": [ - "user_id" - ], - "columnsTo": [ - "id" - ], - "onDelete": "cascade", - "onUpdate": "no action" - } - }, - "compositePrimaryKeys": {}, - "uniqueConstraints": {}, - "checkConstraints": {} - }, - "organizations": { - "name": "organizations", - "columns": { - "id": { - "name": "id", - "type": "text", - "primaryKey": true, - "notNull": true, - "autoincrement": false - }, - "clerk_org_id": { - "name": "clerk_org_id", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "name": { - "name": "name", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "slug": { - "name": "slug", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "github_org": { - "name": "github_org", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "avatar_url": { - "name": "avatar_url", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "created_at": { - "name": "created_at", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "updated_at": { - "name": "updated_at", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - } - }, - "indexes": { - "organizations_clerk_org_id_unique": { - "name": "organizations_clerk_org_id_unique", - "columns": [ - "clerk_org_id" - ], - "isUnique": true - }, - "organizations_slug_unique": { - "name": "organizations_slug_unique", - "columns": [ - "slug" - ], - "isUnique": true - }, - "organizations_slug_idx": { - "name": "organizations_slug_idx", - "columns": [ - "slug" - ], - "isUnique": false - }, - "organizations_clerk_org_id_idx": { - "name": "organizations_clerk_org_id_idx", - "columns": [ - "clerk_org_id" - ], - "isUnique": false - } - }, - "foreignKeys": {}, - "compositePrimaryKeys": {}, - "uniqueConstraints": {}, - "checkConstraints": {} - }, - "projects": { - "name": "projects", - "columns": { - "id": { - "name": "id", - "type": "text", - "primaryKey": true, - "notNull": true, - "autoincrement": false - }, - "main_repo_path": { - "name": "main_repo_path", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "name": { - "name": "name", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "color": { - "name": "color", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "tab_order": { - "name": "tab_order", - "type": "integer", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "last_opened_at": { - "name": "last_opened_at", - "type": "integer", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "created_at": { - "name": "created_at", - "type": "integer", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "config_toast_dismissed": { - "name": "config_toast_dismissed", - "type": "integer", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "default_branch": { - "name": "default_branch", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - } - }, - "indexes": { - "projects_main_repo_path_idx": { - "name": "projects_main_repo_path_idx", - "columns": [ - "main_repo_path" - ], - "isUnique": false - }, - "projects_last_opened_at_idx": { - "name": "projects_last_opened_at_idx", - "columns": [ - "last_opened_at" - ], - "isUnique": false - } - }, - "foreignKeys": {}, - "compositePrimaryKeys": {}, - "uniqueConstraints": {}, - "checkConstraints": {} - }, - "settings": { - "name": "settings", - "columns": { - "id": { - "name": "id", - "type": "integer", - "primaryKey": true, - "notNull": true, - "autoincrement": false, - "default": 1 - }, - "last_active_workspace_id": { - "name": "last_active_workspace_id", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "last_used_app": { - "name": "last_used_app", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "terminal_presets": { - "name": "terminal_presets", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "terminal_presets_initialized": { - "name": "terminal_presets_initialized", - "type": "integer", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "selected_ringtone_id": { - "name": "selected_ringtone_id", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "active_organization_id": { - "name": "active_organization_id", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "confirm_on_quit": { - "name": "confirm_on_quit", - "type": "integer", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "terminal_link_behavior": { - "name": "terminal_link_behavior", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "navigation_style": { - "name": "navigation_style", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - } - }, - "indexes": {}, - "foreignKeys": {}, - "compositePrimaryKeys": {}, - "uniqueConstraints": {}, - "checkConstraints": {} - }, - "tasks": { - "name": "tasks", - "columns": { - "id": { - "name": "id", - "type": "text", - "primaryKey": true, - "notNull": true, - "autoincrement": false - }, - "slug": { - "name": "slug", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "title": { - "name": "title", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "description": { - "name": "description", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "status": { - "name": "status", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "status_color": { - "name": "status_color", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "status_type": { - "name": "status_type", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "status_position": { - "name": "status_position", - "type": "integer", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "priority": { - "name": "priority", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "organization_id": { - "name": "organization_id", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "repository_id": { - "name": "repository_id", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "assignee_id": { - "name": "assignee_id", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "creator_id": { - "name": "creator_id", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "estimate": { - "name": "estimate", - "type": "integer", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "due_date": { - "name": "due_date", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "labels": { - "name": "labels", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "branch": { - "name": "branch", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "pr_url": { - "name": "pr_url", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "external_provider": { - "name": "external_provider", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "external_id": { - "name": "external_id", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "external_key": { - "name": "external_key", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "external_url": { - "name": "external_url", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "last_synced_at": { - "name": "last_synced_at", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "sync_error": { - "name": "sync_error", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "started_at": { - "name": "started_at", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "completed_at": { - "name": "completed_at", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "deleted_at": { - "name": "deleted_at", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "created_at": { - "name": "created_at", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "updated_at": { - "name": "updated_at", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - } - }, - "indexes": { - "tasks_slug_unique": { - "name": "tasks_slug_unique", - "columns": [ - "slug" - ], - "isUnique": true - }, - "tasks_slug_idx": { - "name": "tasks_slug_idx", - "columns": [ - "slug" - ], - "isUnique": false - }, - "tasks_organization_id_idx": { - "name": "tasks_organization_id_idx", - "columns": [ - "organization_id" - ], - "isUnique": false - }, - "tasks_assignee_id_idx": { - "name": "tasks_assignee_id_idx", - "columns": [ - "assignee_id" - ], - "isUnique": false - }, - "tasks_status_idx": { - "name": "tasks_status_idx", - "columns": [ - "status" - ], - "isUnique": false - }, - "tasks_created_at_idx": { - "name": "tasks_created_at_idx", - "columns": [ - "created_at" - ], - "isUnique": false - } - }, - "foreignKeys": { - "tasks_organization_id_organizations_id_fk": { - "name": "tasks_organization_id_organizations_id_fk", - "tableFrom": "tasks", - "tableTo": "organizations", - "columnsFrom": [ - "organization_id" - ], - "columnsTo": [ - "id" - ], - "onDelete": "cascade", - "onUpdate": "no action" - }, - "tasks_assignee_id_users_id_fk": { - "name": "tasks_assignee_id_users_id_fk", - "tableFrom": "tasks", - "tableTo": "users", - "columnsFrom": [ - "assignee_id" - ], - "columnsTo": [ - "id" - ], - "onDelete": "set null", - "onUpdate": "no action" - }, - "tasks_creator_id_users_id_fk": { - "name": "tasks_creator_id_users_id_fk", - "tableFrom": "tasks", - "tableTo": "users", - "columnsFrom": [ - "creator_id" - ], - "columnsTo": [ - "id" - ], - "onDelete": "cascade", - "onUpdate": "no action" - } - }, - "compositePrimaryKeys": {}, - "uniqueConstraints": {}, - "checkConstraints": {} - }, - "users": { - "name": "users", - "columns": { - "id": { - "name": "id", - "type": "text", - "primaryKey": true, - "notNull": true, - "autoincrement": false - }, - "clerk_id": { - "name": "clerk_id", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "name": { - "name": "name", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "email": { - "name": "email", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "avatar_url": { - "name": "avatar_url", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "deleted_at": { - "name": "deleted_at", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "created_at": { - "name": "created_at", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "updated_at": { - "name": "updated_at", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - } - }, - "indexes": { - "users_clerk_id_unique": { - "name": "users_clerk_id_unique", - "columns": [ - "clerk_id" - ], - "isUnique": true - }, - "users_email_unique": { - "name": "users_email_unique", - "columns": [ - "email" - ], - "isUnique": true - }, - "users_email_idx": { - "name": "users_email_idx", - "columns": [ - "email" - ], - "isUnique": false - }, - "users_clerk_id_idx": { - "name": "users_clerk_id_idx", - "columns": [ - "clerk_id" - ], - "isUnique": false - } - }, - "foreignKeys": {}, - "compositePrimaryKeys": {}, - "uniqueConstraints": {}, - "checkConstraints": {} - }, - "workspaces": { - "name": "workspaces", - "columns": { - "id": { - "name": "id", - "type": "text", - "primaryKey": true, - "notNull": true, - "autoincrement": false - }, - "project_id": { - "name": "project_id", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "worktree_id": { - "name": "worktree_id", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "type": { - "name": "type", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "branch": { - "name": "branch", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "name": { - "name": "name", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "tab_order": { - "name": "tab_order", - "type": "integer", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "created_at": { - "name": "created_at", - "type": "integer", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "updated_at": { - "name": "updated_at", - "type": "integer", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "last_opened_at": { - "name": "last_opened_at", - "type": "integer", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "is_unread": { - "name": "is_unread", - "type": "integer", - "primaryKey": false, - "notNull": false, - "autoincrement": false, - "default": false - } - }, - "indexes": { - "workspaces_project_id_idx": { - "name": "workspaces_project_id_idx", - "columns": [ - "project_id" - ], - "isUnique": false - }, - "workspaces_worktree_id_idx": { - "name": "workspaces_worktree_id_idx", - "columns": [ - "worktree_id" - ], - "isUnique": false - }, - "workspaces_last_opened_at_idx": { - "name": "workspaces_last_opened_at_idx", - "columns": [ - "last_opened_at" - ], - "isUnique": false - } - }, - "foreignKeys": { - "workspaces_project_id_projects_id_fk": { - "name": "workspaces_project_id_projects_id_fk", - "tableFrom": "workspaces", - "tableTo": "projects", - "columnsFrom": [ - "project_id" - ], - "columnsTo": [ - "id" - ], - "onDelete": "cascade", - "onUpdate": "no action" - }, - "workspaces_worktree_id_worktrees_id_fk": { - "name": "workspaces_worktree_id_worktrees_id_fk", - "tableFrom": "workspaces", - "tableTo": "worktrees", - "columnsFrom": [ - "worktree_id" - ], - "columnsTo": [ - "id" - ], - "onDelete": "cascade", - "onUpdate": "no action" - } - }, - "compositePrimaryKeys": {}, - "uniqueConstraints": {}, - "checkConstraints": {} - }, - "worktrees": { - "name": "worktrees", - "columns": { - "id": { - "name": "id", - "type": "text", - "primaryKey": true, - "notNull": true, - "autoincrement": false - }, - "project_id": { - "name": "project_id", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "path": { - "name": "path", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "branch": { - "name": "branch", - "type": "text", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "base_branch": { - "name": "base_branch", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "created_at": { - "name": "created_at", - "type": "integer", - "primaryKey": false, - "notNull": true, - "autoincrement": false - }, - "git_status": { - "name": "git_status", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - }, - "github_status": { - "name": "github_status", - "type": "text", - "primaryKey": false, - "notNull": false, - "autoincrement": false - } - }, - "indexes": { - "worktrees_project_id_idx": { - "name": "worktrees_project_id_idx", - "columns": [ - "project_id" - ], - "isUnique": false - }, - "worktrees_branch_idx": { - "name": "worktrees_branch_idx", - "columns": [ - "branch" - ], - "isUnique": false - } - }, - "foreignKeys": { - "worktrees_project_id_projects_id_fk": { - "name": "worktrees_project_id_projects_id_fk", - "tableFrom": "worktrees", - "tableTo": "projects", - "columnsFrom": [ - "project_id" - ], - "columnsTo": [ - "id" - ], - "onDelete": "cascade", - "onUpdate": "no action" - } - }, - "compositePrimaryKeys": {}, - "uniqueConstraints": {}, - "checkConstraints": {} - } - }, - "views": {}, - "enums": {}, - "_meta": { - "schemas": {}, - "tables": {}, - "columns": {} - }, - "internal": { - "indexes": {} - } -} diff --git a/packages/local-db/drizzle/meta/_journal.json b/packages/local-db/drizzle/meta/_journal.json index c63757dc471..ee19d4da90e 100644 --- a/packages/local-db/drizzle/meta/_journal.json +++ b/packages/local-db/drizzle/meta/_journal.json @@ -33,29 +33,8 @@ { "idx": 4, "version": "6", - "when": 1767166138761, - "tag": "0004_add_terminal_link_behavior_setting", - "breakpoints": true - }, - { - "idx": 5, - "version": "6", - "when": 1767166547886, - "tag": "0005_add_navigation_style", - "breakpoints": true - }, - { - "idx": 6, - "version": "6", - "when": 1767230000000, - "tag": "0006_add_unique_branch_workspace_index", - "breakpoints": true - }, - { - "idx": 7, - "version": "6", - "when": 1767350000000, - "tag": "0007_add_workspace_is_unread", + "when": 1767370047298, + "tag": "0004_settings_workspace_improvements", "breakpoints": true } ] diff --git a/packages/local-db/src/schema/schema.ts b/packages/local-db/src/schema/schema.ts index 8c4daa138e6..136dc5e2519 100644 --- a/packages/local-db/src/schema/schema.ts +++ b/packages/local-db/src/schema/schema.ts @@ -144,6 +144,7 @@ export const settings = sqliteTable("settings", { "terminal_link_behavior", ).$type(), navigationStyle: text("navigation_style").$type(), + terminalPersistence: integer("terminal_persistence", { mode: "boolean" }), }); export type InsertSettings = typeof settings.$inferInsert; From 87422c3017f107ff45697cb00670e466ac274207 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Mon, 29 Dec 2025 23:00:50 +0200 Subject: [PATCH 45/98] fix(desktop): address PR review feedback for terminal persistence - P0-1: Use getActiveTerminalManager() instead of hardcoded terminalManager - P0-2: Make attach() async with getSnapshotAsync() to flush pending writes - P1-1: Implement chunk-safe escape sequence parsing with carry buffer - P1-2: Add socket liveness check and spawn lock to prevent daemon races - P2-1: Truncate/redact sensitive data in NDJSON parse error logs - Q1: Query daemon listSessions for workspace cleanup after app restart --- .../src/lib/trpc/routers/projects/projects.ts | 7 +- .../lib/trpc/routers/workspaces/workspaces.ts | 16 +- .../src/main/lib/terminal-host/client.ts | 158 ++++++++++++++---- .../lib/terminal-host/headless-emulator.ts | 135 +++++++++++++-- .../src/main/lib/terminal/daemon-manager.ts | 41 ++++- apps/desktop/src/main/terminal-host/index.ts | 140 ++++++++++++---- .../desktop/src/main/terminal-host/session.ts | 8 +- .../src/main/terminal-host/terminal-host.ts | 8 +- 8 files changed, 412 insertions(+), 101 deletions(-) diff --git a/apps/desktop/src/lib/trpc/routers/projects/projects.ts b/apps/desktop/src/lib/trpc/routers/projects/projects.ts index e6381a711d7..fe4148ca722 100644 --- a/apps/desktop/src/lib/trpc/routers/projects/projects.ts +++ b/apps/desktop/src/lib/trpc/routers/projects/projects.ts @@ -12,7 +12,7 @@ import type { BrowserWindow } from "electron"; import { dialog } from "electron"; import { track } from "main/lib/analytics"; import { localDb } from "main/lib/local-db"; -import { terminalManager } from "main/lib/terminal"; +import { getActiveTerminalManager } from "main/lib/terminal"; import { PROJECT_COLOR_VALUES } from "shared/constants/project-colors"; import simpleGit from "simple-git"; import { z } from "zod"; @@ -658,9 +658,8 @@ export const createProjectsRouter = (getWindow: () => BrowserWindow | null) => { let totalFailed = 0; for (const workspace of projectWorkspaces) { - const terminalResult = await terminalManager.killByWorkspaceId( - workspace.id, - ); + const terminalResult = + await getActiveTerminalManager().killByWorkspaceId(workspace.id); totalFailed += terminalResult.failed; } diff --git a/apps/desktop/src/lib/trpc/routers/workspaces/workspaces.ts b/apps/desktop/src/lib/trpc/routers/workspaces/workspaces.ts index 4a57d0a0c8c..10b2100d3ec 100644 --- a/apps/desktop/src/lib/trpc/routers/workspaces/workspaces.ts +++ b/apps/desktop/src/lib/trpc/routers/workspaces/workspaces.ts @@ -10,7 +10,7 @@ import { import { and, desc, eq, isNotNull, not } from "drizzle-orm"; import { track } from "main/lib/analytics"; import { localDb } from "main/lib/local-db"; -import { terminalManager } from "main/lib/terminal"; +import { getActiveTerminalManager } from "main/lib/terminal"; import { SUPERSET_DIR_NAME, WORKTREES_DIR_NAME } from "shared/constants"; import { z } from "zod"; import { publicProcedure, router } from "../.."; @@ -494,7 +494,7 @@ export const createWorkspacesRouter = () => { await safeCheckoutBranch(project.mainRepoPath, input.branch); // Send newline to terminals so their prompts refresh with new branch - terminalManager.refreshPromptsForWorkspace(workspace.id); + getActiveTerminalManager().refreshPromptsForWorkspace(workspace.id); // Update the workspace - name is always the branch for branch workspaces const now = Date.now(); @@ -777,7 +777,7 @@ export const createWorkspacesRouter = () => { } const activeTerminalCount = - terminalManager.getSessionCountByWorkspaceId(input.id); + getActiveTerminalManager().getSessionCountByWorkspaceId(input.id); // Branch workspaces are non-destructive to close - no git checks needed if (workspace.type === "branch") { @@ -891,9 +891,8 @@ export const createWorkspacesRouter = () => { } // Kill all terminal processes in this workspace first - const terminalResult = await terminalManager.killByWorkspaceId( - input.id, - ); + const terminalResult = + await getActiveTerminalManager().killByWorkspaceId(input.id); const project = localDb .select() @@ -1412,9 +1411,8 @@ export const createWorkspacesRouter = () => { throw new Error("Workspace not found"); } - const terminalResult = await terminalManager.killByWorkspaceId( - input.id, - ); + const terminalResult = + await getActiveTerminalManager().killByWorkspaceId(input.id); // Delete workspace record ONLY, keep worktree localDb.delete(workspaces).where(eq(workspaces.id, input.id)).run(); diff --git a/apps/desktop/src/main/lib/terminal-host/client.ts b/apps/desktop/src/main/lib/terminal-host/client.ts index 5407a385d72..d83fb536f25 100644 --- a/apps/desktop/src/main/lib/terminal-host/client.ts +++ b/apps/desktop/src/main/lib/terminal-host/client.ts @@ -11,7 +11,7 @@ import { spawn } from "node:child_process"; import { EventEmitter } from "node:events"; -import { existsSync, readFileSync, unlinkSync } from "node:fs"; +import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs"; import { connect, type Socket } from "node:net"; import { homedir } from "node:os"; import { join } from "node:path"; @@ -48,11 +48,13 @@ const SUPERSET_HOME_DIR = join(homedir(), SUPERSET_DIR_NAME); const SOCKET_PATH = join(SUPERSET_HOME_DIR, "terminal-host.sock"); const TOKEN_PATH = join(SUPERSET_HOME_DIR, "terminal-host.token"); const PID_PATH = join(SUPERSET_HOME_DIR, "terminal-host.pid"); +const SPAWN_LOCK_PATH = join(SUPERSET_HOME_DIR, "terminal-host.spawn.lock"); // Connection timeouts const CONNECT_TIMEOUT_MS = 5000; const SPAWN_WAIT_MS = 2000; const REQUEST_TIMEOUT_MS = 30000; +const SPAWN_LOCK_TIMEOUT_MS = 10000; // Max time to hold spawn lock // ============================================================================= // NDJSON Parser @@ -336,6 +338,78 @@ export class TerminalHostClient extends EventEmitter { // Daemon Spawning // =========================================================================== + /** + * Check if there's an active daemon listening on the socket. + * Returns true if socket is live and responding. + */ + private isSocketLive(): Promise { + return new Promise((resolve) => { + if (!existsSync(SOCKET_PATH)) { + resolve(false); + return; + } + + const testSocket = connect(SOCKET_PATH); + const timeout = setTimeout(() => { + testSocket.destroy(); + resolve(false); + }, 1000); + + testSocket.on("connect", () => { + clearTimeout(timeout); + testSocket.destroy(); + resolve(true); + }); + + testSocket.on("error", () => { + clearTimeout(timeout); + resolve(false); + }); + }); + } + + /** + * Acquire spawn lock to prevent concurrent daemon spawns. + * Returns true if lock acquired, false if another spawn is in progress. + */ + private acquireSpawnLock(): boolean { + try { + // Check if lock exists and is recent (within timeout) + if (existsSync(SPAWN_LOCK_PATH)) { + const lockContent = readFileSync(SPAWN_LOCK_PATH, "utf-8").trim(); + const lockTime = Number.parseInt(lockContent, 10); + if ( + !Number.isNaN(lockTime) && + Date.now() - lockTime < SPAWN_LOCK_TIMEOUT_MS + ) { + // Lock is held by another process + return false; + } + // Stale lock, remove it + unlinkSync(SPAWN_LOCK_PATH); + } + + // Create lock file with current timestamp + writeFileSync(SPAWN_LOCK_PATH, String(Date.now()), { mode: 0o600 }); + return true; + } catch { + return false; + } + } + + /** + * Release spawn lock + */ + private releaseSpawnLock(): void { + try { + if (existsSync(SPAWN_LOCK_PATH)) { + unlinkSync(SPAWN_LOCK_PATH); + } + } catch { + // Best effort cleanup + } + } + /** * Spawn the daemon process if not running */ @@ -351,8 +425,16 @@ export class TerminalHostClient extends EventEmitter { return; } - // Clean up stale socket file if it exists + // Check if socket is live before removing it + // This prevents orphaning a running daemon that just doesn't have a PID file if (existsSync(SOCKET_PATH)) { + const isLive = await this.isSocketLive(); + if (isLive) { + console.log("[TerminalHostClient] Socket is live, daemon is running"); + return; + } + + // Socket exists but not responsive - safe to remove console.log("[TerminalHostClient] Removing stale socket file"); try { unlinkSync(SOCKET_PATH); @@ -361,41 +443,53 @@ export class TerminalHostClient extends EventEmitter { } } - // Get path to daemon script - const daemonScript = this.getDaemonScriptPath(); - console.log(`[TerminalHostClient] Daemon script path: ${daemonScript}`); - console.log( - `[TerminalHostClient] Script exists: ${existsSync(daemonScript)}`, - ); - - if (!existsSync(daemonScript)) { - throw new Error(`Daemon script not found: ${daemonScript}`); + // Acquire spawn lock to prevent concurrent spawns + if (!this.acquireSpawnLock()) { + console.log("[TerminalHostClient] Another spawn in progress, waiting..."); + // Wait for the other spawn to complete + await this.waitForDaemon(); + return; } - console.log( - `[TerminalHostClient] Spawning daemon with execPath: ${process.execPath}`, - ); - - // Spawn daemon as detached process - const child = spawn(process.execPath, [daemonScript], { - detached: true, - stdio: "ignore", - env: { - ...process.env, - ELECTRON_RUN_AS_NODE: "1", - NODE_ENV: process.env.NODE_ENV, - }, - }); + try { + // Get path to daemon script + const daemonScript = this.getDaemonScriptPath(); + console.log(`[TerminalHostClient] Daemon script path: ${daemonScript}`); + console.log( + `[TerminalHostClient] Script exists: ${existsSync(daemonScript)}`, + ); + + if (!existsSync(daemonScript)) { + throw new Error(`Daemon script not found: ${daemonScript}`); + } - console.log(`[TerminalHostClient] Daemon spawned with PID: ${child.pid}`); + console.log( + `[TerminalHostClient] Spawning daemon with execPath: ${process.execPath}`, + ); + + // Spawn daemon as detached process + const child = spawn(process.execPath, [daemonScript], { + detached: true, + stdio: "ignore", + env: { + ...process.env, + ELECTRON_RUN_AS_NODE: "1", + NODE_ENV: process.env.NODE_ENV, + }, + }); - // Unref to allow parent to exit independently - child.unref(); + console.log(`[TerminalHostClient] Daemon spawned with PID: ${child.pid}`); - // Wait for daemon to start - console.log("[TerminalHostClient] Waiting for daemon to start..."); - await this.waitForDaemon(); - console.log("[TerminalHostClient] Daemon started successfully"); + // Unref to allow parent to exit independently + child.unref(); + + // Wait for daemon to start + console.log("[TerminalHostClient] Waiting for daemon to start..."); + await this.waitForDaemon(); + console.log("[TerminalHostClient] Daemon started successfully"); + } finally { + this.releaseSpawnLock(); + } } /** diff --git a/apps/desktop/src/main/lib/terminal-host/headless-emulator.ts b/apps/desktop/src/main/lib/terminal-host/headless-emulator.ts index d9f432b6b9d..ae7ce8a866f 100644 --- a/apps/desktop/src/main/lib/terminal-host/headless-emulator.ts +++ b/apps/desktop/src/main/lib/terminal-host/headless-emulator.ts @@ -65,6 +65,9 @@ export class HeadlessEmulator { private pendingOutput: string[] = []; private onDataCallback?: (data: string) => void; + // Buffer for partial escape sequences that span chunk boundaries + private escapeSequenceBuffer = ""; + constructor(options: HeadlessEmulatorOptions = {}) { const { cols = 80, rows = 24, scrollback = 10000 } = options; @@ -112,11 +115,8 @@ export class HeadlessEmulator { write(data: string): void { if (this.disposed) return; - // Parse for mode changes before writing to terminal - this.parseModeChanges(data); - - // Parse for OSC-7 (CWD) sequences - this.parseOsc7(data); + // Parse escape sequences with chunk-safe buffering + this.parseEscapeSequences(data); // Write to headless terminal (buffered/async) this.terminal.write(data); @@ -129,11 +129,8 @@ export class HeadlessEmulator { async writeSync(data: string): Promise { if (this.disposed) return; - // Parse for mode changes before writing to terminal - this.parseModeChanges(data); - - // Parse for OSC-7 (CWD) sequences - this.parseOsc7(data); + // Parse escape sequences with chunk-safe buffering + this.parseEscapeSequences(data); // Write to headless terminal and wait for completion return new Promise((resolve) => { @@ -260,6 +257,124 @@ export class HeadlessEmulator { // Private Methods // =========================================================================== + /** + * Parse escape sequences with chunk-safe buffering. + * PTY output can split sequences across chunks, so we buffer partial sequences. + */ + private parseEscapeSequences(data: string): void { + // Prepend any buffered partial sequence from previous chunk + const fullData = this.escapeSequenceBuffer + data; + this.escapeSequenceBuffer = ""; + + // Find the last ESC in the data - anything after it might be incomplete + const lastEscIndex = fullData.lastIndexOf(ESC); + + if (lastEscIndex === -1) { + // No escape sequences, parse everything + this.parseModeChanges(fullData); + this.parseOsc7(fullData); + return; + } + + // Check if there's a potential incomplete sequence at the end + const afterLastEsc = fullData.slice(lastEscIndex); + + // Determine if the sequence is complete + // DECSET/DECRST: ESC[?...h or ESC[?...l - complete when ends with h or l + // OSC-7: ESC]7;...BEL or ESC]7;...ESC\ - complete when ends with BEL or ST + const isComplete = this.isSequenceComplete(afterLastEsc); + + if (isComplete) { + // All sequences are complete, parse everything + this.parseModeChanges(fullData); + this.parseOsc7(fullData); + } else { + // Buffer the incomplete sequence for next chunk + this.escapeSequenceBuffer = afterLastEsc; + + // Parse only the complete portion + const completeData = fullData.slice(0, lastEscIndex); + if (completeData) { + this.parseModeChanges(completeData); + this.parseOsc7(completeData); + } + } + } + + /** + * Check if a string starting with ESC contains a complete escape sequence. + * Uses string-based regex building to avoid control character linter errors. + */ + private isSequenceComplete(str: string): boolean { + if (!str.startsWith(ESC)) return true; + + const escEscaped = escapeRegex(ESC); + const belEscaped = escapeRegex(BEL); + + // Check for complete DECSET/DECRST: ESC[?...h or ESC[?...l + const modePattern = new RegExp(`${escEscaped}\\[\\?[0-9;]+[hl]`); + if (modePattern.test(str)) { + // Has a complete mode sequence, but check if there's more after + const modePatternGlobal = new RegExp( + `${escEscaped}\\[\\?[0-9;]+[hl]`, + "g", + ); + const matches = str.match(modePatternGlobal); + if (matches) { + // Find where the last complete sequence ends + const lastMatch = matches[matches.length - 1]; + const lastMatchEnd = str.lastIndexOf(lastMatch) + lastMatch.length; + // If there's an ESC after all complete sequences, it's incomplete + const remainder = str.slice(lastMatchEnd); + if (remainder.includes(ESC)) { + return this.isSequenceComplete( + remainder.slice(remainder.indexOf(ESC)), + ); + } + return true; + } + } + + // Check for complete OSC-7: ESC]7;...BEL or ESC]7;...ESC\ + if (str.includes(BEL) || str.includes(`${ESC}\\`)) { + // Might have complete OSC sequence + const osc7Pattern = new RegExp( + `${escEscaped}\\]7;[^${belEscaped}${escEscaped}]*(?:${belEscaped}|${escEscaped}\\\\)`, + ); + if (osc7Pattern.test(str)) { + return true; + } + } + + // Check for obviously incomplete patterns + // ESC alone, or ESC[, or ESC[?, or ESC[?123 (no terminator) + if (str === ESC) return false; + if (str === `${ESC}[`) return false; + if (str === `${ESC}]`) return false; + + // Incomplete mode sequence: ESC[?digits but no h/l + const incompleteModePattern = new RegExp(`^${escEscaped}\\[\\?[0-9;]*$`); + if (incompleteModePattern.test(str)) return false; + + // Incomplete OSC sequence: ESC]digit; but no BEL or ST + const incompleteOscPattern = new RegExp(`^${escEscaped}\\][0-9];`); + if ( + incompleteOscPattern.test(str) && + !str.includes(BEL) && + !str.includes(`${ESC}\\`) + ) { + return false; + } + + // If we got here with just ESC and some chars but no recognizable complete sequence, + // consider it incomplete if it looks like the start of a sequence we care about + const startsWithCsiOrOsc = new RegExp(`^${escEscaped}[\\[\\]]`); + if (startsWithCsiOrOsc.test(str)) return false; + + // Otherwise assume it's complete (might be some other sequence we don't track) + return true; + } + /** * Parse DECSET/DECRST sequences from terminal data */ diff --git a/apps/desktop/src/main/lib/terminal/daemon-manager.ts b/apps/desktop/src/main/lib/terminal/daemon-manager.ts index a06c33945b4..4f6639ccc04 100644 --- a/apps/desktop/src/main/lib/terminal/daemon-manager.ts +++ b/apps/desktop/src/main/lib/terminal/daemon-manager.ts @@ -352,20 +352,53 @@ export class DaemonTerminalManager extends EventEmitter { async killByWorkspaceId( workspaceId: string, ): Promise<{ killed: number; failed: number }> { - const sessionsToKill = Array.from(this.sessions.entries()).filter( + // Collect paneIds to kill (from local state or daemon) + let paneIdsToKill: string[] = []; + + // First check local sessions map + const localSessions = Array.from(this.sessions.entries()).filter( ([, session]) => session.workspaceId === workspaceId, ); + paneIdsToKill = localSessions.map(([paneId]) => paneId); - if (sessionsToKill.length === 0) { + // If no local sessions, query daemon directly + // This handles the case where app restarted but daemon still has sessions + if (paneIdsToKill.length === 0) { + try { + const response = await this.client.listSessions(); + const daemonSessions = response.sessions.filter( + (s) => s.workspaceId === workspaceId && s.isAlive, + ); + + if (daemonSessions.length > 0) { + console.log( + `[DaemonTerminalManager] Found ${daemonSessions.length} orphaned daemon sessions for workspace ${workspaceId}`, + ); + paneIdsToKill = daemonSessions.map((s) => s.paneId); + } + } catch (error) { + console.warn( + "[DaemonTerminalManager] Failed to query daemon for sessions:", + error, + ); + } + } + + if (paneIdsToKill.length === 0) { return { killed: 0, failed: 0 }; } let killed = 0; let failed = 0; - for (const [paneId] of sessionsToKill) { + for (const paneId of paneIdsToKill) { try { - await this.kill({ paneId, deleteHistory: true }); + await this.client.kill({ sessionId: paneId, deleteHistory: true }); + // Clean up local state if it exists + const session = this.sessions.get(paneId); + if (session) { + session.isAlive = false; + } killed++; } catch { failed++; diff --git a/apps/desktop/src/main/terminal-host/index.ts b/apps/desktop/src/main/terminal-host/index.ts index 642d926f141..beb5638161b 100644 --- a/apps/desktop/src/main/terminal-host/index.ts +++ b/apps/desktop/src/main/terminal-host/index.ts @@ -118,7 +118,21 @@ class NdjsonParser { try { messages.push(JSON.parse(line)); } catch { - log("warn", "Failed to parse NDJSON line", { line }); + // Truncate and redact potentially sensitive data in error logs + const maxLen = 100; + const truncated = + line.length > maxLen + ? `${line.slice(0, maxLen)}... (truncated)` + : line; + // Redact anything that looks like a token or secret + const redacted = truncated.replace( + /["']?(?:token|secret|password|key|auth)["']?\s*[:=]\s*["']?[^"'\s,}]+["']?/gi, + "[REDACTED]", + ); + log("warn", "Failed to parse NDJSON line", { + preview: redacted, + length: line.length, + }); } } @@ -198,7 +212,7 @@ const handlers: Record = { log("info", "Client authenticated successfully"); }, - createOrAttach: (socket, id, payload, clientState) => { + createOrAttach: async (socket, id, payload, clientState) => { if (!clientState.authenticated) { sendError(socket, id, "NOT_AUTHENTICATED", "Must authenticate first"); return; @@ -207,13 +221,19 @@ const handlers: Record = { const request = payload as CreateOrAttachRequest; log("info", `Creating/attaching session: ${request.sessionId}`); - const response = terminalHost.createOrAttach(socket, request); - sendSuccess(socket, id, response); + try { + const response = await terminalHost.createOrAttach(socket, request); + sendSuccess(socket, id, response); - log( - "info", - `Session ${request.sessionId} ${response.isNew ? "created" : "attached"}`, - ); + log( + "info", + `Session ${request.sessionId} ${response.isNew ? "created" : "attached"}`, + ); + } catch (error) { + const message = error instanceof Error ? error.message : "Unknown error"; + sendError(socket, id, "CREATE_ATTACH_FAILED", message); + log("error", `Failed to create/attach session: ${message}`); + } }, write: (socket, id, payload, clientState) => { @@ -352,42 +372,92 @@ function handleConnection(socket: Socket) { }); } -function startServer(): Promise { - return new Promise((resolve, reject) => { - // Ensure superset directory exists with proper permissions - if (!existsSync(SUPERSET_HOME_DIR)) { - mkdirSync(SUPERSET_HOME_DIR, { recursive: true, mode: 0o700 }); - log("info", `Created directory: ${SUPERSET_HOME_DIR}`); +/** + * Check if there's an active daemon listening on the socket. + * Returns true if socket is live and responding. + */ +function isSocketLive(): Promise { + return new Promise((resolve) => { + if (!existsSync(SOCKET_PATH)) { + resolve(false); + return; } - // Ensure directory has correct permissions + const testSocket = new (require("node:net").Socket)(); + const timeout = setTimeout(() => { + testSocket.destroy(); + resolve(false); + }, 1000); + + testSocket.on("connect", () => { + clearTimeout(timeout); + testSocket.destroy(); + resolve(true); + }); + + testSocket.on("error", () => { + clearTimeout(timeout); + resolve(false); + }); + + testSocket.connect(SOCKET_PATH); + }); +} + +async function startServer(): Promise { + // Ensure superset directory exists with proper permissions + if (!existsSync(SUPERSET_HOME_DIR)) { + mkdirSync(SUPERSET_HOME_DIR, { recursive: true, mode: 0o700 }); + log("info", `Created directory: ${SUPERSET_HOME_DIR}`); + } + + // Ensure directory has correct permissions + try { + chmodSync(SUPERSET_HOME_DIR, 0o700); + } catch { + // May fail if not owner, that's okay + } + + // Check if socket is live before removing it + // This prevents orphaning a running daemon + if (existsSync(SOCKET_PATH)) { + const isLive = await isSocketLive(); + if (isLive) { + log("error", "Another daemon is already running and responsive"); + throw new Error("Another daemon is already running"); + } + + // Socket exists but not responsive - safe to remove try { - chmodSync(SUPERSET_HOME_DIR, 0o700); - } catch { - // May fail if not owner, that's okay + unlinkSync(SOCKET_PATH); + log("info", "Removed stale socket file"); + } catch (error) { + throw new Error(`Failed to remove stale socket: ${error}`); } + } - // Remove stale socket if it exists - if (existsSync(SOCKET_PATH)) { - try { - unlinkSync(SOCKET_PATH); - log("info", "Removed stale socket file"); - } catch (error) { - reject(new Error(`Failed to remove stale socket: ${error}`)); - return; - } + // Clean up stale PID file if socket was removed + if (existsSync(PID_PATH)) { + try { + unlinkSync(PID_PATH); + } catch { + // Ignore - may not have permission } + } - // Initialize auth token - authToken = ensureAuthToken(); + // Initialize auth token + authToken = ensureAuthToken(); - // Initialize terminal host - terminalHost = new TerminalHost(); + // Initialize terminal host + terminalHost = new TerminalHost(); - // Create server - server = createServer(handleConnection); + // Create server + const newServer = createServer(handleConnection); + server = newServer; - server.on("error", (error: NodeJS.ErrnoException) => { + // Wrap server.listen in a Promise for async/await + await new Promise((resolve, reject) => { + newServer.on("error", (error: NodeJS.ErrnoException) => { if (error.code === "EADDRINUSE") { log("error", "Socket already in use - another daemon may be running"); reject(new Error("Socket already in use")); @@ -397,7 +467,7 @@ function startServer(): Promise { } }); - server.listen(SOCKET_PATH, () => { + newServer.listen(SOCKET_PATH, () => { // Set socket permissions (readable/writable by owner only) try { chmodSync(SOCKET_PATH, 0o600); diff --git a/apps/desktop/src/main/terminal-host/session.ts b/apps/desktop/src/main/terminal-host/session.ts index d5271cd49ba..e9b7e86e7a5 100644 --- a/apps/desktop/src/main/terminal-host/session.ts +++ b/apps/desktop/src/main/terminal-host/session.ts @@ -185,8 +185,9 @@ export class Session { /** * Attach a client to this session + * Returns a snapshot after flushing any pending writes to ensure consistency */ - attach(socket: Socket): TerminalSnapshot { + async attach(socket: Socket): Promise { if (this.disposed) { throw new Error("Session disposed"); } @@ -205,8 +206,9 @@ export class Session { socket.once("close", cleanup); socket.once("error", cleanup); - // Return current snapshot - return this.emulator.getSnapshot(); + // Return current snapshot after flushing pending writes + // This ensures any output produced while no clients were attached is included + return this.emulator.getSnapshotAsync(); } /** diff --git a/apps/desktop/src/main/terminal-host/terminal-host.ts b/apps/desktop/src/main/terminal-host/terminal-host.ts index ac1b75452d7..7428b4f2b99 100644 --- a/apps/desktop/src/main/terminal-host/terminal-host.ts +++ b/apps/desktop/src/main/terminal-host/terminal-host.ts @@ -33,10 +33,10 @@ export class TerminalHost { /** * Create or attach to a terminal session */ - createOrAttach( + async createOrAttach( socket: Socket, request: CreateOrAttachRequest, - ): CreateOrAttachResponse { + ): Promise { const { sessionId } = request; let session = this.sessions.get(sessionId); @@ -74,8 +74,8 @@ export class TerminalHost { isNew = true; } - // Attach client to session - const snapshot = session.attach(socket); + // Attach client to session (async to ensure pending writes are flushed) + const snapshot = await session.attach(socket); return { isNew, From 3bb707ed84b128cc06c0ece44f0b4616e6919e88 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 00:33:20 +0200 Subject: [PATCH 46/98] fix(desktop): address second round of PR review feedback - P0: Fix escape sequence buffering to only buffer DECSET/DECRST and OSC-7 (prevents memory leak from buffering color codes like ESC[31m) - P1: Use getActiveTerminalManager() in main.ts detachAllListeners - P1: Ensure ~/.superset* directory exists before spawn lock write - P1: Resize session to requested dimensions on attach (with try-catch) - P2: Make getSessionCountByWorkspaceId async and query daemon after restart - Fix flaky session-lifecycle test by waiting for session ready state and handling PTY EBADF errors during resize --- .../lib/trpc/routers/workspaces/workspaces.ts | 4 +- .../src/main/lib/terminal-host/client.ts | 13 +- .../lib/terminal-host/headless-emulator.ts | 164 ++++++++---------- .../src/main/lib/terminal/daemon-manager.ts | 24 ++- .../src/main/lib/terminal/manager.test.ts | 18 +- apps/desktop/src/main/lib/terminal/manager.ts | 2 +- .../terminal-host/session-lifecycle.test.ts | 37 ++++ .../src/main/terminal-host/terminal-host.ts | 10 ++ apps/desktop/src/main/windows/main.ts | 4 +- 9 files changed, 174 insertions(+), 102 deletions(-) diff --git a/apps/desktop/src/lib/trpc/routers/workspaces/workspaces.ts b/apps/desktop/src/lib/trpc/routers/workspaces/workspaces.ts index 10b2100d3ec..340ce1f3abe 100644 --- a/apps/desktop/src/lib/trpc/routers/workspaces/workspaces.ts +++ b/apps/desktop/src/lib/trpc/routers/workspaces/workspaces.ts @@ -777,7 +777,9 @@ export const createWorkspacesRouter = () => { } const activeTerminalCount = - getActiveTerminalManager().getSessionCountByWorkspaceId(input.id); + await getActiveTerminalManager().getSessionCountByWorkspaceId( + input.id, + ); // Branch workspaces are non-destructive to close - no git checks needed if (workspace.type === "branch") { diff --git a/apps/desktop/src/main/lib/terminal-host/client.ts b/apps/desktop/src/main/lib/terminal-host/client.ts index d83fb536f25..b31a26f1cca 100644 --- a/apps/desktop/src/main/lib/terminal-host/client.ts +++ b/apps/desktop/src/main/lib/terminal-host/client.ts @@ -11,7 +11,13 @@ import { spawn } from "node:child_process"; import { EventEmitter } from "node:events"; -import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs"; +import { + existsSync, + mkdirSync, + readFileSync, + unlinkSync, + writeFileSync, +} from "node:fs"; import { connect, type Socket } from "node:net"; import { homedir } from "node:os"; import { join } from "node:path"; @@ -374,6 +380,11 @@ export class TerminalHostClient extends EventEmitter { */ private acquireSpawnLock(): boolean { try { + // Ensure superset home directory exists before any file operations + if (!existsSync(SUPERSET_HOME_DIR)) { + mkdirSync(SUPERSET_HOME_DIR, { recursive: true, mode: 0o700 }); + } + // Check if lock exists and is recent (within timeout) if (existsSync(SPAWN_LOCK_PATH)) { const lockContent = readFileSync(SPAWN_LOCK_PATH, "utf-8").trim(); diff --git a/apps/desktop/src/main/lib/terminal-host/headless-emulator.ts b/apps/desktop/src/main/lib/terminal-host/headless-emulator.ts index ae7ce8a866f..ad30a0dd7b0 100644 --- a/apps/desktop/src/main/lib/terminal-host/headless-emulator.ts +++ b/apps/desktop/src/main/lib/terminal-host/headless-emulator.ts @@ -68,6 +68,9 @@ export class HeadlessEmulator { // Buffer for partial escape sequences that span chunk boundaries private escapeSequenceBuffer = ""; + // Maximum buffer size to prevent unbounded growth (safety cap) + private static readonly MAX_ESCAPE_BUFFER_SIZE = 1024; + constructor(options: HeadlessEmulatorOptions = {}) { const { cols = 80, rows = 24, scrollback = 10000 } = options; @@ -260,119 +263,100 @@ export class HeadlessEmulator { /** * Parse escape sequences with chunk-safe buffering. * PTY output can split sequences across chunks, so we buffer partial sequences. + * + * IMPORTANT: We only buffer sequences we actually track (DECSET/DECRST and OSC-7). + * Other escape sequences (colors, cursor moves, etc.) are NOT buffered to prevent + * memory leaks from unbounded buffer growth. */ private parseEscapeSequences(data: string): void { // Prepend any buffered partial sequence from previous chunk const fullData = this.escapeSequenceBuffer + data; this.escapeSequenceBuffer = ""; - // Find the last ESC in the data - anything after it might be incomplete - const lastEscIndex = fullData.lastIndexOf(ESC); + // Parse complete sequences in the data + this.parseModeChanges(fullData); + this.parseOsc7(fullData); - if (lastEscIndex === -1) { - // No escape sequences, parse everything - this.parseModeChanges(fullData); - this.parseOsc7(fullData); - return; - } + // Check for incomplete sequences we care about at the end + // We only buffer DECSET/DECRST (ESC[?...) and OSC-7 (ESC]7;...) + const incompleteSequence = this.findIncompleteTrackedSequence(fullData); - // Check if there's a potential incomplete sequence at the end - const afterLastEsc = fullData.slice(lastEscIndex); - - // Determine if the sequence is complete - // DECSET/DECRST: ESC[?...h or ESC[?...l - complete when ends with h or l - // OSC-7: ESC]7;...BEL or ESC]7;...ESC\ - complete when ends with BEL or ST - const isComplete = this.isSequenceComplete(afterLastEsc); - - if (isComplete) { - // All sequences are complete, parse everything - this.parseModeChanges(fullData); - this.parseOsc7(fullData); - } else { - // Buffer the incomplete sequence for next chunk - this.escapeSequenceBuffer = afterLastEsc; - - // Parse only the complete portion - const completeData = fullData.slice(0, lastEscIndex); - if (completeData) { - this.parseModeChanges(completeData); - this.parseOsc7(completeData); + if (incompleteSequence) { + // Cap buffer size to prevent unbounded growth + if ( + incompleteSequence.length <= HeadlessEmulator.MAX_ESCAPE_BUFFER_SIZE + ) { + this.escapeSequenceBuffer = incompleteSequence; } + // If buffer too large, just discard it (likely malformed or attack) } } /** - * Check if a string starting with ESC contains a complete escape sequence. - * Uses string-based regex building to avoid control character linter errors. + * Find an incomplete DECSET/DECRST or OSC-7 sequence at the end of data. + * Returns the incomplete sequence string, or null if none found. + * + * We ONLY buffer sequences we track: + * - DECSET/DECRST: ESC[?...h or ESC[?...l + * - OSC-7: ESC]7;...BEL or ESC]7;...ESC\ + * + * Other CSI sequences (ESC[31m, ESC[H, etc.) are NOT buffered. */ - private isSequenceComplete(str: string): boolean { - if (!str.startsWith(ESC)) return true; - + private findIncompleteTrackedSequence(data: string): string | null { const escEscaped = escapeRegex(ESC); - const belEscaped = escapeRegex(BEL); - // Check for complete DECSET/DECRST: ESC[?...h or ESC[?...l - const modePattern = new RegExp(`${escEscaped}\\[\\?[0-9;]+[hl]`); - if (modePattern.test(str)) { - // Has a complete mode sequence, but check if there's more after - const modePatternGlobal = new RegExp( - `${escEscaped}\\[\\?[0-9;]+[hl]`, - "g", - ); - const matches = str.match(modePatternGlobal); - if (matches) { - // Find where the last complete sequence ends - const lastMatch = matches[matches.length - 1]; - const lastMatchEnd = str.lastIndexOf(lastMatch) + lastMatch.length; - // If there's an ESC after all complete sequences, it's incomplete - const remainder = str.slice(lastMatchEnd); - if (remainder.includes(ESC)) { - return this.isSequenceComplete( - remainder.slice(remainder.indexOf(ESC)), - ); + // Look for potential incomplete sequences from the end + const lastEscIndex = data.lastIndexOf(ESC); + if (lastEscIndex === -1) return null; + + const afterLastEsc = data.slice(lastEscIndex); + + // Check if this looks like a sequence we track + + // Pattern: ESC[? - start of DECSET/DECRST + if (afterLastEsc.startsWith(`${ESC}[?`)) { + // Check if it's complete (ends with h or l after digits) + const completePattern = new RegExp(`${escEscaped}\\[\\?[0-9;]+[hl]`); + if (completePattern.test(afterLastEsc)) { + // Complete DECSET/DECRST - check if there's another incomplete after + const globalPattern = new RegExp(`${escEscaped}\\[\\?[0-9;]+[hl]`, "g"); + const matches = afterLastEsc.match(globalPattern); + if (matches) { + const lastMatch = matches[matches.length - 1]; + const lastMatchEnd = + afterLastEsc.lastIndexOf(lastMatch) + lastMatch.length; + const remainder = afterLastEsc.slice(lastMatchEnd); + if (remainder.includes(ESC)) { + return this.findIncompleteTrackedSequence(remainder); + } } - return true; + return null; // Complete } + // Incomplete DECSET/DECRST - buffer it + return afterLastEsc; } - // Check for complete OSC-7: ESC]7;...BEL or ESC]7;...ESC\ - if (str.includes(BEL) || str.includes(`${ESC}\\`)) { - // Might have complete OSC sequence - const osc7Pattern = new RegExp( - `${escEscaped}\\]7;[^${belEscaped}${escEscaped}]*(?:${belEscaped}|${escEscaped}\\\\)`, - ); - if (osc7Pattern.test(str)) { - return true; + // Pattern: ESC]7; - start of OSC-7 + if (afterLastEsc.startsWith(`${ESC}]7;`)) { + // Check if it's complete (ends with BEL or ESC\) + if (afterLastEsc.includes(BEL) || afterLastEsc.includes(`${ESC}\\`)) { + return null; // Complete } + // Incomplete OSC-7 - buffer it + return afterLastEsc; } - // Check for obviously incomplete patterns - // ESC alone, or ESC[, or ESC[?, or ESC[?123 (no terminator) - if (str === ESC) return false; - if (str === `${ESC}[`) return false; - if (str === `${ESC}]`) return false; - - // Incomplete mode sequence: ESC[?digits but no h/l - const incompleteModePattern = new RegExp(`^${escEscaped}\\[\\?[0-9;]*$`); - if (incompleteModePattern.test(str)) return false; - - // Incomplete OSC sequence: ESC]digit; but no BEL or ST - const incompleteOscPattern = new RegExp(`^${escEscaped}\\][0-9];`); - if ( - incompleteOscPattern.test(str) && - !str.includes(BEL) && - !str.includes(`${ESC}\\`) - ) { - return false; - } - - // If we got here with just ESC and some chars but no recognizable complete sequence, - // consider it incomplete if it looks like the start of a sequence we care about - const startsWithCsiOrOsc = new RegExp(`^${escEscaped}[\\[\\]]`); - if (startsWithCsiOrOsc.test(str)) return false; - - // Otherwise assume it's complete (might be some other sequence we don't track) - return true; + // Check for partial starts of tracked sequences + // These could become tracked sequences with more data + if (afterLastEsc === ESC) return afterLastEsc; // Just ESC + if (afterLastEsc === `${ESC}[`) return afterLastEsc; // ESC[ + if (afterLastEsc === `${ESC}]`) return afterLastEsc; // ESC] + if (afterLastEsc === `${ESC}]7`) return afterLastEsc; // ESC]7 + const incompleteDecset = new RegExp(`^${escEscaped}\\[\\?[0-9;]*$`); + if (incompleteDecset.test(afterLastEsc)) return afterLastEsc; // ESC[?123 + + // Not a sequence we track (e.g., ESC[31m, ESC[H) - don't buffer + return null; } /** diff --git a/apps/desktop/src/main/lib/terminal/daemon-manager.ts b/apps/desktop/src/main/lib/terminal/daemon-manager.ts index 4f6639ccc04..7069fa500f9 100644 --- a/apps/desktop/src/main/lib/terminal/daemon-manager.ts +++ b/apps/desktop/src/main/lib/terminal/daemon-manager.ts @@ -408,10 +408,30 @@ export class DaemonTerminalManager extends EventEmitter { return { killed, failed }; } - getSessionCountByWorkspaceId(workspaceId: string): number { - return Array.from(this.sessions.values()).filter( + async getSessionCountByWorkspaceId(workspaceId: string): Promise { + // First check local sessions + const localCount = Array.from(this.sessions.values()).filter( (session) => session.workspaceId === workspaceId && session.isAlive, ).length; + + if (localCount > 0) { + return localCount; + } + + // If no local sessions, query daemon directly + // This handles the case where app restarted but daemon still has sessions + try { + const response = await this.client.listSessions(); + return response.sessions.filter( + (s) => s.workspaceId === workspaceId && s.isAlive, + ).length; + } catch (error) { + console.warn( + "[DaemonTerminalManager] Failed to query daemon for session count:", + error, + ); + return 0; + } } /** diff --git a/apps/desktop/src/main/lib/terminal/manager.test.ts b/apps/desktop/src/main/lib/terminal/manager.test.ts index e49cb8bfca5..f6d2c9d6146 100644 --- a/apps/desktop/src/main/lib/terminal/manager.test.ts +++ b/apps/desktop/src/main/lib/terminal/manager.test.ts @@ -664,12 +664,18 @@ describe("TerminalManager", () => { workspaceId: "other-workspace", }); - expect(manager.getSessionCountByWorkspaceId("workspace-count")).toBe(2); - expect(manager.getSessionCountByWorkspaceId("other-workspace")).toBe(1); + expect( + await manager.getSessionCountByWorkspaceId("workspace-count"), + ).toBe(2); + expect( + await manager.getSessionCountByWorkspaceId("other-workspace"), + ).toBe(1); }); - it("should return zero for non-existent workspace", () => { - expect(manager.getSessionCountByWorkspaceId("non-existent")).toBe(0); + it("should return zero for non-existent workspace", async () => { + expect(await manager.getSessionCountByWorkspaceId("non-existent")).toBe( + 0, + ); }); it("should not count dead sessions", async () => { @@ -695,7 +701,9 @@ describe("TerminalManager", () => { // Wait for state to update await new Promise((resolve) => setTimeout(resolve, 100)); - expect(manager.getSessionCountByWorkspaceId("workspace-mixed")).toBe(1); + expect( + await manager.getSessionCountByWorkspaceId("workspace-mixed"), + ).toBe(1); }); }); diff --git a/apps/desktop/src/main/lib/terminal/manager.ts b/apps/desktop/src/main/lib/terminal/manager.ts index 4541b75d664..84522cde550 100644 --- a/apps/desktop/src/main/lib/terminal/manager.ts +++ b/apps/desktop/src/main/lib/terminal/manager.ts @@ -378,7 +378,7 @@ export class TerminalManager extends EventEmitter { }); } - getSessionCountByWorkspaceId(workspaceId: string): number { + async getSessionCountByWorkspaceId(workspaceId: string): Promise { return Array.from(this.sessions.values()).filter( (session) => session.workspaceId === workspaceId && session.isAlive, ).length; diff --git a/apps/desktop/src/main/terminal-host/session-lifecycle.test.ts b/apps/desktop/src/main/terminal-host/session-lifecycle.test.ts index ebd13ad5aab..4e994c87957 100644 --- a/apps/desktop/src/main/terminal-host/session-lifecycle.test.ts +++ b/apps/desktop/src/main/terminal-host/session-lifecycle.test.ts @@ -218,6 +218,34 @@ describe("Terminal Host Session Lifecycle", () => { }); } + /** + * Wait for a session to be ready (alive and accepting requests) + */ + async function waitForSessionReady( + socket: Socket, + sessionId: string, + timeoutMs = 3000, + ): Promise { + const startTime = Date.now(); + while (Date.now() - startTime < timeoutMs) { + const listRequest: IpcRequest = { + id: `list-${Date.now()}`, + type: "listSessions", + payload: undefined, + }; + const response = await sendRequest(socket, listRequest); + if (response.ok) { + const payload = response.payload as ListSessionsResponse; + const session = payload.sessions.find((s) => s.sessionId === sessionId); + if (session?.isAlive) { + return true; + } + } + await new Promise((r) => setTimeout(r, 100)); + } + return false; + } + /** * Authenticate with the daemon */ @@ -358,6 +386,11 @@ describe("Terminal Host Session Lifecycle", () => { ); } + // Wait for the session to be fully ready before attaching + // PTY spawn can be async and session needs to be alive for attach + const isReady = await waitForSessionReady(socket, "test-session-2"); + expect(isReady).toBe(true); + // Attach to same session const createRequest2: IpcRequest = { id: "test-create-2b", @@ -374,6 +407,10 @@ describe("Terminal Host Session Lifecycle", () => { }; const response2 = await sendRequest(socket, createRequest2); + if (!response2.ok) { + // Log error details for debugging + console.error("Attach failed:", JSON.stringify(response2, null, 2)); + } expect(response2.ok).toBe(true); if (response2.ok) { const payload = response2.payload as CreateOrAttachResponse; diff --git a/apps/desktop/src/main/terminal-host/terminal-host.ts b/apps/desktop/src/main/terminal-host/terminal-host.ts index 7428b4f2b99..2bb53414b96 100644 --- a/apps/desktop/src/main/terminal-host/terminal-host.ts +++ b/apps/desktop/src/main/terminal-host/terminal-host.ts @@ -72,6 +72,16 @@ export class TerminalHost { this.sessions.set(sessionId, session); isNew = true; + } else if (session.isAlive) { + // Attaching to existing session - resize to requested dimensions + // This ensures the snapshot reflects the client's current terminal size + // Note: Resize can fail if PTY is in a bad state (e.g., EBADF) + // We catch and ignore these errors since the session may still be usable + try { + session.resize(request.cols, request.rows); + } catch { + // Ignore resize failures - session may still be attachable + } } // Attach client to session (async to ensure pending writes are flushed) diff --git a/apps/desktop/src/main/windows/main.ts b/apps/desktop/src/main/windows/main.ts index fb29400b1a9..966e84614c1 100644 --- a/apps/desktop/src/main/windows/main.ts +++ b/apps/desktop/src/main/windows/main.ts @@ -17,7 +17,7 @@ import { notificationsApp, notificationsEmitter, } from "../lib/notifications/server"; -import { terminalManager } from "../lib/terminal"; +import { getActiveTerminalManager } from "../lib/terminal"; // Singleton IPC handler to prevent duplicate handlers on window reopen (macOS) let ipcHandler: ReturnType | null = null; @@ -164,7 +164,7 @@ export async function MainWindow() { server.close(); notificationsEmitter.removeAllListeners(); // Remove terminal listeners to prevent duplicates when window reopens on macOS - terminalManager.detachAllListeners(); + getActiveTerminalManager().detachAllListeners(); // Detach window from IPC handler (handler stays alive for window reopen) ipcHandler?.detachWindow(window); // Clear current window reference From 15a519299736ed79dd76ce7e183c1798e199673d Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 08:10:07 +0200 Subject: [PATCH 47/98] fix(desktop): address third round of PR review feedback - P0: Fix dead sessions - dispose and recreate when session exists but !isAlive Also improved cleanup: reschedule if clients attached, cleanup on detach - P1: Fix snapshot restore order - rehydrateSequences BEFORE snapshotAnsi (matches headless emulator's applySnapshot order for correct TUI restoration) - P1: Fix stale PID reuse - check socket liveness first, then clean up stale PID (prevents daemon startup failure when PID is reused by another process) - P2: Centralize socket disconnect handling in daemon handleConnection (avoids per-session socket listeners that could cause MaxListenersExceeded) --- .../src/main/lib/terminal-host/client.ts | 45 +++++----------- apps/desktop/src/main/terminal-host/index.ts | 9 +++- .../desktop/src/main/terminal-host/session.ts | 10 ++-- .../src/main/terminal-host/terminal-host.ts | 53 +++++++++++++++++-- .../TabsContent/Terminal/Terminal.tsx | 12 +++-- 5 files changed, 79 insertions(+), 50 deletions(-) diff --git a/apps/desktop/src/main/lib/terminal-host/client.ts b/apps/desktop/src/main/lib/terminal-host/client.ts index b31a26f1cca..dce65c558e7 100644 --- a/apps/desktop/src/main/lib/terminal-host/client.ts +++ b/apps/desktop/src/main/lib/terminal-host/client.ts @@ -425,19 +425,8 @@ export class TerminalHostClient extends EventEmitter { * Spawn the daemon process if not running */ private async spawnDaemon(): Promise { - // Check if daemon is already running via PID file - if (this.isDaemonRunning()) { - console.log( - "[TerminalHostClient] Daemon already running (PID file exists)", - ); - // Daemon is running but socket might be stale - // Give it a moment and return - await this.sleep(500); - return; - } - - // Check if socket is live before removing it - // This prevents orphaning a running daemon that just doesn't have a PID file + // Check if socket is live first - this is the authoritative check + // PID file can be stale if daemon crashed and PID was reused by another process if (existsSync(SOCKET_PATH)) { const isLive = await this.isSocketLive(); if (isLive) { @@ -454,6 +443,17 @@ export class TerminalHostClient extends EventEmitter { } } + // Also clean up stale PID file if socket was not live + // This handles the case where daemon crashed and PID was reused + if (existsSync(PID_PATH)) { + console.log("[TerminalHostClient] Removing stale PID file"); + try { + unlinkSync(PID_PATH); + } catch { + // Ignore - might not have permission + } + } + // Acquire spawn lock to prevent concurrent spawns if (!this.acquireSpawnLock()) { console.log("[TerminalHostClient] Another spawn in progress, waiting..."); @@ -503,25 +503,6 @@ export class TerminalHostClient extends EventEmitter { } } - /** - * Check if daemon process is running - */ - private isDaemonRunning(): boolean { - if (!existsSync(PID_PATH)) { - return false; - } - - try { - const pid = Number.parseInt(readFileSync(PID_PATH, "utf-8").trim(), 10); - // Check if process exists (kill with signal 0) - process.kill(pid, 0); - return true; - } catch { - // Process doesn't exist or no permission - return false; - } - } - /** * Get path to daemon script */ diff --git a/apps/desktop/src/main/terminal-host/index.ts b/apps/desktop/src/main/terminal-host/index.ts index beb5638161b..bf2e5876579 100644 --- a/apps/desktop/src/main/terminal-host/index.ts +++ b/apps/desktop/src/main/terminal-host/index.ts @@ -363,9 +363,14 @@ function handleConnection(socket: Socket) { } }); - socket.on("close", () => { + const handleDisconnect = () => { log("info", `Client disconnected: ${remoteId}`); - }); + // Detach this socket from all sessions it was attached to + // This is centralized here to avoid per-session socket listeners + terminalHost.detachFromAllSessions(socket); + }; + + socket.on("close", handleDisconnect); socket.on("error", (error) => { log("error", `Socket error for ${remoteId}`, { error: error.message }); diff --git a/apps/desktop/src/main/terminal-host/session.ts b/apps/desktop/src/main/terminal-host/session.ts index e9b7e86e7a5..2ff403eadec 100644 --- a/apps/desktop/src/main/terminal-host/session.ts +++ b/apps/desktop/src/main/terminal-host/session.ts @@ -186,6 +186,9 @@ export class Session { /** * Attach a client to this session * Returns a snapshot after flushing any pending writes to ensure consistency + * + * Note: Socket disconnect handling is centralized in the daemon's handleConnection + * to avoid adding per-session listeners which could cause MaxListenersExceededWarning */ async attach(socket: Socket): Promise { if (this.disposed) { @@ -199,13 +202,6 @@ export class Session { }); this.lastAttachedAt = new Date(); - // Handle client disconnect - const cleanup = () => { - this.attachedClients.delete(socket); - }; - socket.once("close", cleanup); - socket.once("error", cleanup); - // Return current snapshot after flushing pending writes // This ensures any output produced while no clients were attached is included return this.emulator.getSnapshotAsync(); diff --git a/apps/desktop/src/main/terminal-host/terminal-host.ts b/apps/desktop/src/main/terminal-host/terminal-host.ts index 2bb53414b96..b3e9f793fe0 100644 --- a/apps/desktop/src/main/terminal-host/terminal-host.ts +++ b/apps/desktop/src/main/terminal-host/terminal-host.ts @@ -42,6 +42,13 @@ export class TerminalHost { let session = this.sessions.get(sessionId); let isNew = false; + // If session exists but is dead, dispose it and create a new one + if (session && !session.isAlive) { + session.dispose(); + this.sessions.delete(sessionId); + session = undefined; + } + if (!session) { // Create new session session = createSession(request); @@ -72,8 +79,8 @@ export class TerminalHost { this.sessions.set(sessionId, session); isNew = true; - } else if (session.isAlive) { - // Attaching to existing session - resize to requested dimensions + } else { + // Attaching to existing live session - resize to requested dimensions // This ensures the snapshot reflects the client's current terminal size // Note: Resize can fail if PTY is in a bad state (e.g., EBADF) // We catch and ignore these errors since the session may still be usable @@ -119,6 +126,11 @@ export class TerminalHost { const session = this.sessions.get(request.sessionId); if (session) { session.detach(socket); + // Clean up dead sessions when last client detaches + if (!session.isAlive && session.clientCount === 0) { + session.dispose(); + this.sessions.delete(request.sessionId); + } } return { success: true }; } @@ -170,6 +182,21 @@ export class TerminalHost { return { success: true }; } + /** + * Detach a socket from all sessions it's attached to + * Called when a client connection closes + */ + detachFromAllSessions(socket: Socket): void { + for (const [sessionId, session] of this.sessions.entries()) { + session.detach(socket); + // Clean up dead sessions when last client detaches + if (!session.isAlive && session.clientCount === 0) { + session.dispose(); + this.sessions.delete(sessionId); + } + } + } + /** * Clean up all sessions on shutdown */ @@ -204,12 +231,30 @@ export class TerminalHost { _signal?: number, ): void { // Keep session around for a bit so clients can see exit status - // Then clean up + // Then clean up (reschedule if clients still attached) + this.scheduleSessionCleanup(sessionId); + } + + /** + * Schedule cleanup of a dead session + * Reschedules if clients are still attached + */ + private scheduleSessionCleanup(sessionId: string): void { setTimeout(() => { const session = this.sessions.get(sessionId); - if (session && !session.isAlive && session.clientCount === 0) { + if (!session || session.isAlive) { + // Session was recreated or is alive, nothing to clean up + return; + } + + if (session.clientCount === 0) { + // No clients attached, safe to clean up session.dispose(); this.sessions.delete(sessionId); + } else { + // Clients still attached, reschedule cleanup + // They'll see the exit status and can restart + this.scheduleSessionCleanup(sessionId); } }, 5000); } diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index f4f7359ef5e..9a46bc93f33 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -324,14 +324,16 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { scrollbackLines: number; }; }) => { - xterm.write(result.scrollback); - updateCwdRef.current(result.scrollback); - - // Apply rehydration sequences to restore terminal modes (e.g., alternate screen for TUI apps) - // This must come after the scrollback content to properly restore the terminal state + // Apply rehydration sequences FIRST to restore terminal modes + // (e.g., alternate screen, app cursor mode, bracketed paste) + // This must come before the scrollback content for correct TUI restoration if (result.snapshot?.rehydrateSequences) { xterm.write(result.snapshot.rehydrateSequences); } + + // Then apply the scrollback content + xterm.write(result.scrollback); + updateCwdRef.current(result.scrollback); }; const restartTerminal = () => { From f714ec023a5c95665a242e75e889bc8f0def4551 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 09:11:22 +0200 Subject: [PATCH 48/98] fix(desktop): query daemon as source of truth for workspace sessions - killByWorkspaceId now always queries daemon for authoritative session list - getSessionCountByWorkspaceId now always queries daemon first - Fixes orphan sessions when users partially reattach after app restart --- .../src/main/lib/terminal/daemon-manager.ts | 67 ++++++++----------- 1 file changed, 27 insertions(+), 40 deletions(-) diff --git a/apps/desktop/src/main/lib/terminal/daemon-manager.ts b/apps/desktop/src/main/lib/terminal/daemon-manager.ts index 7069fa500f9..e14ee19717c 100644 --- a/apps/desktop/src/main/lib/terminal/daemon-manager.ts +++ b/apps/desktop/src/main/lib/terminal/daemon-manager.ts @@ -352,39 +352,32 @@ export class DaemonTerminalManager extends EventEmitter { async killByWorkspaceId( workspaceId: string, ): Promise<{ killed: number; failed: number }> { - // Collect paneIds to kill (from local state or daemon) - let paneIdsToKill: string[] = []; + // Always query daemon for the authoritative list of sessions + // Local sessions map may be incomplete after app restart + const paneIdsToKill = new Set(); - // First check local sessions map - const localSessions = Array.from(this.sessions.entries()).filter( - ([, session]) => session.workspaceId === workspaceId, - ); - paneIdsToKill = localSessions.map(([paneId]) => paneId); - - // If no local sessions, query daemon directly - // This handles the case where app restarted but daemon still has sessions - if (paneIdsToKill.length === 0) { - try { - const response = await this.client.listSessions(); - const daemonSessions = response.sessions.filter( - (s) => s.workspaceId === workspaceId && s.isAlive, - ); - - if (daemonSessions.length > 0) { - console.log( - `[DaemonTerminalManager] Found ${daemonSessions.length} orphaned daemon sessions for workspace ${workspaceId}`, - ); - paneIdsToKill = daemonSessions.map((s) => s.paneId); + // Query daemon for all sessions in this workspace + try { + const response = await this.client.listSessions(); + for (const session of response.sessions) { + if (session.workspaceId === workspaceId && session.isAlive) { + paneIdsToKill.add(session.paneId); + } + } + } catch (error) { + console.warn( + "[DaemonTerminalManager] Failed to query daemon for sessions:", + error, + ); + // Fall back to local sessions if daemon query fails + for (const [paneId, session] of this.sessions.entries()) { + if (session.workspaceId === workspaceId) { + paneIdsToKill.add(paneId); } - } catch (error) { - console.warn( - "[DaemonTerminalManager] Failed to query daemon for sessions:", - error, - ); } } - if (paneIdsToKill.length === 0) { + if (paneIdsToKill.size === 0) { return { killed: 0, failed: 0 }; } @@ -409,17 +402,8 @@ export class DaemonTerminalManager extends EventEmitter { } async getSessionCountByWorkspaceId(workspaceId: string): Promise { - // First check local sessions - const localCount = Array.from(this.sessions.values()).filter( - (session) => session.workspaceId === workspaceId && session.isAlive, - ).length; - - if (localCount > 0) { - return localCount; - } - - // If no local sessions, query daemon directly - // This handles the case where app restarted but daemon still has sessions + // Always query daemon for the authoritative count + // Local sessions map may be incomplete after app restart try { const response = await this.client.listSessions(); return response.sessions.filter( @@ -430,7 +414,10 @@ export class DaemonTerminalManager extends EventEmitter { "[DaemonTerminalManager] Failed to query daemon for session count:", error, ); - return 0; + // Fall back to local sessions if daemon query fails + return Array.from(this.sessions.values()).filter( + (session) => session.workspaceId === workspaceId && session.isAlive, + ).length; } } From 68ff9ab4f72ca681a0b501ff8bd1946bbaaaa937 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 09:22:41 +0200 Subject: [PATCH 49/98] feat(desktop): add daemon restart button to Terminal settings - Add shutdown IPC request type to daemon protocol - Add shutdown handler to daemon (graceful shutdown after response) - Add shutdown() method to terminal host client - Add restartDaemon tRPC endpoint in settings router - Add 'Restart Daemon' button in Terminal settings (visible when persistence enabled) This allows users to restart the daemon to pick up new code after app updates. --- .../src/lib/trpc/routers/settings/index.ts | 30 +++++++++++++++ .../src/main/lib/terminal-host/client.ts | 17 +++++++++ .../src/main/lib/terminal-host/types.ts | 9 +++++ apps/desktop/src/main/terminal-host/index.ts | 26 +++++++++++++ .../SettingsView/TerminalSettings.tsx | 38 +++++++++++++++++++ 5 files changed, 120 insertions(+) diff --git a/apps/desktop/src/lib/trpc/routers/settings/index.ts b/apps/desktop/src/lib/trpc/routers/settings/index.ts index c75eab773cd..1b782960427 100644 --- a/apps/desktop/src/lib/trpc/routers/settings/index.ts +++ b/apps/desktop/src/lib/trpc/routers/settings/index.ts @@ -4,6 +4,10 @@ import { type TerminalPreset, } from "@superset/local-db"; import { localDb } from "main/lib/local-db"; +import { + disposeTerminalHostClient, + getTerminalHostClient, +} from "main/lib/terminal-host/client"; import { DEFAULT_CONFIRM_ON_QUIT, DEFAULT_NAVIGATION_STYLE, @@ -249,5 +253,31 @@ export const createSettingsRouter = () => { return { success: true }; }), + + /** + * Restart the terminal host daemon. + * This shuts down the current daemon and disposes the client. + * A new daemon will be spawned automatically on the next terminal operation. + * + * NOTE: This will NOT kill existing terminal sessions - they will be + * orphaned and the daemon will exit after cleaning them up. + */ + restartDaemon: publicProcedure.mutation(async () => { + try { + const client = getTerminalHostClient(); + // Request daemon shutdown (will kill sessions and exit) + await client.shutdown({ killSessions: true }); + } catch (error) { + console.warn( + "[settings] Daemon shutdown request failed (may already be stopped):", + error, + ); + } + + // Dispose the client so a new one is created on next use + disposeTerminalHostClient(); + + return { success: true }; + }), }); }; diff --git a/apps/desktop/src/main/lib/terminal-host/client.ts b/apps/desktop/src/main/lib/terminal-host/client.ts index dce65c558e7..9808196bf66 100644 --- a/apps/desktop/src/main/lib/terminal-host/client.ts +++ b/apps/desktop/src/main/lib/terminal-host/client.ts @@ -38,6 +38,7 @@ import { type ListSessionsResponse, PROTOCOL_VERSION, type ResizeRequest, + type ShutdownRequest, type TerminalDataEvent, type TerminalExitEvent, type WriteRequest, @@ -648,6 +649,22 @@ export class TerminalHostClient extends EventEmitter { )) as EmptyResponse; } + /** + * Shutdown the daemon gracefully. + * After calling this, the client should be disposed and a new daemon + * will be spawned on the next getTerminalHostClient() call. + */ + async shutdown(request: ShutdownRequest = {}): Promise { + await this.ensureConnected(); + const response = (await this.sendRequest( + "shutdown", + request, + )) as EmptyResponse; + // Disconnect after shutdown request is sent + this.disconnect(); + return response; + } + /** * Disconnect from daemon (but don't stop it) */ diff --git a/apps/desktop/src/main/lib/terminal-host/types.ts b/apps/desktop/src/main/lib/terminal-host/types.ts index 7ee82f8d96a..19734616cad 100644 --- a/apps/desktop/src/main/lib/terminal-host/types.ts +++ b/apps/desktop/src/main/lib/terminal-host/types.ts @@ -213,6 +213,14 @@ export interface ClearScrollbackRequest { sessionId: string; } +/** + * Shutdown the daemon gracefully + */ +export interface ShutdownRequest { + /** Optional: Kill all sessions before shutdown (default: false) */ + killSessions?: boolean; +} + // ============================================================================= // IPC Message Framing // ============================================================================= @@ -300,4 +308,5 @@ export type RequestTypeMap = { killAll: { request: KillAllRequest; response: EmptyResponse }; listSessions: { request: undefined; response: ListSessionsResponse }; clearScrollback: { request: ClearScrollbackRequest; response: EmptyResponse }; + shutdown: { request: ShutdownRequest; response: EmptyResponse }; }; diff --git a/apps/desktop/src/main/terminal-host/index.ts b/apps/desktop/src/main/terminal-host/index.ts index bf2e5876579..255c8c3fbaf 100644 --- a/apps/desktop/src/main/terminal-host/index.ts +++ b/apps/desktop/src/main/terminal-host/index.ts @@ -37,6 +37,7 @@ import { type KillRequest, PROTOCOL_VERSION, type ResizeRequest, + type ShutdownRequest, type WriteRequest, } from "../lib/terminal-host/types"; import { TerminalHost } from "./terminal-host"; @@ -313,6 +314,31 @@ const handlers: Record = { const response = terminalHost.clearScrollback(request); sendSuccess(socket, id, response); }, + + shutdown: (socket, id, payload, clientState) => { + if (!clientState.authenticated) { + sendError(socket, id, "NOT_AUTHENTICATED", "Must authenticate first"); + return; + } + + const request = payload as ShutdownRequest; + log("info", "Shutdown requested via IPC", { + killSessions: request.killSessions, + }); + + // Send success response before shutting down + sendSuccess(socket, id, { success: true }); + + // Kill sessions if requested + if (request.killSessions) { + terminalHost.killAll({ deleteHistory: false }); + } + + // Schedule shutdown after a brief delay to allow response to be sent + setTimeout(() => { + stopServer().then(() => process.exit(0)); + }, 100); + }, }; function handleRequest( diff --git a/apps/desktop/src/renderer/screens/main/components/SettingsView/TerminalSettings.tsx b/apps/desktop/src/renderer/screens/main/components/SettingsView/TerminalSettings.tsx index c93d97fe9d1..8cc93744710 100644 --- a/apps/desktop/src/renderer/screens/main/components/SettingsView/TerminalSettings.tsx +++ b/apps/desktop/src/renderer/screens/main/components/SettingsView/TerminalSettings.tsx @@ -1,4 +1,6 @@ +import { Button } from "@superset/ui/button"; import { Label } from "@superset/ui/label"; +import { toast } from "@superset/ui/sonner"; import { Switch } from "@superset/ui/switch"; import { trpc } from "renderer/lib/trpc"; @@ -32,10 +34,28 @@ export function TerminalSettings() { }, }); + const restartDaemon = trpc.settings.restartDaemon.useMutation({ + onSuccess: () => { + toast.success("Terminal daemon restarted", { + description: + "A new daemon will start automatically when you open a terminal.", + }); + }, + onError: (error) => { + toast.error("Failed to restart daemon", { + description: error.message, + }); + }, + }); + const handleToggle = (enabled: boolean) => { setTerminalPersistence.mutate({ enabled }); }; + const handleRestartDaemon = () => { + restartDaemon.mutate(); + }; + return (
@@ -69,6 +89,24 @@ export function TerminalSettings() { disabled={isLoading || setTerminalPersistence.isPending} />
+ + {/* Daemon Management - only show when persistence is enabled */} + {terminalPersistence && ( +
+

Terminal Daemon

+

+ Restart the terminal daemon to pick up new code after an app + update. This will close all terminal sessions. +

+ +
+ )}
); From c9bd4121ed77da3881e9709fdf22a09a2f4a3500 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 10:06:43 +0200 Subject: [PATCH 50/98] fix(desktop): externalize @xterm/headless in vite config --- apps/desktop/electron.vite.config.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/apps/desktop/electron.vite.config.ts b/apps/desktop/electron.vite.config.ts index 64a0e3801e7..a539c2e4c72 100644 --- a/apps/desktop/electron.vite.config.ts +++ b/apps/desktop/electron.vite.config.ts @@ -118,6 +118,7 @@ export default defineConfig({ "electron", "better-sqlite3", // Native module - must stay external "node-pty", // Native module - must stay external + "@xterm/headless", // Terminal headless emulator for daemon /^@sentry\/electron/, ], }, From 47fcd35420bb4b9ca341ffc6f8e060156eafa067 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 10:11:32 +0200 Subject: [PATCH 51/98] revert: remove @xterm/headless from externals @xterm/headless is a pure JS package that should be bundled, not externalized. Only native modules (better-sqlite3, node-pty) need to be external. Externalizing @xterm/headless caused the daemon to crash on startup because it couldn't find the module. --- apps/desktop/electron.vite.config.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/apps/desktop/electron.vite.config.ts b/apps/desktop/electron.vite.config.ts index a539c2e4c72..64a0e3801e7 100644 --- a/apps/desktop/electron.vite.config.ts +++ b/apps/desktop/electron.vite.config.ts @@ -118,7 +118,6 @@ export default defineConfig({ "electron", "better-sqlite3", // Native module - must stay external "node-pty", // Native module - must stay external - "@xterm/headless", // Terminal headless emulator for daemon /^@sentry\/electron/, ], }, From ce280f93d8dfc606f4462f26edfec15ca54b2056 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 10:52:09 +0200 Subject: [PATCH 52/98] fix(desktop): add timeout to daemon connection polling to prevent terminal hang - Add ConnectionState enum to replace boolean flag for clearer state management - Add 10-second timeout to ensureConnected() polling loop that was hanging forever - Properly set state to DISCONNECTED on connection failure for error recovery - Add error UI with retry button in Terminal component when connection fails Fixes terminal hang on initial app load when multiple terminals connect simultaneously. --- .../src/main/lib/terminal-host/client.ts | 52 +++++++++++++---- .../TabsContent/Terminal/Terminal.tsx | 58 ++++++++++++++++++- 2 files changed, 98 insertions(+), 12 deletions(-) diff --git a/apps/desktop/src/main/lib/terminal-host/client.ts b/apps/desktop/src/main/lib/terminal-host/client.ts index 9808196bf66..36dffbcf961 100644 --- a/apps/desktop/src/main/lib/terminal-host/client.ts +++ b/apps/desktop/src/main/lib/terminal-host/client.ts @@ -44,6 +44,16 @@ import { type WriteRequest, } from "./types"; +// ============================================================================= +// Connection State +// ============================================================================= + +enum ConnectionState { + DISCONNECTED = "disconnected", + CONNECTING = "connecting", + CONNECTED = "connected", +} + // ============================================================================= // Configuration // ============================================================================= @@ -126,7 +136,7 @@ export class TerminalHostClient extends EventEmitter { private pendingRequests = new Map(); private requestCounter = 0; private authenticated = false; - private connecting = false; + private connectionState = ConnectionState.DISCONNECTED; private disposed = false; // =========================================================================== @@ -138,22 +148,40 @@ export class TerminalHostClient extends EventEmitter { * Spawns daemon if needed. */ async ensureConnected(): Promise { - if (this.socket && this.authenticated) { + // Already connected - fast path + if ( + this.connectionState === ConnectionState.CONNECTED && + this.socket && + this.authenticated + ) { console.log("[TerminalHostClient] Already connected and authenticated"); return; } - if (this.connecting) { + // Another connection in progress - wait with timeout + if (this.connectionState === ConnectionState.CONNECTING) { console.log( "[TerminalHostClient] Connection already in progress, waiting...", ); - // Wait for existing connection attempt return new Promise((resolve, reject) => { + const startTime = Date.now(); + const WAIT_TIMEOUT_MS = 10000; // 10 seconds max wait + const checkConnection = () => { - if (this.socket && this.authenticated) { + if ( + this.connectionState === ConnectionState.CONNECTED && + this.socket && + this.authenticated + ) { resolve(); - } else if (!this.connecting) { - reject(new Error("Connection failed")); + } else if (this.connectionState === ConnectionState.DISCONNECTED) { + reject(new Error("Connection failed while waiting")); + } else if (Date.now() - startTime > WAIT_TIMEOUT_MS) { + reject( + new Error( + "Timeout waiting for connection - daemon may be unresponsive", + ), + ); } else { setTimeout(checkConnection, 100); } @@ -162,7 +190,7 @@ export class TerminalHostClient extends EventEmitter { }); } - this.connecting = true; + this.connectionState = ConnectionState.CONNECTING; console.log("[TerminalHostClient] Connecting to daemon..."); try { @@ -190,8 +218,11 @@ export class TerminalHostClient extends EventEmitter { console.log("[TerminalHostClient] Authenticating..."); await this.authenticate(); console.log("[TerminalHostClient] Authentication successful!"); - } finally { - this.connecting = false; + + this.connectionState = ConnectionState.CONNECTED; + } catch (error) { + this.connectionState = ConnectionState.DISCONNECTED; + throw error; } } @@ -305,6 +336,7 @@ export class TerminalHostClient extends EventEmitter { private handleDisconnect(): void { this.socket = null; this.authenticated = false; + this.connectionState = ConnectionState.DISCONNECTED; // Reject all pending requests for (const [id, pending] of this.pendingRequests.entries()) { diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index 9a46bc93f33..529b1ff02df 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -45,6 +45,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const [isSearchOpen, setIsSearchOpen] = useState(false); const [terminalCwd, setTerminalCwd] = useState(null); const [cwdConfirmed, setCwdConfirmed] = useState(false); + const [connectionError, setConnectionError] = useState(null); const setFocusedPane = useTabsStore((s) => s.setFocusedPane); const setTabAutoTitle = useTabsStore((s) => s.setTabAutoTitle); const updatePaneCwd = useTabsStore((s) => s.updatePaneCwd); @@ -194,6 +195,40 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { useTerminalCallbacksStore.getState().unregisterClearCallback, ); + const handleRetryConnection = useCallback(() => { + setConnectionError(null); + const xterm = xtermRef.current; + if (!xterm) return; + + xterm.clear(); + xterm.writeln("Retrying connection...\r\n"); + + createOrAttachRef.current( + { + paneId, + tabId: parentTabIdRef.current || paneId, + workspaceId, + cols: xterm.cols, + rows: xterm.rows, + }, + { + onSuccess: (result) => { + setConnectionError(null); + // Apply rehydration sequences first + if (result.snapshot?.rehydrateSequences) { + xterm.write(result.snapshot.rehydrateSequences); + } + xterm.write(result.scrollback); + setSubscriptionEnabled(true); + }, + onError: (error) => { + setConnectionError(error.message || "Connection failed"); + setSubscriptionEnabled(true); + }, + }, + ); + }, [paneId, workspaceId]); + const parentTabIdRef = useRef(parentTabId); parentTabIdRef.current = parentTabId; @@ -354,7 +389,9 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { setSubscriptionEnabled(true); flushPendingEvents(); }, - onError: () => { + onError: (error) => { + console.error("[Terminal] Failed to restart:", error); + setConnectionError(error.message || "Failed to restart terminal"); setSubscriptionEnabled(true); }, }, @@ -418,7 +455,9 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { setSubscriptionEnabled(true); flushPendingEvents(); }, - onError: () => { + onError: (error) => { + console.error("[Terminal] Failed to create/attach:", error); + setConnectionError(error.message || "Failed to connect to terminal"); setSubscriptionEnabled(true); }, }, @@ -537,6 +576,21 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { isOpen={isSearchOpen} onClose={() => setIsSearchOpen(false)} /> + {connectionError && ( +
+
+

Connection Error

+

{connectionError}

+
+ +
+ )}
); From 0694e7a9c29a6e529dd0c6717905ad268c7353a9 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 11:12:40 +0200 Subject: [PATCH 53/98] fix(desktop): force terminal refresh after scrollback restore xterm.write() is asynchronous - escape sequences may not be fully processed when the terminal first renders, causing garbled display. Force a re-render after write completes to ensure correct display. Symptom: restored terminals showed corrupted text until panel was resized. --- .../ContentView/TabsContent/Terminal/Terminal.tsx | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index 529b1ff02df..700a7f30cff 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -366,8 +366,13 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { xterm.write(result.snapshot.rehydrateSequences); } - // Then apply the scrollback content - xterm.write(result.scrollback); + // xterm.write() is asynchronous - escape sequences may not be fully + // processed when the terminal first renders, causing garbled display. + // Force a re-render after write completes to ensure correct display. + // (Symptom: restored terminals show corrupted text until resized) + xterm.write(result.scrollback, () => { + xterm.refresh(0, xterm.rows - 1); + }); updateCwdRef.current(result.scrollback); }; From 0c4f8264699a424e4980a081e2169f3826ed0a0f Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 11:22:41 +0200 Subject: [PATCH 54/98] fix(desktop): use fitAddon.fit() with requestAnimationFrame for terminal refresh The previous xterm.refresh() approach wasn't working because the write callback fires when data is parsed, not when it's rendered. Using fitAddon.fit() inside requestAnimationFrame ensures we're after the render cycle, triggering a full re-layout that fixes the garbled display. Also fixed handleRetryConnection which was missing the refresh fix. --- .../ContentView/TabsContent/Terminal/Terminal.tsx | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index 700a7f30cff..035938bd204 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -198,6 +198,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const handleRetryConnection = useCallback(() => { setConnectionError(null); const xterm = xtermRef.current; + const fitAddon = fitAddonRef.current; if (!xterm) return; xterm.clear(); @@ -218,7 +219,12 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { if (result.snapshot?.rehydrateSequences) { xterm.write(result.snapshot.rehydrateSequences); } - xterm.write(result.scrollback); + // Force re-render after write completes + xterm.write(result.scrollback, () => { + requestAnimationFrame(() => { + fitAddon?.fit(); + }); + }); setSubscriptionEnabled(true); }, onError: (error) => { @@ -370,8 +376,11 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { // processed when the terminal first renders, causing garbled display. // Force a re-render after write completes to ensure correct display. // (Symptom: restored terminals show corrupted text until resized) + // Using fitAddon.fit() which triggers a full re-layout and re-render. xterm.write(result.scrollback, () => { - xterm.refresh(0, xterm.rows - 1); + requestAnimationFrame(() => { + fitAddon.fit(); + }); }); updateCwdRef.current(result.scrollback); }; From 025a8d191bd0acfe362dbadab1312f1bbdd8926b Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 12:09:28 +0200 Subject: [PATCH 55/98] fix(desktop): dispose DaemonTerminalManager when restarting daemon The DaemonTerminalManager singleton caches a reference to the TerminalHostClient. When restartDaemon disposes the client, the manager still held the old disposed client reference, causing all terminal operations to hang. Fix: - Add disposeDaemonManager() function to reset the manager singleton - Call it from restartDaemon alongside disposeTerminalHostClient() - Also fix disconnect() to set connectionState to DISCONNECTED --- apps/desktop/src/lib/trpc/routers/settings/index.ts | 6 +++++- apps/desktop/src/main/lib/terminal-host/client.ts | 1 + apps/desktop/src/main/lib/terminal/daemon-manager.ts | 12 ++++++++++++ 3 files changed, 18 insertions(+), 1 deletion(-) diff --git a/apps/desktop/src/lib/trpc/routers/settings/index.ts b/apps/desktop/src/lib/trpc/routers/settings/index.ts index 1b782960427..419fe4ee67a 100644 --- a/apps/desktop/src/lib/trpc/routers/settings/index.ts +++ b/apps/desktop/src/lib/trpc/routers/settings/index.ts @@ -4,6 +4,7 @@ import { type TerminalPreset, } from "@superset/local-db"; import { localDb } from "main/lib/local-db"; +import { disposeDaemonManager } from "main/lib/terminal/daemon-manager"; import { disposeTerminalHostClient, getTerminalHostClient, @@ -274,8 +275,11 @@ export const createSettingsRouter = () => { ); } - // Dispose the client so a new one is created on next use + // Dispose both the client and the daemon manager so fresh instances + // are created on next use. The manager caches a client reference, + // so it must be disposed when the client is disposed. disposeTerminalHostClient(); + disposeDaemonManager(); return { success: true }; }), diff --git a/apps/desktop/src/main/lib/terminal-host/client.ts b/apps/desktop/src/main/lib/terminal-host/client.ts index 36dffbcf961..fc05a7139db 100644 --- a/apps/desktop/src/main/lib/terminal-host/client.ts +++ b/apps/desktop/src/main/lib/terminal-host/client.ts @@ -706,6 +706,7 @@ export class TerminalHostClient extends EventEmitter { this.socket = null; } this.authenticated = false; + this.connectionState = ConnectionState.DISCONNECTED; } /** diff --git a/apps/desktop/src/main/lib/terminal/daemon-manager.ts b/apps/desktop/src/main/lib/terminal/daemon-manager.ts index e14ee19717c..671fbc1e004 100644 --- a/apps/desktop/src/main/lib/terminal/daemon-manager.ts +++ b/apps/desktop/src/main/lib/terminal/daemon-manager.ts @@ -484,3 +484,15 @@ export function getDaemonTerminalManager(): DaemonTerminalManager { } return daemonManager; } + +/** + * Dispose the daemon manager singleton. + * Must be called when the terminal host client is disposed (e.g., daemon restart) + * to ensure the manager gets a fresh client reference on next use. + */ +export function disposeDaemonManager(): void { + if (daemonManager) { + daemonManager.removeAllListeners(); + daemonManager = null; + } +} From b5e3fb7ca15ec69f1619a25cf31843b4d6b38659 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 12:23:08 +0200 Subject: [PATCH 56/98] fix(desktop): reload window after daemon restart to clear stale terminal state Existing mounted terminals don't detect daemon restart - their tRPC subscriptions just stop receiving data silently. Reloading the window ensures all terminal components get fresh state and can reconnect to the new daemon. --- .../main/components/SettingsView/TerminalSettings.tsx | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/apps/desktop/src/renderer/screens/main/components/SettingsView/TerminalSettings.tsx b/apps/desktop/src/renderer/screens/main/components/SettingsView/TerminalSettings.tsx index 8cc93744710..d4c8441d25d 100644 --- a/apps/desktop/src/renderer/screens/main/components/SettingsView/TerminalSettings.tsx +++ b/apps/desktop/src/renderer/screens/main/components/SettingsView/TerminalSettings.tsx @@ -37,9 +37,13 @@ export function TerminalSettings() { const restartDaemon = trpc.settings.restartDaemon.useMutation({ onSuccess: () => { toast.success("Terminal daemon restarted", { - description: - "A new daemon will start automatically when you open a terminal.", + description: "Reloading window to reset terminal connections...", }); + // Reload the window after a short delay to let the toast show + // This ensures all terminal components get fresh state + setTimeout(() => { + window.location.reload(); + }, 1500); }, onError: (error) => { toast.error("Failed to restart daemon", { From 7cbc0ab4e7e0885e3029d5858119a587a985f58b Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 12:29:01 +0200 Subject: [PATCH 57/98] refactor(desktop): remove restart daemon button for v1 simplicity Manual recovery via 'pkill -f terminal-host' if daemon becomes unresponsive. Daemon will respawn automatically on next terminal operation. Auto-recovery can be implemented in v2 if users report frequent issues. --- .../src/lib/trpc/routers/settings/index.ts | 34 --------------- .../SettingsView/TerminalSettings.tsx | 42 ------------------- 2 files changed, 76 deletions(-) diff --git a/apps/desktop/src/lib/trpc/routers/settings/index.ts b/apps/desktop/src/lib/trpc/routers/settings/index.ts index 419fe4ee67a..c75eab773cd 100644 --- a/apps/desktop/src/lib/trpc/routers/settings/index.ts +++ b/apps/desktop/src/lib/trpc/routers/settings/index.ts @@ -4,11 +4,6 @@ import { type TerminalPreset, } from "@superset/local-db"; import { localDb } from "main/lib/local-db"; -import { disposeDaemonManager } from "main/lib/terminal/daemon-manager"; -import { - disposeTerminalHostClient, - getTerminalHostClient, -} from "main/lib/terminal-host/client"; import { DEFAULT_CONFIRM_ON_QUIT, DEFAULT_NAVIGATION_STYLE, @@ -254,34 +249,5 @@ export const createSettingsRouter = () => { return { success: true }; }), - - /** - * Restart the terminal host daemon. - * This shuts down the current daemon and disposes the client. - * A new daemon will be spawned automatically on the next terminal operation. - * - * NOTE: This will NOT kill existing terminal sessions - they will be - * orphaned and the daemon will exit after cleaning them up. - */ - restartDaemon: publicProcedure.mutation(async () => { - try { - const client = getTerminalHostClient(); - // Request daemon shutdown (will kill sessions and exit) - await client.shutdown({ killSessions: true }); - } catch (error) { - console.warn( - "[settings] Daemon shutdown request failed (may already be stopped):", - error, - ); - } - - // Dispose both the client and the daemon manager so fresh instances - // are created on next use. The manager caches a client reference, - // so it must be disposed when the client is disposed. - disposeTerminalHostClient(); - disposeDaemonManager(); - - return { success: true }; - }), }); }; diff --git a/apps/desktop/src/renderer/screens/main/components/SettingsView/TerminalSettings.tsx b/apps/desktop/src/renderer/screens/main/components/SettingsView/TerminalSettings.tsx index d4c8441d25d..c93d97fe9d1 100644 --- a/apps/desktop/src/renderer/screens/main/components/SettingsView/TerminalSettings.tsx +++ b/apps/desktop/src/renderer/screens/main/components/SettingsView/TerminalSettings.tsx @@ -1,6 +1,4 @@ -import { Button } from "@superset/ui/button"; import { Label } from "@superset/ui/label"; -import { toast } from "@superset/ui/sonner"; import { Switch } from "@superset/ui/switch"; import { trpc } from "renderer/lib/trpc"; @@ -34,32 +32,10 @@ export function TerminalSettings() { }, }); - const restartDaemon = trpc.settings.restartDaemon.useMutation({ - onSuccess: () => { - toast.success("Terminal daemon restarted", { - description: "Reloading window to reset terminal connections...", - }); - // Reload the window after a short delay to let the toast show - // This ensures all terminal components get fresh state - setTimeout(() => { - window.location.reload(); - }, 1500); - }, - onError: (error) => { - toast.error("Failed to restart daemon", { - description: error.message, - }); - }, - }); - const handleToggle = (enabled: boolean) => { setTerminalPersistence.mutate({ enabled }); }; - const handleRestartDaemon = () => { - restartDaemon.mutate(); - }; - return (
@@ -93,24 +69,6 @@ export function TerminalSettings() { disabled={isLoading || setTerminalPersistence.isPending} />
- - {/* Daemon Management - only show when persistence is enabled */} - {terminalPersistence && ( -
-

Terminal Daemon

-

- Restart the terminal daemon to pick up new code after an app - update. This will close all terminal sessions. -

- -
- )}
); From 90e00ce2b13c999759a9af07bbed41d7b9a2cadb Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 12:44:14 +0200 Subject: [PATCH 58/98] fix(desktop): detect daemon disconnect and show error UI in existing terminals When the daemon is killed or crashes, existing terminals now: - Receive disconnect events through tRPC subscription - Show error overlay with 'Retry Connection' button - Can reconnect when daemon respawns Changes: - DaemonTerminalManager emits disconnect events for all sessions on client disconnect - Terminal router forwards disconnect events through stream subscription - Terminal.tsx handles disconnect event to show error UI --- .../src/lib/trpc/routers/terminal/terminal.ts | 7 +++++++ .../src/main/lib/terminal/daemon-manager.ts | 17 ++++++++++++++++- .../TabsContent/Terminal/Terminal.tsx | 9 ++++++++- .../ContentView/TabsContent/Terminal/types.ts | 3 ++- 4 files changed, 33 insertions(+), 3 deletions(-) diff --git a/apps/desktop/src/lib/trpc/routers/terminal/terminal.ts b/apps/desktop/src/lib/trpc/routers/terminal/terminal.ts index fb783f42caa..e14cb8c7632 100644 --- a/apps/desktop/src/lib/trpc/routers/terminal/terminal.ts +++ b/apps/desktop/src/lib/trpc/routers/terminal/terminal.ts @@ -257,6 +257,7 @@ export const createTerminalRouter = () => { return observable< | { type: "data"; data: string } | { type: "exit"; exitCode: number; signal?: number } + | { type: "disconnect"; reason: string } >((emit) => { const onData = (data: string) => { emit.next({ type: "data", data }); @@ -267,13 +268,19 @@ export const createTerminalRouter = () => { emit.complete(); }; + const onDisconnect = (reason: string) => { + emit.next({ type: "disconnect", reason }); + }; + terminalManager.on(`data:${paneId}`, onData); terminalManager.on(`exit:${paneId}`, onExit); + terminalManager.on(`disconnect:${paneId}`, onDisconnect); // Cleanup on unsubscribe return () => { terminalManager.off(`data:${paneId}`, onData); terminalManager.off(`exit:${paneId}`, onExit); + terminalManager.off(`disconnect:${paneId}`, onDisconnect); }; }); }), diff --git a/apps/desktop/src/main/lib/terminal/daemon-manager.ts b/apps/desktop/src/main/lib/terminal/daemon-manager.ts index 671fbc1e004..d80ef3a3d65 100644 --- a/apps/desktop/src/main/lib/terminal/daemon-manager.ts +++ b/apps/desktop/src/main/lib/terminal/daemon-manager.ts @@ -97,13 +97,28 @@ export class DaemonTerminalManager extends EventEmitter { }, ); - // Handle client disconnection + // Handle client disconnection - notify all active sessions this.client.on("disconnected", () => { console.warn("[DaemonTerminalManager] Disconnected from daemon"); + // Emit disconnect event for all active sessions so terminals can show error UI + for (const [paneId, session] of this.sessions.entries()) { + if (session.isAlive) { + this.emit( + `disconnect:${paneId}`, + "Connection to terminal daemon lost", + ); + } + } }); this.client.on("error", (error: Error) => { console.error("[DaemonTerminalManager] Client error:", error.message); + // Emit error event for all active sessions + for (const [paneId, session] of this.sessions.entries()) { + if (session.isAlive) { + this.emit(`disconnect:${paneId}`, error.message); + } + } }); } diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index 035938bd204..48812ea9958 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -264,6 +264,9 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { `\r\n\r\n[Process exited with code ${event.exitCode}]`, ); xtermRef.current.writeln("[Press any key to restart]"); + } else if (event.type === "disconnect") { + // Daemon connection lost - show error UI with retry option + setConnectionError(event.reason || "Connection to terminal daemon lost"); } }; @@ -342,11 +345,15 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { if (event.type === "data") { xterm.write(event.data); updateCwdRef.current(event.data); - } else { + } else if (event.type === "exit") { isExitedRef.current = true; setSubscriptionEnabled(false); xterm.writeln(`\r\n\r\n[Process exited with code ${event.exitCode}]`); xterm.writeln("[Press any key to restart]"); + } else if (event.type === "disconnect") { + setConnectionError( + event.reason || "Connection to terminal daemon lost", + ); } } }; diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/types.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/types.ts index 29e41dff6d5..1cc40404f89 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/types.ts +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/types.ts @@ -5,4 +5,5 @@ export interface TerminalProps { export type TerminalStreamEvent = | { type: "data"; data: string } - | { type: "exit"; exitCode: number }; + | { type: "exit"; exitCode: number } + | { type: "disconnect"; reason: string }; From f2a27dd76f84e91a094ed02d91d082040a8dee85 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 13:50:33 +0200 Subject: [PATCH 59/98] fix(desktop): gate TUI restoration until xterm renderer is ready When restoring TUI applications (claude, vim, etc.) after app restart, keyboard input would fail with xterm crash: 'Cannot read properties of undefined (reading dimensions)'. Root cause: xterm's internal viewport/render service wasn't fully initialized when rehydrateSequences (alternate screen mode escapes) were written immediately after open(). Fix: Gate restoration until xterm fires its first onRender event, then apply pending restoration data. This ensures the renderer is ready to handle escape sequences that modify terminal state. - Add didFirstRenderRef to track when xterm has rendered once - Add pendingInitialStateRef to store restoration data - Add maybeApplyInitialState() that runs only when both conditions met - Apply same pattern to all three restore paths: createOrAttach, restartTerminal, handleRetryConnection --- .../TabsContent/Terminal/Terminal.tsx | 251 +++++++++++------- 1 file changed, 152 insertions(+), 99 deletions(-) diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index 48812ea9958..3718221ccd2 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -1,7 +1,7 @@ import { toast } from "@superset/ui/sonner"; import type { FitAddon } from "@xterm/addon-fit"; import type { SearchAddon } from "@xterm/addon-search"; -import type { Terminal as XTerm } from "@xterm/xterm"; +import type { IDisposable, Terminal as XTerm } from "@xterm/xterm"; import "@xterm/xterm/css/xterm.css"; import debounce from "lodash/debounce"; import { useCallback, useEffect, useRef, useState } from "react"; @@ -26,6 +26,21 @@ import { TerminalSearch } from "./TerminalSearch"; import type { TerminalProps, TerminalStreamEvent } from "./types"; import { shellEscapePaths } from "./utils"; +type CreateOrAttachResult = { + wasRecovered: boolean; + isNew: boolean; + scrollback: string; + snapshot?: { + snapshotAnsi: string; + rehydrateSequences: string; + cwd: string | null; + modes: Record; + cols: number; + rows: number; + scrollbackLines: number; + }; +}; + export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const paneId = tabId; const panes = useTabsStore((s) => s.panes); @@ -41,7 +56,6 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const isExitedRef = useRef(false); const pendingEventsRef = useRef([]); const commandBufferRef = useRef(""); - const [subscriptionEnabled, setSubscriptionEnabled] = useState(false); const [isSearchOpen, setIsSearchOpen] = useState(false); const [terminalCwd, setTerminalCwd] = useState(null); const [cwdConfirmed, setCwdConfirmed] = useState(false); @@ -58,6 +72,14 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const isFocused = pane?.tabId ? focusedPaneIds[pane.tabId] === paneId : false; + // Gate streaming until initial state restoration is applied to avoid interleaving output. + const isStreamReadyRef = useRef(false); + + // Gate restoration until xterm has rendered at least once (renderer/viewport ready). + const didFirstRenderRef = useRef(false); + const pendingInitialStateRef = useRef(null); + const renderDisposableRef = useRef(null); + // Refs avoid effect re-runs when these values change const isFocusedRef = useRef(isFocused); isFocusedRef.current = isFocused; @@ -195,12 +217,97 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { useTerminalCallbacksStore.getState().unregisterClearCallback, ); + const parentTabIdRef = useRef(parentTabId); + parentTabIdRef.current = parentTabId; + + const setTabAutoTitleRef = useRef(setTabAutoTitle); + setTabAutoTitleRef.current = setTabAutoTitle; + + const debouncedSetTabAutoTitleRef = useRef( + debounce((tabId: string, title: string) => { + setTabAutoTitleRef.current(tabId, title); + }, 100), + ); + + const flushPendingEvents = useCallback(() => { + const xterm = xtermRef.current; + if (!xterm) return; + if (pendingEventsRef.current.length === 0) return; + + const events = pendingEventsRef.current.splice( + 0, + pendingEventsRef.current.length, + ); + + for (const event of events) { + if (event.type === "data") { + xterm.write(event.data); + updateCwdRef.current(event.data); + } else if (event.type === "exit") { + isExitedRef.current = true; + isStreamReadyRef.current = false; + xterm.writeln(`\r\n\r\n[Process exited with code ${event.exitCode}]`); + xterm.writeln("[Press any key to restart]"); + } else if (event.type === "disconnect") { + setConnectionError( + event.reason || "Connection to terminal daemon lost", + ); + } + } + }, []); + + const maybeApplyInitialState = useCallback(() => { + if (!didFirstRenderRef.current) return; + const result = pendingInitialStateRef.current; + if (!result) return; + + const xterm = xtermRef.current; + const fitAddon = fitAddonRef.current; + if (!xterm || !fitAddon) return; + + // Clear before applying to prevent double-apply on concurrent triggers. + pendingInitialStateRef.current = null; + + try { + // Apply rehydration sequences FIRST to restore terminal modes + // (e.g., alternate screen, app cursor mode, bracketed paste) + // This must come before the scrollback content for correct TUI restoration + if (result.snapshot?.rehydrateSequences) { + xterm.write(result.snapshot.rehydrateSequences); + } + + // xterm.write() is asynchronous - escape sequences may not be fully + // processed when the terminal first renders, causing garbled display. + // Force a re-render after write completes to ensure correct display. + // (Symptom: restored terminals show corrupted text until resized) + // Using fitAddon.fit() which triggers a full re-layout and re-render. + xterm.write(result.scrollback, () => { + requestAnimationFrame(() => { + try { + fitAddon.fit(); + } catch (error) { + console.warn("[Terminal] fit() failed after restoration:", error); + } + }); + }); + updateCwdRef.current(result.scrollback); + } catch (error) { + console.error("[Terminal] Restoration failed:", error); + } + + // Enable streaming after initial state has been queued into xterm's write buffer. + isStreamReadyRef.current = true; + flushPendingEvents(); + }, [flushPendingEvents]); + const handleRetryConnection = useCallback(() => { setConnectionError(null); const xterm = xtermRef.current; - const fitAddon = fitAddonRef.current; if (!xterm) return; + isStreamReadyRef.current = false; + pendingInitialStateRef.current = null; + xterm.clear(); xterm.writeln("Retrying connection...\r\n"); @@ -215,41 +322,21 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { { onSuccess: (result) => { setConnectionError(null); - // Apply rehydration sequences first - if (result.snapshot?.rehydrateSequences) { - xterm.write(result.snapshot.rehydrateSequences); - } - // Force re-render after write completes - xterm.write(result.scrollback, () => { - requestAnimationFrame(() => { - fitAddon?.fit(); - }); - }); - setSubscriptionEnabled(true); + pendingInitialStateRef.current = result; + maybeApplyInitialState(); }, onError: (error) => { setConnectionError(error.message || "Connection failed"); - setSubscriptionEnabled(true); + isStreamReadyRef.current = true; + flushPendingEvents(); }, }, ); - }, [paneId, workspaceId]); - - const parentTabIdRef = useRef(parentTabId); - parentTabIdRef.current = parentTabId; - - const setTabAutoTitleRef = useRef(setTabAutoTitle); - setTabAutoTitleRef.current = setTabAutoTitle; - - const debouncedSetTabAutoTitleRef = useRef( - debounce((tabId: string, title: string) => { - setTabAutoTitleRef.current(tabId, title); - }, 100), - ); + }, [paneId, workspaceId, maybeApplyInitialState, flushPendingEvents]); const handleStreamData = (event: TerminalStreamEvent) => { // Queue events until terminal is ready to prevent data loss - if (!xtermRef.current || !subscriptionEnabled) { + if (!xtermRef.current || !isStreamReadyRef.current) { pendingEventsRef.current.push(event); return; } @@ -259,7 +346,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { updateCwdFromData(event.data); } else if (event.type === "exit") { isExitedRef.current = true; - setSubscriptionEnabled(false); + isStreamReadyRef.current = false; xtermRef.current.writeln( `\r\n\r\n[Process exited with code ${event.exitCode}]`, ); @@ -323,6 +410,9 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { xtermRef.current = xterm; fitAddonRef.current = fitAddon; isExitedRef.current = false; + isStreamReadyRef.current = false; + didFirstRenderRef.current = false; + pendingInitialStateRef.current = null; if (isFocusedRef.current) { xterm.focus(); @@ -335,66 +425,19 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { searchAddonRef.current = searchAddon; }); - const flushPendingEvents = () => { - if (pendingEventsRef.current.length === 0) return; - const events = pendingEventsRef.current.splice( - 0, - pendingEventsRef.current.length, - ); - for (const event of events) { - if (event.type === "data") { - xterm.write(event.data); - updateCwdRef.current(event.data); - } else if (event.type === "exit") { - isExitedRef.current = true; - setSubscriptionEnabled(false); - xterm.writeln(`\r\n\r\n[Process exited with code ${event.exitCode}]`); - xterm.writeln("[Press any key to restart]"); - } else if (event.type === "disconnect") { - setConnectionError( - event.reason || "Connection to terminal daemon lost", - ); - } - } - }; - - const applyInitialState = (result: { - wasRecovered: boolean; - isNew: boolean; - scrollback: string; - snapshot?: { - snapshotAnsi: string; - rehydrateSequences: string; - cwd: string | null; - modes: Record; - cols: number; - rows: number; - scrollbackLines: number; - }; - }) => { - // Apply rehydration sequences FIRST to restore terminal modes - // (e.g., alternate screen, app cursor mode, bracketed paste) - // This must come before the scrollback content for correct TUI restoration - if (result.snapshot?.rehydrateSequences) { - xterm.write(result.snapshot.rehydrateSequences); - } - - // xterm.write() is asynchronous - escape sequences may not be fully - // processed when the terminal first renders, causing garbled display. - // Force a re-render after write completes to ensure correct display. - // (Symptom: restored terminals show corrupted text until resized) - // Using fitAddon.fit() which triggers a full re-layout and re-render. - xterm.write(result.scrollback, () => { - requestAnimationFrame(() => { - fitAddon.fit(); - }); - }); - updateCwdRef.current(result.scrollback); - }; + // Wait for xterm to render once before applying restoration data. + // This prevents crashes when writing rehydrate escape sequences too early. + renderDisposableRef.current?.dispose(); + renderDisposableRef.current = xterm.onRender(() => { + renderDisposableRef.current?.dispose(); + renderDisposableRef.current = null; + didFirstRenderRef.current = true; + maybeApplyInitialState(); + }); const restartTerminal = () => { isExitedRef.current = false; - setSubscriptionEnabled(false); + isStreamReadyRef.current = false; xterm.clear(); createOrAttachRef.current( { @@ -406,14 +449,14 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { }, { onSuccess: (result) => { - applyInitialState(result); - setSubscriptionEnabled(true); - flushPendingEvents(); + pendingInitialStateRef.current = result; + maybeApplyInitialState(); }, onError: (error) => { console.error("[Terminal] Failed to restart:", error); setConnectionError(error.message || "Failed to restart terminal"); - setSubscriptionEnabled(true); + isStreamReadyRef.current = true; + flushPendingEvents(); }, }, ); @@ -470,16 +513,16 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { if (initialCommands || initialCwd) { clearPaneInitialDataRef.current(paneId); } - // Always apply initial state (scrollback) first, then flush pending events - // This ensures we don't lose terminal history when reattaching - applyInitialState(result); - setSubscriptionEnabled(true); - flushPendingEvents(); + // Defer initial state restoration until xterm has rendered once. + // Streaming is enabled only after restoration is queued into xterm. + pendingInitialStateRef.current = result; + maybeApplyInitialState(); }, onError: (error) => { console.error("[Terminal] Failed to create/attach:", error); setConnectionError(error.message || "Failed to connect to terminal"); - setSubscriptionEnabled(true); + isStreamReadyRef.current = true; + flushPendingEvents(); }, }, ); @@ -549,12 +592,22 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { debouncedSetTabAutoTitleRef.current?.cancel?.(); // Detach instead of kill to keep PTY running for reattachment detachRef.current({ paneId }); - setSubscriptionEnabled(false); + isStreamReadyRef.current = false; + didFirstRenderRef.current = false; + pendingInitialStateRef.current = null; + renderDisposableRef.current?.dispose(); + renderDisposableRef.current = null; xterm.dispose(); xtermRef.current = null; searchAddonRef.current = null; }; - }, [paneId, workspaceId, workspaceCwd]); + }, [ + paneId, + workspaceId, + workspaceCwd, + flushPendingEvents, + maybeApplyInitialState, + ]); useEffect(() => { const xterm = xtermRef.current; From 0ce3830e4a9a4c2e3f80dd4e7f0149e33f32cd5d Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 13:55:44 +0200 Subject: [PATCH 60/98] fix(desktop): don't auto-title from keyboard input when in TUI apps When typing in TUI apps (codex, vim, etc.) that use alternate screen mode, the auto-title feature was incorrectly capturing keyboard input (e.g. 'hello') and setting it as the tab name. Fix: Check xterm.buffer.active.type before setting auto-title from keyboard input. TUI apps use 'alternate' screen buffer, so we skip keyboard-based auto-titling for them. TUI apps can still set their own title via escape sequences (handled by onTitleChange). --- .../ContentView/TabsContent/Terminal/Terminal.tsx | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index 3718221ccd2..529947c380d 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -476,9 +476,13 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { }) => { const { domEvent } = event; if (domEvent.key === "Enter") { - const title = sanitizeForTitle(commandBufferRef.current); - if (title && parentTabIdRef.current) { - debouncedSetTabAutoTitleRef.current(parentTabIdRef.current, title); + // Don't auto-title from keyboard when in alternate screen (TUI apps like vim, codex) + // TUI apps set their own title via escape sequences handled by onTitleChange + if (xterm.buffer.active.type !== "alternate") { + const title = sanitizeForTitle(commandBufferRef.current); + if (title && parentTabIdRef.current) { + debouncedSetTabAutoTitleRef.current(parentTabIdRef.current, title); + } } commandBufferRef.current = ""; } else if (domEvent.key === "Backspace") { From ddfc11f4ece741a93be2e1e45ca6e484a127af69 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 14:01:03 +0200 Subject: [PATCH 61/98] fix(desktop): enter alternate screen mode before writing TUI restoration content After restoration, xterm.js didn't know it was in alternate screen mode because rehydrateSequences intentionally excludes the 1049 escape sequence (sending it after content would clear the screen). Fix: Check snapshot.modes.alternateScreen and send the alternate screen escape sequence BEFORE writing any content. This makes xterm.js properly track that it's in alternate buffer mode, which is needed for: - Correct auto-title behavior (don't capture keyboard in TUI apps) - Proper xterm buffer state for applications expecting alternate screen --- .../ContentView/TabsContent/Terminal/Terminal.tsx | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index 529947c380d..43f8fc85369 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -269,9 +269,16 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { pendingInitialStateRef.current = null; try { - // Apply rehydration sequences FIRST to restore terminal modes - // (e.g., alternate screen, app cursor mode, bracketed paste) - // This must come before the scrollback content for correct TUI restoration + // If session was in alternate screen mode, enter it BEFORE writing content. + // rehydrateSequences intentionally excludes alternate screen mode (1049) because + // sending it after content would clear the screen. We must send it first so xterm + // knows to use the alternate buffer, then write content into it. + if (result.snapshot?.modes.alternateScreen) { + xterm.write("\x1b[?1049h"); + } + + // Apply rehydration sequences to restore other terminal modes + // (app cursor mode, bracketed paste, mouse tracking, etc.) if (result.snapshot?.rehydrateSequences) { xterm.write(result.snapshot.rehydrateSequences); } From 982fc2dee6411c0afe17eaec0492b25030f3d624 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 14:13:30 +0200 Subject: [PATCH 62/98] chore(desktop): remove noisy 'Already connected' log from ensureConnected fast path This log fired on every single daemon API call (write, resize, etc.) which spammed the console with hundreds of messages. The fast path doesn't need logging since it's the normal successful case. --- apps/desktop/src/main/lib/terminal-host/client.ts | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/apps/desktop/src/main/lib/terminal-host/client.ts b/apps/desktop/src/main/lib/terminal-host/client.ts index fc05a7139db..763cf43bcb1 100644 --- a/apps/desktop/src/main/lib/terminal-host/client.ts +++ b/apps/desktop/src/main/lib/terminal-host/client.ts @@ -148,13 +148,12 @@ export class TerminalHostClient extends EventEmitter { * Spawns daemon if needed. */ async ensureConnected(): Promise { - // Already connected - fast path + // Already connected - fast path (no logging to avoid noise on every API call) if ( this.connectionState === ConnectionState.CONNECTED && this.socket && this.authenticated ) { - console.log("[TerminalHostClient] Already connected and authenticated"); return; } From e1e2016f6a3af9dcd5955727f5198bdce5ad649e Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 14:24:18 +0200 Subject: [PATCH 63/98] fix(desktop): track alternate screen mode ourselves instead of relying on xterm When the Terminal component remounts (HMR, recovery), a new xterm instance is created that doesn't know about escape sequences sent before it existed. Codex may have sent the alternate screen escape sequence, but the new xterm never saw it, so xterm.buffer.active.type incorrectly returns 'normal'. Fix: Track alternate screen mode ourselves via isAlternateScreenRef: - Set from snapshot.modes.alternateScreen on restore - Update when receiving escape sequences in stream data (1049h/l, 47h/l) - Use this ref instead of xterm.buffer.active.type for auto-title decisions - Reset on cleanup and terminal restart --- .../TabsContent/Terminal/Terminal.tsx | 29 ++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index 43f8fc85369..4a79f1e96f1 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -80,6 +80,10 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const pendingInitialStateRef = useRef(null); const renderDisposableRef = useRef(null); + // Track alternate screen mode ourselves (xterm.buffer.active.type is unreliable after HMR/recovery) + // Updated from: snapshot.modes.alternateScreen on restore, escape sequences in stream + const isAlternateScreenRef = useRef(false); + // Refs avoid effect re-runs when these values change const isFocusedRef = useRef(isFocused); isFocusedRef.current = isFocused; @@ -269,6 +273,10 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { pendingInitialStateRef.current = null; try { + // Track alternate screen mode from snapshot for our own reference + // (xterm.buffer.active.type is unreliable after HMR/recovery) + isAlternateScreenRef.current = !!result.snapshot?.modes.alternateScreen; + // If session was in alternate screen mode, enter it BEFORE writing content. // rehydrateSequences intentionally excludes alternate screen mode (1049) because // sending it after content would clear the screen. We must send it first so xterm @@ -349,6 +357,20 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { } if (event.type === "data") { + // Track alternate screen mode changes from escape sequences + // Check for both modern (1049) and legacy (47) alternate screen sequences + if ( + event.data.includes("\x1b[?1049h") || + event.data.includes("\x1b[?47h") + ) { + isAlternateScreenRef.current = true; + } + if ( + event.data.includes("\x1b[?1049l") || + event.data.includes("\x1b[?47l") + ) { + isAlternateScreenRef.current = false; + } xtermRef.current.write(event.data); updateCwdFromData(event.data); } else if (event.type === "exit") { @@ -445,6 +467,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const restartTerminal = () => { isExitedRef.current = false; isStreamReadyRef.current = false; + isAlternateScreenRef.current = false; // Reset for new shell xterm.clear(); createOrAttachRef.current( { @@ -485,7 +508,10 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { if (domEvent.key === "Enter") { // Don't auto-title from keyboard when in alternate screen (TUI apps like vim, codex) // TUI apps set their own title via escape sequences handled by onTitleChange - if (xterm.buffer.active.type !== "alternate") { + // Use our own tracking (isAlternateScreenRef) because xterm.buffer.active.type + // is unreliable after HMR or recovery - the new xterm instance doesn't know + // about escape sequences that were sent before it was created. + if (!isAlternateScreenRef.current) { const title = sanitizeForTitle(commandBufferRef.current); if (title && parentTabIdRef.current) { debouncedSetTabAutoTitleRef.current(parentTabIdRef.current, title); @@ -606,6 +632,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { isStreamReadyRef.current = false; didFirstRenderRef.current = false; pendingInitialStateRef.current = null; + isAlternateScreenRef.current = false; renderDisposableRef.current?.dispose(); renderDisposableRef.current = null; xterm.dispose(); From d65da340fea9d55b221de82ddd6b1f0ae325faba Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 14:29:03 +0200 Subject: [PATCH 64/98] fix(desktop): detect alternate screen mode from queued events and scrollback The previous fix tracked isAlternateScreenRef but only detected escape sequences in handleStreamData, which runs when isStreamReadyRef is true. Events arriving before stream was ready were queued to pendingEventsRef and flushed without parsing for escape sequences. This fix adds escape sequence detection to: 1. flushPendingEvents - for events queued during initial load 2. maybeApplyInitialState - parses scrollback for enter/exit sequences Fixes TUI apps (Codex, vim) incorrectly triggering auto-title from keyboard input. --- .../TabsContent/Terminal/Terminal.tsx | 29 +++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index 4a79f1e96f1..db2c56d1cd2 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -245,6 +245,20 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { for (const event of events) { if (event.type === "data") { + // Track alternate screen mode from queued events too + // (escape sequences sent before stream was ready) + if ( + event.data.includes("\x1b[?1049h") || + event.data.includes("\x1b[?47h") + ) { + isAlternateScreenRef.current = true; + } + if ( + event.data.includes("\x1b[?1049l") || + event.data.includes("\x1b[?47l") + ) { + isAlternateScreenRef.current = false; + } xterm.write(event.data); updateCwdRef.current(event.data); } else if (event.type === "exit") { @@ -277,6 +291,21 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { // (xterm.buffer.active.type is unreliable after HMR/recovery) isAlternateScreenRef.current = !!result.snapshot?.modes.alternateScreen; + // Also parse scrollback for escape sequences in case snapshot.modes is incomplete + // This handles cases where the daemon didn't track the mode but the sequences are in history + if (result.scrollback) { + const hasEnterAlt = + result.scrollback.includes("\x1b[?1049h") || + result.scrollback.includes("\x1b[?47h"); + const hasExitAlt = + result.scrollback.includes("\x1b[?1049l") || + result.scrollback.includes("\x1b[?47l"); + // If we see enter without exit, we're likely in alternate screen + if (hasEnterAlt && !hasExitAlt) { + isAlternateScreenRef.current = true; + } + } + // If session was in alternate screen mode, enter it BEFORE writing content. // rehydrateSequences intentionally excludes alternate screen mode (1049) because // sending it after content would clear the screen. We must send it first so xterm From 9c665bec694d50af6ca0ce19d4dd19e291459f20 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 19:01:15 +0200 Subject: [PATCH 65/98] fix(desktop): force redraw after terminal restore --- .../ContentView/TabsContent/Terminal/Terminal.tsx | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index db2c56d1cd2..3b2f95f291b 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -329,6 +329,11 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { requestAnimationFrame(() => { try { fitAddon.fit(); + // Keep PTY dimensions in sync even when FitAddon doesn't change cols/rows. + // This also forces full-screen TUIs (opencode, vim, etc.) to redraw after reattach. + if (xtermRef.current !== xterm) return; + resizeRef.current({ paneId, cols: xterm.cols, rows: xterm.rows }); + xterm.refresh(0, xterm.rows - 1); } catch (error) { console.warn("[Terminal] fit() failed after restoration:", error); } From a92026be4a4aecc9ed54fdf851f5f27c4f0e3098 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 19:21:36 +0200 Subject: [PATCH 66/98] fix(desktop): nudge resize to redraw TUIs after restore --- .../TabsContent/Terminal/Terminal.tsx | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-) diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index 3b2f95f291b..9f115133281 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -329,11 +329,23 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { requestAnimationFrame(() => { try { fitAddon.fit(); + if (xtermRef.current !== xterm) return; + + // Some full-screen TUIs don't reliably repaint after reattach unless they + // receive an actual resize signal. Nudge rows by 1 and revert to force a redraw. + const cols = xterm.cols; + const rows = xterm.rows; + if (isAlternateScreenRef.current && rows > 2) { + const nudgeRows = rows - 1; + xterm.resize(cols, nudgeRows); + resizeRef.current({ paneId, cols, rows: nudgeRows }); + xterm.resize(cols, rows); + } + // Keep PTY dimensions in sync even when FitAddon doesn't change cols/rows. // This also forces full-screen TUIs (opencode, vim, etc.) to redraw after reattach. - if (xtermRef.current !== xterm) return; - resizeRef.current({ paneId, cols: xterm.cols, rows: xterm.rows }); - xterm.refresh(0, xterm.rows - 1); + resizeRef.current({ paneId, cols, rows }); + xterm.refresh(0, rows - 1); } catch (error) { console.warn("[Terminal] fit() failed after restoration:", error); } From 9ee7f55c8be0d0c353aed2de4243e6065c689d98 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 19:25:58 +0200 Subject: [PATCH 67/98] fix(desktop): force repaint on reattached terminals --- .../ContentView/TabsContent/Terminal/Terminal.tsx | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index 9f115133281..8be911e51a5 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -331,11 +331,11 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { fitAddon.fit(); if (xtermRef.current !== xterm) return; - // Some full-screen TUIs don't reliably repaint after reattach unless they - // receive an actual resize signal. Nudge rows by 1 and revert to force a redraw. + // Reattached sessions can sometimes render partially until the user resizes the + // pane. Nudge rows by 1 and revert to force a full repaint + TUI redraw. const cols = xterm.cols; const rows = xterm.rows; - if (isAlternateScreenRef.current && rows > 2) { + if (!result.isNew && rows > 2) { const nudgeRows = rows - 1; xterm.resize(cols, nudgeRows); resizeRef.current({ paneId, cols, rows: nudgeRows }); From 22d8a7f5c8cbe1d81e314efe09fbfd305429c98f Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 20:22:56 +0200 Subject: [PATCH 68/98] fix(desktop): retry redraw after terminal restore --- .../TabsContent/Terminal/Terminal.tsx | 81 ++++++++++++------- 1 file changed, 53 insertions(+), 28 deletions(-) diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index 8be911e51a5..ad8bf196078 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -322,35 +322,60 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { // xterm.write() is asynchronous - escape sequences may not be fully // processed when the terminal first renders, causing garbled display. - // Force a re-render after write completes to ensure correct display. - // (Symptom: restored terminals show corrupted text until resized) - // Using fitAddon.fit() which triggers a full re-layout and re-render. - xterm.write(result.scrollback, () => { - requestAnimationFrame(() => { - try { - fitAddon.fit(); - if (xtermRef.current !== xterm) return; - - // Reattached sessions can sometimes render partially until the user resizes the - // pane. Nudge rows by 1 and revert to force a full repaint + TUI redraw. - const cols = xterm.cols; - const rows = xterm.rows; - if (!result.isNew && rows > 2) { - const nudgeRows = rows - 1; - xterm.resize(cols, nudgeRows); - resizeRef.current({ paneId, cols, rows: nudgeRows }); - xterm.resize(cols, rows); - } - - // Keep PTY dimensions in sync even when FitAddon doesn't change cols/rows. - // This also forces full-screen TUIs (opencode, vim, etc.) to redraw after reattach. - resizeRef.current({ paneId, cols, rows }); - xterm.refresh(0, rows - 1); - } catch (error) { - console.warn("[Terminal] fit() failed after restoration:", error); - } + // Force a re-render after write completes to ensure correct display. + // (Symptom: restored terminals show corrupted text until resized) + // Using fitAddon.fit() which triggers a full re-layout and re-render. + xterm.write(result.scrollback, () => { + const redraw = () => { + requestAnimationFrame(() => { + try { + fitAddon.fit(); + if (xtermRef.current !== xterm) return; + + // Reattached sessions can sometimes render partially until the user resizes the + // pane. Nudge rows by 1 and revert to force a full repaint + TUI redraw. + const cols = xterm.cols; + const rows = xterm.rows; + if (cols <= 0 || rows <= 0) return; + + if (!result.isNew && rows > 2) { + const nudgeRows = rows - 1; + xterm.resize(cols, nudgeRows); + resizeRef.current({ paneId, cols, rows: nudgeRows }); + xterm.resize(cols, rows); + } + + // Keep PTY dimensions in sync even when FitAddon doesn't change cols/rows. + // This also forces full-screen TUIs (opencode, vim, etc.) to redraw after reattach. + resizeRef.current({ paneId, cols, rows }); + xterm.refresh(0, rows - 1); + } catch (error) { + console.warn( + "[Terminal] redraw() failed after restoration:", + error, + ); + } + }); + }; + + const scheduleRedraw = (delayMs: number) => { + setTimeout(() => { + if (xtermRef.current !== xterm) return; + redraw(); + }, delayMs); + }; + + // Run multiple redraw passes to avoid timing issues with layout, fonts, and renderer init. + scheduleRedraw(0); + scheduleRedraw(50); + scheduleRedraw(250); + scheduleRedraw(1000); + + // If font metrics settle after restoration, run one more redraw. + void document.fonts?.ready.then(() => { + scheduleRedraw(0); + }); }); - }); updateCwdRef.current(result.scrollback); } catch (error) { console.error("[Terminal] Restoration failed:", error); From ff2edfa8bac77c84b7dcb2f7d743859a1ba41204 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 20:50:04 +0200 Subject: [PATCH 69/98] chore(desktop): fix terminal restore indentation --- .../TabsContent/Terminal/Terminal.tsx | 98 +++++++++---------- 1 file changed, 49 insertions(+), 49 deletions(-) diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index ad8bf196078..96a9f812a61 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -322,60 +322,60 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { // xterm.write() is asynchronous - escape sequences may not be fully // processed when the terminal first renders, causing garbled display. - // Force a re-render after write completes to ensure correct display. - // (Symptom: restored terminals show corrupted text until resized) - // Using fitAddon.fit() which triggers a full re-layout and re-render. - xterm.write(result.scrollback, () => { - const redraw = () => { - requestAnimationFrame(() => { - try { - fitAddon.fit(); - if (xtermRef.current !== xterm) return; - - // Reattached sessions can sometimes render partially until the user resizes the - // pane. Nudge rows by 1 and revert to force a full repaint + TUI redraw. - const cols = xterm.cols; - const rows = xterm.rows; - if (cols <= 0 || rows <= 0) return; - - if (!result.isNew && rows > 2) { - const nudgeRows = rows - 1; - xterm.resize(cols, nudgeRows); - resizeRef.current({ paneId, cols, rows: nudgeRows }); - xterm.resize(cols, rows); - } - - // Keep PTY dimensions in sync even when FitAddon doesn't change cols/rows. - // This also forces full-screen TUIs (opencode, vim, etc.) to redraw after reattach. - resizeRef.current({ paneId, cols, rows }); - xterm.refresh(0, rows - 1); - } catch (error) { - console.warn( - "[Terminal] redraw() failed after restoration:", - error, - ); - } - }); - }; - - const scheduleRedraw = (delayMs: number) => { - setTimeout(() => { + // Force a re-render after write completes to ensure correct display. + // (Symptom: restored terminals show corrupted text until resized) + // Using fitAddon.fit() which triggers a full re-layout and re-render. + xterm.write(result.scrollback, () => { + const redraw = () => { + requestAnimationFrame(() => { + try { + fitAddon.fit(); if (xtermRef.current !== xterm) return; - redraw(); - }, delayMs); - }; - // Run multiple redraw passes to avoid timing issues with layout, fonts, and renderer init. - scheduleRedraw(0); - scheduleRedraw(50); - scheduleRedraw(250); - scheduleRedraw(1000); + // Reattached sessions can sometimes render partially until the user resizes the + // pane. Nudge rows by 1 and revert to force a full repaint + TUI redraw. + const cols = xterm.cols; + const rows = xterm.rows; + if (cols <= 0 || rows <= 0) return; + + if (!result.isNew && rows > 2) { + const nudgeRows = rows - 1; + xterm.resize(cols, nudgeRows); + resizeRef.current({ paneId, cols, rows: nudgeRows }); + xterm.resize(cols, rows); + } - // If font metrics settle after restoration, run one more redraw. - void document.fonts?.ready.then(() => { - scheduleRedraw(0); + // Keep PTY dimensions in sync even when FitAddon doesn't change cols/rows. + // This also forces full-screen TUIs (opencode, vim, etc.) to redraw after reattach. + resizeRef.current({ paneId, cols, rows }); + xterm.refresh(0, rows - 1); + } catch (error) { + console.warn( + "[Terminal] redraw() failed after restoration:", + error, + ); + } }); + }; + + const scheduleRedraw = (delayMs: number) => { + setTimeout(() => { + if (xtermRef.current !== xterm) return; + redraw(); + }, delayMs); + }; + + // Run multiple redraw passes to avoid timing issues with layout, fonts, and renderer init. + scheduleRedraw(0); + scheduleRedraw(50); + scheduleRedraw(250); + scheduleRedraw(1000); + + // If font metrics settle after restoration, run one more redraw. + void document.fonts?.ready.then(() => { + scheduleRedraw(0); }); + }); updateCwdRef.current(result.scrollback); } catch (error) { console.error("[Terminal] Restoration failed:", error); From 99f6a36690b7a9524c4806955ea234a45a82fd28 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 20:59:34 +0200 Subject: [PATCH 70/98] fix(desktop): force repaint on restored TUIs --- .../TabsContent/Terminal/Terminal.tsx | 58 +++++++++++++++++-- 1 file changed, 52 insertions(+), 6 deletions(-) diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index 96a9f812a61..a92f9ff781d 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -206,11 +206,13 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const createOrAttachRef = useRef(createOrAttachMutation.mutate); const writeRef = useRef(writeMutation.mutate); const resizeRef = useRef(resizeMutation.mutate); + const resizeAsyncRef = useRef(resizeMutation.mutateAsync); const detachRef = useRef(detachMutation.mutate); const clearScrollbackRef = useRef(clearScrollbackMutation.mutate); createOrAttachRef.current = createOrAttachMutation.mutate; writeRef.current = writeMutation.mutate; resizeRef.current = resizeMutation.mutate; + resizeAsyncRef.current = resizeMutation.mutateAsync; detachRef.current = detachMutation.mutate; clearScrollbackRef.current = clearScrollbackMutation.mutate; @@ -326,6 +328,8 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { // (Symptom: restored terminals show corrupted text until resized) // Using fitAddon.fit() which triggers a full re-layout and re-render. xterm.write(result.scrollback, () => { + let didForceRepaint = false; + const redraw = () => { requestAnimationFrame(() => { try { @@ -333,16 +337,58 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { if (xtermRef.current !== xterm) return; // Reattached sessions can sometimes render partially until the user resizes the - // pane. Nudge rows by 1 and revert to force a full repaint + TUI redraw. + // pane. Nudge dimensions to force a full repaint + TUI redraw. const cols = xterm.cols; const rows = xterm.rows; if (cols <= 0 || rows <= 0) return; - if (!result.isNew && rows > 2) { - const nudgeRows = rows - 1; - xterm.resize(cols, nudgeRows); - resizeRef.current({ paneId, cols, rows: nudgeRows }); - xterm.resize(cols, rows); + if (!result.isNew && !didForceRepaint) { + didForceRepaint = true; + + void (async () => { + try { + if (xtermRef.current !== xterm) return; + + // TUIs run in alt-screen and don't care about scrollback reflow. + // Prefer nudging `cols` to force a full line reflow + repaint. + if (isAlternateScreenRef.current && cols > 2) { + const nudgeCols = cols - 1; + xterm.resize(nudgeCols, rows); + xterm.resize(cols, rows); + await resizeAsyncRef.current({ + paneId, + cols: nudgeCols, + rows, + }); + await new Promise((resolve) => { + setTimeout(resolve, 16); + }); + if (xtermRef.current !== xterm) return; + await resizeAsyncRef.current({ paneId, cols, rows }); + return; + } + + // For non-alt-screen, only nudge the PTY (avoid changing xterm scrollback). + if (rows > 2) { + const nudgeRows = rows - 1; + await resizeAsyncRef.current({ + paneId, + cols, + rows: nudgeRows, + }); + await new Promise((resolve) => { + setTimeout(resolve, 16); + }); + if (xtermRef.current !== xterm) return; + await resizeAsyncRef.current({ paneId, cols, rows }); + } + } catch (error) { + console.warn( + "[Terminal] force repaint failed after restoration:", + error, + ); + } + })(); } // Keep PTY dimensions in sync even when FitAddon doesn't change cols/rows. From 3d265168a8097224e13bf7ca275a9031e67227d6 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Tue, 30 Dec 2025 21:31:55 +0200 Subject: [PATCH 71/98] fix(desktop): smooth terminal restore repaint --- .../TabsContent/Terminal/Terminal.tsx | 91 +++++++------------ 1 file changed, 35 insertions(+), 56 deletions(-) diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index a92f9ff781d..1a7664980e3 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -79,6 +79,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const didFirstRenderRef = useRef(false); const pendingInitialStateRef = useRef(null); const renderDisposableRef = useRef(null); + const restoreSequenceRef = useRef(0); // Track alternate screen mode ourselves (xterm.buffer.active.type is unreliable after HMR/recovery) // Updated from: snapshot.modes.alternateScreen on restore, escape sequences in stream @@ -287,6 +288,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { // Clear before applying to prevent double-apply on concurrent triggers. pendingInitialStateRef.current = null; + const restoreSequence = ++restoreSequenceRef.current; try { // Track alternate screen mode from snapshot for our own reference @@ -333,55 +335,43 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const redraw = () => { requestAnimationFrame(() => { try { + if (restoreSequenceRef.current !== restoreSequence) return; + if (xtermRef.current !== xterm) return; + fitAddon.fit(); if (xtermRef.current !== xterm) return; - // Reattached sessions can sometimes render partially until the user resizes the - // pane. Nudge dimensions to force a full repaint + TUI redraw. + // Reattached sessions can sometimes render partially until the user resizes the pane. + // Force a repaint and (for restored TUIs) one SIGWINCH cycle to trigger a redraw. const cols = xterm.cols; const rows = xterm.rows; if (cols <= 0 || rows <= 0) return; - if (!result.isNew && !didForceRepaint) { + const shouldForceRepaint = + !result.isNew && isAlternateScreenRef.current && rows > 2; + + if (shouldForceRepaint && !didForceRepaint) { didForceRepaint = true; + const nudgeRows = rows - 1; + // Order matters: send the nudge, yield a frame, then restore. This ensures + // the PTY actually delivers SIGWINCH and the TUI repaints into the buffer. void (async () => { try { + await resizeAsyncRef.current({ + paneId, + cols, + rows: nudgeRows, + }); + await new Promise((resolve) => { + setTimeout(resolve, 16); + }); + if (restoreSequenceRef.current !== restoreSequence) return; if (xtermRef.current !== xterm) return; - - // TUIs run in alt-screen and don't care about scrollback reflow. - // Prefer nudging `cols` to force a full line reflow + repaint. - if (isAlternateScreenRef.current && cols > 2) { - const nudgeCols = cols - 1; - xterm.resize(nudgeCols, rows); - xterm.resize(cols, rows); - await resizeAsyncRef.current({ - paneId, - cols: nudgeCols, - rows, - }); - await new Promise((resolve) => { - setTimeout(resolve, 16); - }); - if (xtermRef.current !== xterm) return; - await resizeAsyncRef.current({ paneId, cols, rows }); - return; - } - - // For non-alt-screen, only nudge the PTY (avoid changing xterm scrollback). - if (rows > 2) { - const nudgeRows = rows - 1; - await resizeAsyncRef.current({ - paneId, - cols, - rows: nudgeRows, - }); - await new Promise((resolve) => { - setTimeout(resolve, 16); - }); - if (xtermRef.current !== xterm) return; - await resizeAsyncRef.current({ paneId, cols, rows }); - } + await resizeAsyncRef.current({ paneId, cols, rows }); + if (restoreSequenceRef.current !== restoreSequence) return; + if (xtermRef.current !== xterm) return; + xterm.refresh(0, rows - 1); } catch (error) { console.warn( "[Terminal] force repaint failed after restoration:", @@ -389,11 +379,10 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { ); } })(); + } else { + // Keep PTY dimensions in sync even when FitAddon doesn't change cols/rows. + resizeRef.current({ paneId, cols, rows }); } - - // Keep PTY dimensions in sync even when FitAddon doesn't change cols/rows. - // This also forces full-screen TUIs (opencode, vim, etc.) to redraw after reattach. - resizeRef.current({ paneId, cols, rows }); xterm.refresh(0, rows - 1); } catch (error) { console.warn( @@ -404,22 +393,12 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { }); }; - const scheduleRedraw = (delayMs: number) => { - setTimeout(() => { - if (xtermRef.current !== xterm) return; - redraw(); - }, delayMs); - }; - - // Run multiple redraw passes to avoid timing issues with layout, fonts, and renderer init. - scheduleRedraw(0); - scheduleRedraw(50); - scheduleRedraw(250); - scheduleRedraw(1000); - - // If font metrics settle after restoration, run one more redraw. + // Redraw once immediately, and once again after fonts settle. + redraw(); void document.fonts?.ready.then(() => { - scheduleRedraw(0); + if (restoreSequenceRef.current !== restoreSequence) return; + if (xtermRef.current !== xterm) return; + redraw(); }); }); updateCwdRef.current(result.scrollback); From 297682d8ae263a8a36145571966b7a6795ba6866 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Wed, 31 Dec 2025 09:23:25 +0200 Subject: [PATCH 72/98] fix(desktop): fix WebGL corruption on terminal restore - Clear xterm-webgl texture atlas after rehydration to force a clean repaint - Add a first-render fallback so restored sessions can't get stuck not-ready - Surface terminal stream error events --- .../src/main/lib/terminal/daemon-manager.ts | 9 ++ .../TabsContent/Terminal/Terminal.tsx | 105 +++++++++++------- .../TabsContent/Terminal/helpers.ts | 52 ++++++--- .../ContentView/TabsContent/Terminal/types.ts | 3 +- 4 files changed, 111 insertions(+), 58 deletions(-) diff --git a/apps/desktop/src/main/lib/terminal/daemon-manager.ts b/apps/desktop/src/main/lib/terminal/daemon-manager.ts index d80ef3a3d65..43fd0df4a5f 100644 --- a/apps/desktop/src/main/lib/terminal/daemon-manager.ts +++ b/apps/desktop/src/main/lib/terminal/daemon-manager.ts @@ -97,6 +97,15 @@ export class DaemonTerminalManager extends EventEmitter { }, ); + // Forward terminal-specific error events (e.g., write queue full) + this.client.on( + "terminalError", + (sessionId: string, error: string, code?: string) => { + const paneId = sessionId; + this.emit(`error:${paneId}`, { error, code }); + }, + ); + // Handle client disconnection - notify all active sessions this.client.on("disconnected", () => { console.warn("[DaemonTerminalManager] Disconnected from daemon"); diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index 1a7664980e3..7cc0100210f 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -20,12 +20,15 @@ import { setupKeyboardHandler, setupPasteHandler, setupResizeHandlers, + type TerminalRenderer, } from "./helpers"; import { parseCwd } from "./parseCwd"; import { TerminalSearch } from "./TerminalSearch"; import type { TerminalProps, TerminalStreamEvent } from "./types"; import { shellEscapePaths } from "./utils"; +const FIRST_RENDER_RESTORE_FALLBACK_MS = 250; + type CreateOrAttachResult = { wasRecovered: boolean; isNew: boolean; @@ -53,6 +56,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const xtermRef = useRef(null); const fitAddonRef = useRef(null); const searchAddonRef = useRef(null); + const rendererRef = useRef(null); const isExitedRef = useRef(false); const pendingEventsRef = useRef([]); const commandBufferRef = useRef(""); @@ -207,13 +211,11 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const createOrAttachRef = useRef(createOrAttachMutation.mutate); const writeRef = useRef(writeMutation.mutate); const resizeRef = useRef(resizeMutation.mutate); - const resizeAsyncRef = useRef(resizeMutation.mutateAsync); const detachRef = useRef(detachMutation.mutate); const clearScrollbackRef = useRef(clearScrollbackMutation.mutate); createOrAttachRef.current = createOrAttachMutation.mutate; writeRef.current = writeMutation.mutate; resizeRef.current = resizeMutation.mutate; - resizeAsyncRef.current = resizeMutation.mutateAsync; detachRef.current = detachMutation.mutate; clearScrollbackRef.current = clearScrollbackMutation.mutate; @@ -273,6 +275,18 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { setConnectionError( event.reason || "Connection to terminal daemon lost", ); + } else if (event.type === "error") { + const message = event.code + ? `${event.code}: ${event.error}` + : event.error; + console.warn("[Terminal] stream error:", message); + + // Don't block interaction for non-fatal issues like a paste drop. + if (event.code === "WRITE_QUEUE_FULL") { + xterm.writeln(`\r\n[Terminal] ${message}`); + } else { + setConnectionError(message); + } } } }, []); @@ -328,10 +342,8 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { // processed when the terminal first renders, causing garbled display. // Force a re-render after write completes to ensure correct display. // (Symptom: restored terminals show corrupted text until resized) - // Using fitAddon.fit() which triggers a full re-layout and re-render. + // Use fitAddon.fit() and (when using WebGL) clear the glyph atlas to force a full repaint. xterm.write(result.scrollback, () => { - let didForceRepaint = false; - const redraw = () => { requestAnimationFrame(() => { try { @@ -342,46 +354,23 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { if (xtermRef.current !== xterm) return; // Reattached sessions can sometimes render partially until the user resizes the pane. - // Force a repaint and (for restored TUIs) one SIGWINCH cycle to trigger a redraw. + // WebGL off fully fixes this, which strongly suggests a WebGL texture-atlas repaint bug. + // Clearing the atlas forces xterm-webgl to rebuild glyphs and repaint without a resize nudge. const cols = xterm.cols; const rows = xterm.rows; if (cols <= 0 || rows <= 0) return; - const shouldForceRepaint = - !result.isNew && isAlternateScreenRef.current && rows > 2; - - if (shouldForceRepaint && !didForceRepaint) { - didForceRepaint = true; - const nudgeRows = rows - 1; - - // Order matters: send the nudge, yield a frame, then restore. This ensures - // the PTY actually delivers SIGWINCH and the TUI repaints into the buffer. - void (async () => { - try { - await resizeAsyncRef.current({ - paneId, - cols, - rows: nudgeRows, - }); - await new Promise((resolve) => { - setTimeout(resolve, 16); - }); - if (restoreSequenceRef.current !== restoreSequence) return; - if (xtermRef.current !== xterm) return; - await resizeAsyncRef.current({ paneId, cols, rows }); - if (restoreSequenceRef.current !== restoreSequence) return; - if (xtermRef.current !== xterm) return; - xterm.refresh(0, rows - 1); - } catch (error) { - console.warn( - "[Terminal] force repaint failed after restoration:", - error, - ); - } - })(); - } else { - // Keep PTY dimensions in sync even when FitAddon doesn't change cols/rows. - resizeRef.current({ paneId, cols, rows }); + // Keep PTY dimensions in sync even when FitAddon doesn't change cols/rows. + resizeRef.current({ paneId, cols, rows }); + + if (!result.isNew) { + const renderer = rendererRef.current; + if (renderer?.kind === "webgl") { + // Clear twice: once immediately, and once after fonts settle. + // This reduces restore artifacts (especially for TUIs like opencode) + // and prevents stale glyphs when fonts swap in. + renderer.clearTextureAtlas?.(); + } } xterm.refresh(0, rows - 1); } catch (error) { @@ -409,7 +398,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { // Enable streaming after initial state has been queued into xterm's write buffer. isStreamReadyRef.current = true; flushPendingEvents(); - }, [flushPendingEvents]); + }, [flushPendingEvents, paneId]); const handleRetryConnection = useCallback(() => { setConnectionError(null); @@ -479,6 +468,17 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { } else if (event.type === "disconnect") { // Daemon connection lost - show error UI with retry option setConnectionError(event.reason || "Connection to terminal daemon lost"); + } else if (event.type === "error") { + const message = event.code + ? `${event.code}: ${event.error}` + : event.error; + console.warn("[Terminal] stream error:", message); + + if (event.code === "WRITE_QUEUE_FULL") { + xtermRef.current.writeln(`\r\n[Terminal] ${message}`); + } else { + setConnectionError(message); + } } }; @@ -525,6 +525,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const { xterm, fitAddon, + renderer, cleanup: cleanupQuerySuppression, } = createTerminalInstance(container, { cwd: workspaceCwd, @@ -534,6 +535,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { }); xtermRef.current = xterm; fitAddonRef.current = fitAddon; + rendererRef.current = renderer; isExitedRef.current = false; isStreamReadyRef.current = false; didFirstRenderRef.current = false; @@ -553,13 +555,28 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { // Wait for xterm to render once before applying restoration data. // This prevents crashes when writing rehydrate escape sequences too early. renderDisposableRef.current?.dispose(); + let firstRenderFallback: ReturnType | null = null; + renderDisposableRef.current = xterm.onRender(() => { + if (firstRenderFallback) { + clearTimeout(firstRenderFallback); + firstRenderFallback = null; + } renderDisposableRef.current?.dispose(); renderDisposableRef.current = null; didFirstRenderRef.current = true; maybeApplyInitialState(); }); + // Failure-proofing: if the renderer never emits an initial render (e.g. WebGL hiccup, + // offscreen mount), don't leave the session stuck in "not ready" forever. + firstRenderFallback = setTimeout(() => { + if (isUnmounted) return; + if (didFirstRenderRef.current) return; + didFirstRenderRef.current = true; + maybeApplyInitialState(); + }, FIRST_RENDER_RESTORE_FALLBACK_MS); + const restartTerminal = () => { isExitedRef.current = false; isStreamReadyRef.current = false; @@ -712,6 +729,9 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { return () => { isUnmounted = true; + if (firstRenderFallback) { + clearTimeout(firstRenderFallback); + } inputDisposable.dispose(); keyDisposable.dispose(); titleDisposable.dispose(); @@ -734,6 +754,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { xterm.dispose(); xtermRef.current = null; searchAddonRef.current = null; + rendererRef.current = null; }; }, [ paneId, diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/helpers.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/helpers.ts index 89473cdf9d6..c726f7f8cc3 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/helpers.ts +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/helpers.ts @@ -60,35 +60,55 @@ export function getDefaultTerminalBg(): string { * Load GPU-accelerated renderer with automatic fallback. * Tries WebGL first, falls back to Canvas if WebGL fails. */ -function loadRenderer(xterm: XTerm): { dispose: () => void } { +export type TerminalRenderer = { + kind: "webgl" | "canvas" | "dom"; + dispose: () => void; + clearTextureAtlas?: () => void; +}; + +function loadRenderer(xterm: XTerm): TerminalRenderer { let renderer: WebglAddon | CanvasAddon | null = null; + let webglAddon: WebglAddon | null = null; + let kind: TerminalRenderer["kind"] = "dom"; + + const tryLoadCanvas = () => { + try { + renderer = new CanvasAddon(); + xterm.loadAddon(renderer); + kind = "canvas"; + } catch { + // Canvas fallback failed, use default renderer + } + }; try { - const webglAddon = new WebglAddon(); + webglAddon = new WebglAddon(); webglAddon.onContextLoss(() => { - webglAddon.dispose(); - try { - renderer = new CanvasAddon(); - xterm.loadAddon(renderer); - } catch { - // Canvas fallback failed, use default renderer - } + webglAddon?.dispose(); + webglAddon = null; + tryLoadCanvas(); }); xterm.loadAddon(webglAddon); renderer = webglAddon; + kind = "webgl"; } catch { - try { - renderer = new CanvasAddon(); - xterm.loadAddon(renderer); - } catch { - // Both renderers failed, use default - } + tryLoadCanvas(); } return { + kind, dispose: () => renderer?.dispose(), + clearTextureAtlas: webglAddon + ? () => { + try { + webglAddon?.clearTextureAtlas(); + } catch (error) { + console.warn("[Terminal] WebGL clearTextureAtlas() failed:", error); + } + } + : undefined, }; } @@ -104,6 +124,7 @@ export function createTerminalInstance( ): { xterm: XTerm; fitAddon: FitAddon; + renderer: TerminalRenderer; cleanup: () => void; } { const { cwd, initialTheme, onFileLinkClick } = options; @@ -178,6 +199,7 @@ export function createTerminalInstance( return { xterm, fitAddon, + renderer, cleanup: () => { cleanupQuerySuppression(); renderer.dispose(); diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/types.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/types.ts index 1cc40404f89..f74da3d734b 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/types.ts +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/types.ts @@ -6,4 +6,5 @@ export interface TerminalProps { export type TerminalStreamEvent = | { type: "data"; data: string } | { type: "exit"; exitCode: number } - | { type: "disconnect"; reason: string }; + | { type: "disconnect"; reason: string } + | { type: "error"; error: string; code?: string }; From 6cc7643da55202f10b2f150098f3fdd660db5553 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Wed, 31 Dec 2025 09:37:44 +0200 Subject: [PATCH 73/98] fix(desktop): make large pastes reliable - Run PTYs in per-session subprocesses and frame IO as binary - Time-slice headless emulator output processing to keep daemon responsive - Handle PTY input backpressure (EAGAIN/EWOULDBLOCK) without dropping chunks - Improve renderer paste handling (bracketed paste + chunking) and surface errors --- LARGE_PASTE_HANG_ANALYSIS.md | 60 ++ apps/desktop/electron.vite.config.ts | 1 + .../src/lib/trpc/routers/terminal/terminal.ts | 22 +- .../src/main/lib/terminal-host/client.ts | 114 +++- .../lib/terminal-host/headless-emulator.ts | 23 +- .../src/main/lib/terminal-host/types.ts | 15 +- .../src/main/lib/terminal/daemon-manager.ts | 29 +- apps/desktop/src/main/lib/terminal/manager.ts | 11 +- .../src/main/lib/terminal/port-manager.ts | 41 +- .../src/main/lib/terminal/pty-write-queue.ts | 150 +++++ apps/desktop/src/main/lib/terminal/session.ts | 6 +- apps/desktop/src/main/lib/terminal/types.ts | 3 + apps/desktop/src/main/terminal-host/index.ts | 37 +- .../main/terminal-host/pty-subprocess-ipc.ts | 128 +++++ .../src/main/terminal-host/pty-subprocess.ts | 415 ++++++++++++++ .../desktop/src/main/terminal-host/session.ts | 516 +++++++++++++++--- .../TabsContent/Terminal/Terminal.tsx | 152 ++++-- .../TabsContent/Terminal/helpers.ts | 124 ++++- 18 files changed, 1700 insertions(+), 147 deletions(-) create mode 100644 LARGE_PASTE_HANG_ANALYSIS.md create mode 100644 apps/desktop/src/main/lib/terminal/pty-write-queue.ts create mode 100644 apps/desktop/src/main/terminal-host/pty-subprocess-ipc.ts create mode 100644 apps/desktop/src/main/terminal-host/pty-subprocess.ts diff --git a/LARGE_PASTE_HANG_ANALYSIS.md b/LARGE_PASTE_HANG_ANALYSIS.md new file mode 100644 index 00000000000..3006a8f353d --- /dev/null +++ b/LARGE_PASTE_HANG_ANALYSIS.md @@ -0,0 +1,60 @@ +# Large Paste into `vi` — Postmortem & Fix + +## Problem +Pasting large blocks of text (e.g. 3k+ lines) into `vi` inside Superset Desktop’s persistent terminal could: +- hang the terminal daemon / freeze all terminals, or +- partially paste and then silently stop (missing chunks). + +This was most visible on macOS (small kernel PTY buffer + very high output volume during `vi` repaints). + +## What Was Actually Happening +There were two distinct failure modes. + +### 1) CPU saturation on output (daemon side) +Large pastes cause `vi` to repaint aggressively, producing huge volumes of escape-sequence-heavy output. If the daemon tries to parse and apply that output to the headless xterm emulator in large, unbounded chunks, it can monopolize the event loop and trigger request timeouts / “frozen terminals”. + +### 2) Backpressure on input (PTY write side) +PTY writes must respect backpressure. When writing directly to a PTY file descriptor in non-blocking mode, the kernel can return: +- `EAGAIN` / `EWOULDBLOCK` (normal: PTY buffer full) + +If `EAGAIN` is treated as fatal (or if the queue is cleared on error), paste chunks get dropped. + +## Final Fix (Working) +The solution is end-to-end flow control + isolation. + +### Process isolation (per terminal) +Each PTY runs in its own subprocess (`apps/desktop/src/main/terminal-host/pty-subprocess.ts`). One terminal hitting backpressure can’t freeze the daemon or other terminals. + +### Binary framing (no JSON/NDJSON on hot paths) +Subprocess ↔ daemon communication uses a small length-prefixed binary framing protocol (`apps/desktop/src/main/terminal-host/pty-subprocess-ipc.ts`) to avoid JSON stringify/parse overhead on escape-heavy output. + +### Output batching + stdout backpressure +Subprocess batches PTY output (32ms cadence, 128KB max) and pauses PTY reads when `process.stdout` is backpressured. + +### Input backpressure (retry, don’t drop) +Subprocess writes to the PTY fd via async `fs.write()` (when fd is available) and treats `EAGAIN`/`EWOULDBLOCK` as expected backpressure: +- keeps the queued buffers +- retries with exponential backoff (2ms → 50ms) +- pauses upstream `stdin` when backlog exceeds a high watermark and resumes once drained + +### Daemon responsiveness (time-sliced emulator) +The daemon applies PTY output to the headless emulator in time-budgeted slices to avoid long single-tick stalls during heavy output bursts. + +### Renderer paste behavior +Renderer wraps clipboard pastes with bracketed paste sequences and chunks large payloads to reduce burstiness. + +## Debugging / Observability +Set these env vars and restart the app: +- `SUPERSET_PTY_SUBPROCESS_DEBUG=1` — subprocess batching + PTY input backpressure logs +- `SUPERSET_TERMINAL_EMULATOR_DEBUG=1` — daemon emulator budget/overrun logs + +Helpful process inspection: +```bash +ps aux | rg "terminal-host|pty-subprocess" -n +``` + +## Repro / Verification +1. Start the desktop app (`apps/desktop`). +2. Open a terminal, run `vi tmp.txt` and enter insert mode (`i`). +3. Paste ~3000+ lines. +4. Verify `vi` receives all lines (save to disk and check line count) and other terminals remain responsive. diff --git a/apps/desktop/electron.vite.config.ts b/apps/desktop/electron.vite.config.ts index 64a0e3801e7..62a3727c2b2 100644 --- a/apps/desktop/electron.vite.config.ts +++ b/apps/desktop/electron.vite.config.ts @@ -109,6 +109,7 @@ export default defineConfig({ input: { index: resolve("src/main/index.ts"), "terminal-host": resolve("src/main/terminal-host/index.ts"), + "pty-subprocess": resolve("src/main/terminal-host/pty-subprocess.ts"), }, output: { dir: resolve(devPath, "main"), diff --git a/apps/desktop/src/lib/trpc/routers/terminal/terminal.ts b/apps/desktop/src/lib/trpc/routers/terminal/terminal.ts index e14cb8c7632..3baf541f31d 100644 --- a/apps/desktop/src/lib/trpc/routers/terminal/terminal.ts +++ b/apps/desktop/src/lib/trpc/routers/terminal/terminal.ts @@ -103,7 +103,16 @@ export const createTerminalRouter = () => { }), ) .mutation(async ({ input }) => { - terminalManager.write(input); + try { + terminalManager.write(input); + } catch (error) { + const message = + error instanceof Error ? error.message : "Write failed"; + terminalManager.emit(`error:${input.paneId}`, { + error: message, + code: "WRITE_FAILED", + }); + } }), resize: publicProcedure @@ -258,6 +267,7 @@ export const createTerminalRouter = () => { | { type: "data"; data: string } | { type: "exit"; exitCode: number; signal?: number } | { type: "disconnect"; reason: string } + | { type: "error"; error: string; code?: string } >((emit) => { const onData = (data: string) => { emit.next({ type: "data", data }); @@ -272,15 +282,25 @@ export const createTerminalRouter = () => { emit.next({ type: "disconnect", reason }); }; + const onError = (payload: { error: string; code?: string }) => { + emit.next({ + type: "error", + error: payload.error, + code: payload.code, + }); + }; + terminalManager.on(`data:${paneId}`, onData); terminalManager.on(`exit:${paneId}`, onExit); terminalManager.on(`disconnect:${paneId}`, onDisconnect); + terminalManager.on(`error:${paneId}`, onError); // Cleanup on unsubscribe return () => { terminalManager.off(`data:${paneId}`, onData); terminalManager.off(`exit:${paneId}`, onExit); terminalManager.off(`disconnect:${paneId}`, onDisconnect); + terminalManager.off(`error:${paneId}`, onError); }; }); }), diff --git a/apps/desktop/src/main/lib/terminal-host/client.ts b/apps/desktop/src/main/lib/terminal-host/client.ts index 763cf43bcb1..25e9491d9f1 100644 --- a/apps/desktop/src/main/lib/terminal-host/client.ts +++ b/apps/desktop/src/main/lib/terminal-host/client.ts @@ -40,6 +40,7 @@ import { type ResizeRequest, type ShutdownRequest, type TerminalDataEvent, + type TerminalErrorEvent, type TerminalExitEvent, type WriteRequest, } from "./types"; @@ -78,16 +79,22 @@ const SPAWN_LOCK_TIMEOUT_MS = 10000; // Max time to hold spawn lock // ============================================================================= class NdjsonParser { - private buffer = ""; + // Use array buffering to avoid O(n²) string concatenation on high-volume streams + private chunks: string[] = []; + private remainder = ""; parse(chunk: string): Array { - this.buffer += chunk; const messages: Array = []; - let newlineIndex = this.buffer.indexOf("\n"); + // Prepend any remainder from previous parse + const data = this.remainder + chunk; + this.remainder = ""; + + let startIndex = 0; + let newlineIndex = data.indexOf("\n"); + while (newlineIndex !== -1) { - const line = this.buffer.slice(0, newlineIndex); - this.buffer = this.buffer.slice(newlineIndex + 1); + const line = data.slice(startIndex, newlineIndex); if (line.trim()) { try { @@ -97,7 +104,13 @@ class NdjsonParser { } } - newlineIndex = this.buffer.indexOf("\n"); + startIndex = newlineIndex + 1; + newlineIndex = data.indexOf("\n", startIndex); + } + + // Save any remaining data after the last newline + if (startIndex < data.length) { + this.remainder = data.slice(startIndex); } return messages; @@ -121,6 +134,8 @@ interface PendingRequest { export interface TerminalHostClientEvents { data: (sessionId: string, data: string) => void; exit: (sessionId: string, exitCode: number, signal?: number) => void; + /** Terminal-specific error (e.g., write queue full - paste dropped) */ + terminalError: (sessionId: string, error: string, code?: string) => void; connected: () => void; disconnected: () => void; error: (error: Error) => void; @@ -138,6 +153,9 @@ export class TerminalHostClient extends EventEmitter { private authenticated = false; private connectionState = ConnectionState.DISCONNECTED; private disposed = false; + private notifyQueue: string[] = []; + private notifyQueueBytes = 0; + private notifyDrainArmed = false; // =========================================================================== // Connection Management @@ -282,6 +300,10 @@ export class TerminalHostClient extends EventEmitter { } }); + this.socket.on("drain", () => { + this.flushNotifyQueue(); + }); + this.socket.on("close", () => { this.handleDisconnect(); }); @@ -313,7 +335,10 @@ export class TerminalHostClient extends EventEmitter { } else if (message.type === "event") { // Event from daemon const event = message as IpcEvent; - const payload = event.payload as TerminalDataEvent | TerminalExitEvent; + const payload = event.payload as + | TerminalDataEvent + | TerminalExitEvent + | TerminalErrorEvent; if (payload.type === "data") { this.emit("data", event.sessionId, (payload as TerminalDataEvent).data); @@ -325,6 +350,16 @@ export class TerminalHostClient extends EventEmitter { exitPayload.exitCode, exitPayload.signal, ); + } else if (payload.type === "error") { + const errorPayload = payload as TerminalErrorEvent; + // Emit terminal-specific error so callers can handle it + // This is critical for "Write queue full" - paste was silently dropped before! + this.emit( + "terminalError", + event.sessionId, + errorPayload.error, + errorPayload.code, + ); } } } @@ -336,6 +371,9 @@ export class TerminalHostClient extends EventEmitter { this.socket = null; this.authenticated = false; this.connectionState = ConnectionState.DISCONNECTED; + this.notifyQueue = []; + this.notifyQueueBytes = 0; + this.notifyDrainArmed = false; // Reject all pending requests for (const [id, pending] of this.pendingRequests.entries()) { @@ -599,6 +637,53 @@ export class TerminalHostClient extends EventEmitter { }); } + /** + * Send a notification (no pending request / no timeout). + * + * Used for high-frequency messages like terminal input, where request/response + * overhead can cause timeouts under load and drop data. The daemon may still + * send a response for compatibility, but this client will ignore it. + */ + private sendNotification(type: string, payload: unknown): void { + if (!this.socket) return; + + const id = `notify_${++this.requestCounter}`; + const message = `${JSON.stringify({ id, type, payload })}\n`; + + // If we're already backpressured, just queue. + if (this.notifyDrainArmed || this.notifyQueue.length > 0) { + this.notifyQueue.push(message); + this.notifyQueueBytes += Buffer.byteLength(message, "utf8"); + return; + } + + const canWrite = this.socket.write(message); + if (!canWrite) { + // Message is queued internally by the socket; arm drain to flush any + // subsequent notifications we enqueue. + this.notifyDrainArmed = true; + } + } + + private flushNotifyQueue(): void { + if (!this.socket) return; + if (!this.notifyDrainArmed && this.notifyQueue.length === 0) return; + + this.notifyDrainArmed = false; + + while (this.notifyQueue.length > 0) { + const message = this.notifyQueue.shift(); + if (!message) break; + this.notifyQueueBytes -= Buffer.byteLength(message, "utf8"); + + const canWrite = this.socket.write(message); + if (!canWrite) { + this.notifyDrainArmed = true; + return; + } + } + } + // =========================================================================== // Public API // =========================================================================== @@ -624,6 +709,21 @@ export class TerminalHostClient extends EventEmitter { return (await this.sendRequest("write", request)) as EmptyResponse; } + /** + * Write data without waiting for a response (best-effort, backpressured). + * Prevents large pastes from timing out and dropping chunks when the daemon + * is busy processing output. + */ + writeNoAck(request: WriteRequest): void { + void this.ensureConnected() + .then(() => { + this.sendNotification("write", request); + }) + .catch((error) => { + this.emit("error", error instanceof Error ? error : new Error(String(error))); + }); + } + /** * Resize a terminal session */ diff --git a/apps/desktop/src/main/lib/terminal-host/headless-emulator.ts b/apps/desktop/src/main/lib/terminal-host/headless-emulator.ts index ad30a0dd7b0..15460908784 100644 --- a/apps/desktop/src/main/lib/terminal-host/headless-emulator.ts +++ b/apps/desktop/src/main/lib/terminal-host/headless-emulator.ts @@ -23,6 +23,9 @@ import { const ESC = "\x1b"; const BEL = "\x07"; +const DEBUG_EMULATOR_TIMING = + process.env.SUPERSET_TERMINAL_EMULATOR_DEBUG === "1"; + /** * DECSET/DECRST mode numbers we track */ @@ -118,11 +121,27 @@ export class HeadlessEmulator { write(data: string): void { if (this.disposed) return; - // Parse escape sequences with chunk-safe buffering + if (!DEBUG_EMULATOR_TIMING) { + // Parse escape sequences with chunk-safe buffering + this.parseEscapeSequences(data); + // Write to headless terminal (buffered/async) + this.terminal.write(data); + return; + } + + const parseStart = performance.now(); this.parseEscapeSequences(data); + const parseTime = performance.now() - parseStart; - // Write to headless terminal (buffered/async) + const terminalStart = performance.now(); this.terminal.write(data); + const terminalTime = performance.now() - terminalStart; + + if (parseTime > 2 || terminalTime > 2) { + console.warn( + `[HeadlessEmulator] write(${data.length}b): parse=${parseTime.toFixed(1)}ms, terminal=${terminalTime.toFixed(1)}ms`, + ); + } } /** diff --git a/apps/desktop/src/main/lib/terminal-host/types.ts b/apps/desktop/src/main/lib/terminal-host/types.ts index 19734616cad..f63303b801b 100644 --- a/apps/desktop/src/main/lib/terminal-host/types.ts +++ b/apps/desktop/src/main/lib/terminal-host/types.ts @@ -284,7 +284,20 @@ export interface TerminalExitEvent { signal?: number; } -export type TerminalEvent = TerminalDataEvent | TerminalExitEvent; +/** + * Terminal error event (e.g., write queue full, subprocess error) + */ +export interface TerminalErrorEvent { + type: "error"; + error: string; + /** Error code for programmatic handling */ + code?: "WRITE_QUEUE_FULL" | "SUBPROCESS_ERROR" | "WRITE_FAILED" | "UNKNOWN"; +} + +export type TerminalEvent = + | TerminalDataEvent + | TerminalExitEvent + | TerminalErrorEvent; // ============================================================================= // Request/Response Type Map diff --git a/apps/desktop/src/main/lib/terminal/daemon-manager.ts b/apps/desktop/src/main/lib/terminal/daemon-manager.ts index 43fd0df4a5f..4fbaea5b8e0 100644 --- a/apps/desktop/src/main/lib/terminal/daemon-manager.ts +++ b/apps/desktop/src/main/lib/terminal/daemon-manager.ts @@ -129,6 +129,18 @@ export class DaemonTerminalManager extends EventEmitter { } } }); + + // Terminal-specific errors (e.g., subprocess backpressure limits) + this.client.on( + "terminalError", + (sessionId: string, error: string, code?: string) => { + const paneId = sessionId; + console.error( + `[DaemonTerminalManager] Terminal error for ${paneId}: ${code ?? "UNKNOWN"}: ${error}`, + ); + this.emit(`error:${paneId}`, { error, code }); + }, + ); } // =========================================================================== @@ -249,13 +261,9 @@ export class DaemonTerminalManager extends EventEmitter { throw new Error(`Terminal session ${paneId} not found or not alive`); } - // Fire and forget - daemon will handle the write - this.client.write({ sessionId: paneId, data }).catch((error) => { - console.error( - `[DaemonTerminalManager] Write failed for ${paneId}:`, - error, - ); - }); + // Fire and forget - daemon will handle the write. + // Use the no-ack fast path to avoid per-chunk request timeouts under load. + this.client.writeNoAck({ sessionId: paneId, data }); session.lastActive = Date.now(); } @@ -451,12 +459,7 @@ export class DaemonTerminalManager extends EventEmitter { refreshPromptsForWorkspace(workspaceId: string): void { for (const [paneId, session] of this.sessions.entries()) { if (session.workspaceId === workspaceId && session.isAlive) { - this.client.write({ sessionId: paneId, data: "\n" }).catch((error) => { - console.warn( - `[DaemonTerminalManager] Failed to refresh prompt for pane ${paneId}:`, - error, - ); - }); + this.client.writeNoAck({ sessionId: paneId, data: "\n" }); } } } diff --git a/apps/desktop/src/main/lib/terminal/manager.ts b/apps/desktop/src/main/lib/terminal/manager.ts index 84522cde550..dc1aeb34563 100644 --- a/apps/desktop/src/main/lib/terminal/manager.ts +++ b/apps/desktop/src/main/lib/terminal/manager.ts @@ -110,6 +110,7 @@ export class TerminalManager extends EventEmitter { session.pty.onExit(async ({ exitCode, signal }) => { session.isAlive = false; + session.writeQueue.dispose(); flushSession(session); // Check if shell crashed quickly - try fallback @@ -163,7 +164,9 @@ export class TerminalManager extends EventEmitter { throw new Error(`Terminal session ${paneId} not found or not alive`); } - session.pty.write(data); + if (!session.writeQueue.write(data)) { + throw new Error(`Terminal ${paneId} write queue full`); + } session.lastActive = Date.now(); } @@ -314,12 +317,14 @@ export class TerminalManager extends EventEmitter { ): Promise { if (!session.isAlive) { session.deleteHistoryOnExit = true; + session.writeQueue.dispose(); await closeSessionHistory(session); this.sessions.delete(paneId); return true; } session.deleteHistoryOnExit = true; + session.writeQueue.dispose(); return new Promise((resolve) => { let resolved = false; @@ -392,7 +397,7 @@ export class TerminalManager extends EventEmitter { for (const [paneId, session] of this.sessions.entries()) { if (session.workspaceId === workspaceId && session.isAlive) { try { - session.pty.write("\n"); + session.writeQueue.write("\n"); } catch (error) { console.warn( `[TerminalManager] Failed to refresh prompt for pane ${paneId}:`, @@ -436,8 +441,10 @@ export class TerminalManager extends EventEmitter { }); exitPromises.push(exitPromise); + session.writeQueue.dispose(); session.pty.kill(); } else { + session.writeQueue.dispose(); await closeSessionHistory(session); } } diff --git a/apps/desktop/src/main/lib/terminal/port-manager.ts b/apps/desktop/src/main/lib/terminal/port-manager.ts index b848024fc85..5d8995ffa1d 100644 --- a/apps/desktop/src/main/lib/terminal/port-manager.ts +++ b/apps/desktop/src/main/lib/terminal/port-manager.ts @@ -328,13 +328,25 @@ class PortManager extends EventEmitter { const buffered = this.lineBuffers.get(paneId) || ""; const combined = buffered + data; - // Split by newlines - const parts = combined.split(/\r?\n/); + // Fast path: avoid splitting/regex on obviously irrelevant output (e.g., full-screen TUIs). + // Still maintain the incomplete-line buffer so patterns spanning chunks can be detected later. + const lastNewlineIndex = Math.max( + combined.lastIndexOf("\n"), + combined.lastIndexOf("\r"), + ); + + // No newline yet → only an incomplete line to buffer. + if (lastNewlineIndex === -1) { + if (combined.length <= MAX_LINE_BUFFER) { + this.lineBuffers.set(paneId, combined); + } else { + this.lineBuffers.delete(paneId); + } + return; + } - // If data doesn't end with a newline, the last part is incomplete - buffer it - const endsWithNewline = /[\r\n]$/.test(data); - const completeLines = endsWithNewline ? parts : parts.slice(0, -1); - const incompleteLine = endsWithNewline ? "" : (parts.at(-1) ?? ""); + const completePart = combined.slice(0, lastNewlineIndex); + const incompleteLine = combined.slice(lastNewlineIndex + 1); // Update buffer (with size limit to prevent memory issues) if (incompleteLine && incompleteLine.length <= MAX_LINE_BUFFER) { @@ -343,13 +355,26 @@ class PortManager extends EventEmitter { this.lineBuffers.delete(paneId); } - // Process complete lines + // Heuristic: only do full line processing if the chunk *looks* like it could contain a port. + // Sample both the head and tail to handle long logs without scanning huge strings. + const sample = + completePart.length > 4096 + ? `${completePart.slice(0, 2048)}${completePart.slice(-2048)}` + : completePart; + const looksRelevant = + /(?:localhost|127\.0\.0\.1|0\.0\.0\.0|https?:\/\/|listening|started|ready|running|\bon port\b)/i.test( + sample, + ); + if (!looksRelevant) return; + + // Split by newlines (only on the completed portion) + const completeLines = completePart.split(/\r?\n/); + for (const line of completeLines) { if (!line.trim()) continue; const port = extractPort(line); if (port !== null) { - // Schedule verification - port will only be added if it's actually listening this.schedulePortVerification(port, paneId, workspaceId, line); } } diff --git a/apps/desktop/src/main/lib/terminal/pty-write-queue.ts b/apps/desktop/src/main/lib/terminal/pty-write-queue.ts new file mode 100644 index 00000000000..f0e35c90a9b --- /dev/null +++ b/apps/desktop/src/main/lib/terminal/pty-write-queue.ts @@ -0,0 +1,150 @@ +import type { IPty } from "node-pty"; + +/** + * A write queue for PTY that prevents blocking the event loop. + * + * Problem: node-pty's write() is synchronous and blocks when the kernel's + * PTY buffer fills up (~4KB on macOS). Large pastes (e.g., 16KB+) can freeze + * the entire daemon, causing all requests to timeout. + * + * Solution: Queue writes and process them in chunks, yielding to the event + * loop between chunks. This keeps the daemon responsive while still delivering + * all data to the PTY. + * + * Features: + * - Chunked writes to prevent blocking + * - Memory-bounded queue to prevent OOM + * - Backpressure signaling when queue is full + * - Graceful handling of PTY closure + */ +export class PtyWriteQueue { + private queue: string[] = []; + private queuedBytes = 0; + private flushing = false; + private disposed = false; + + /** + * Size of each write chunk. Smaller = more responsive but slower throughput. + * 256 bytes keeps individual blocks short (~1-5ms typically). + */ + private readonly CHUNK_SIZE = 256; + + /** + * Delay between chunks in ms. Gives event loop time to process other work. + */ + private readonly CHUNK_DELAY_MS = 1; + + /** + * Maximum bytes allowed in queue. Prevents OOM if PTY stops consuming. + * 1MB is generous - a typical large paste is ~50KB. + */ + private readonly MAX_QUEUE_BYTES = 1_000_000; + + constructor( + private pty: IPty, + private onDrain?: () => void, + ) {} + + /** + * Queue data to be written to the PTY. + * @returns true if queued, false if queue is full (backpressure) + */ + write(data: string): boolean { + if (this.disposed) { + return false; + } + + if (this.queuedBytes + data.length > this.MAX_QUEUE_BYTES) { + console.warn( + `[PtyWriteQueue] Queue full (${this.queuedBytes} bytes), rejecting write of ${data.length} bytes`, + ); + return false; + } + + this.queue.push(data); + this.queuedBytes += data.length; + this.scheduleFlush(); + return true; + } + + /** + * Schedule the flush loop if not already running. + */ + private scheduleFlush(): void { + if (this.flushing || this.disposed) return; + this.flushing = true; + setTimeout(() => this.flush(), 0); + } + + /** + * Process one chunk from the queue and schedule the next. + */ + private flush(): void { + if (this.disposed) { + this.flushing = false; + return; + } + + if (this.queue.length === 0) { + this.flushing = false; + this.onDrain?.(); + return; + } + + // Take a chunk from front of queue + let chunk = this.queue[0]; + if (chunk.length > this.CHUNK_SIZE) { + // Split: take CHUNK_SIZE, leave rest in queue + this.queue[0] = chunk.slice(this.CHUNK_SIZE); + chunk = chunk.slice(0, this.CHUNK_SIZE); + } else { + // Take entire item + this.queue.shift(); + } + + this.queuedBytes -= chunk.length; + + try { + this.pty.write(chunk); + } catch (error) { + // PTY might be closed - clear queue and stop + console.warn("[PtyWriteQueue] Write failed, clearing queue:", error); + this.clear(); + this.flushing = false; + return; + } + + // Yield to event loop with a small delay, allowing other work to run + setTimeout(() => this.flush(), this.CHUNK_DELAY_MS); + } + + /** + * Number of bytes currently queued. + */ + get pending(): number { + return this.queuedBytes; + } + + /** + * Whether there's data waiting to be written. + */ + get hasPending(): boolean { + return this.queuedBytes > 0; + } + + /** + * Clear all pending writes. + */ + clear(): void { + this.queue = []; + this.queuedBytes = 0; + } + + /** + * Stop processing and clear queue. + */ + dispose(): void { + this.disposed = true; + this.clear(); + } +} diff --git a/apps/desktop/src/main/lib/terminal/session.ts b/apps/desktop/src/main/lib/terminal/session.ts index 08b5c559f00..e8ba5d04a1d 100644 --- a/apps/desktop/src/main/lib/terminal/session.ts +++ b/apps/desktop/src/main/lib/terminal/session.ts @@ -9,6 +9,7 @@ import { import { HistoryReader, HistoryWriter } from "../terminal-history"; import { buildTerminalEnv, FALLBACK_SHELL, getDefaultShell } from "./env"; import { portManager } from "./port-manager"; +import { PtyWriteQueue } from "./pty-write-queue"; import type { InternalCreateSessionParams, TerminalSession } from "./types"; const DEFAULT_COLS = 80; @@ -122,6 +123,8 @@ export async function createSession( onData(paneId, batchedData); }); + const writeQueue = new PtyWriteQueue(ptyProcess); + return { pty: ptyProcess, paneId, @@ -135,6 +138,7 @@ export async function createSession( wasRecovered, historyWriter, dataBatcher, + writeQueue, shell, startTime: Date.now(), usedFallback: useFallbackShell, @@ -186,7 +190,7 @@ export function setupDataHandler( } if (session.isAlive) { - session.pty.write(initialCommandString); + session.writeQueue.write(initialCommandString); } })(); } diff --git a/apps/desktop/src/main/lib/terminal/types.ts b/apps/desktop/src/main/lib/terminal/types.ts index 64ee71ba1ee..b7d2b4eff29 100644 --- a/apps/desktop/src/main/lib/terminal/types.ts +++ b/apps/desktop/src/main/lib/terminal/types.ts @@ -1,6 +1,7 @@ import type * as pty from "node-pty"; import type { DataBatcher } from "../data-batcher"; import type { HistoryWriter } from "../terminal-history"; +import type { PtyWriteQueue } from "./pty-write-queue"; export interface TerminalSession { pty: pty.IPty; @@ -16,6 +17,8 @@ export interface TerminalSession { wasRecovered: boolean; historyWriter?: HistoryWriter; dataBatcher: DataBatcher; + /** Queued writer to prevent blocking on large writes */ + writeQueue: PtyWriteQueue; shell: string; startTime: number; usedFallback: boolean; diff --git a/apps/desktop/src/main/terminal-host/index.ts b/apps/desktop/src/main/terminal-host/index.ts index 255c8c3fbaf..9353f240011 100644 --- a/apps/desktop/src/main/terminal-host/index.ts +++ b/apps/desktop/src/main/terminal-host/index.ts @@ -30,6 +30,7 @@ import { type DetachRequest, type HelloRequest, type HelloResponse, + type IpcEvent, type IpcErrorResponse, type IpcRequest, type IpcSuccessResponse, @@ -38,6 +39,7 @@ import { PROTOCOL_VERSION, type ResizeRequest, type ShutdownRequest, + type TerminalErrorEvent, type WriteRequest, } from "../lib/terminal-host/types"; import { TerminalHost } from "./terminal-host"; @@ -244,8 +246,39 @@ const handlers: Record = { } const request = payload as WriteRequest; - const response = terminalHost.write(request); - sendSuccess(socket, id, response); + + const isNotify = id.startsWith("notify_"); + + try { + const response = terminalHost.write(request); + // High-frequency write notifications don't need responses; suppress to avoid + // saturating the socket and dropping input under load. + if (!isNotify) { + sendSuccess(socket, id, response); + } + } catch (error) { + const message = error instanceof Error ? error.message : "Write failed"; + + if (isNotify) { + // Emit a session-scoped error event so the main process can surface it. + // (No response is sent for notify writes.) + const event: IpcEvent = { + type: "event", + event: "error", + sessionId: request.sessionId, + payload: { + type: "error", + error: message, + code: "WRITE_FAILED", + } satisfies TerminalErrorEvent, + }; + socket.write(`${JSON.stringify(event)}\n`); + log("warn", `Write failed for ${request.sessionId}`, { error: message }); + return; + } + + sendError(socket, id, "WRITE_FAILED", message); + } }, resize: (socket, id, payload, clientState) => { diff --git a/apps/desktop/src/main/terminal-host/pty-subprocess-ipc.ts b/apps/desktop/src/main/terminal-host/pty-subprocess-ipc.ts new file mode 100644 index 00000000000..28d35c156a1 --- /dev/null +++ b/apps/desktop/src/main/terminal-host/pty-subprocess-ipc.ts @@ -0,0 +1,128 @@ +export enum PtySubprocessIpcType { + // Daemon -> subprocess commands + Spawn = 1, + Write = 2, + Resize = 3, + Kill = 4, + Dispose = 5, + + // Subprocess -> daemon events + Ready = 101, + Spawned = 102, + Data = 103, + Exit = 104, + Error = 105, +} + +export interface PtySubprocessFrame { + type: PtySubprocessIpcType; + payload: Buffer; +} + +const HEADER_BYTES = 5; +const EMPTY_PAYLOAD = Buffer.alloc(0); + +// Hard cap to avoid OOM if the stream is corrupted. +// PTY data is untrusted input in practice (terminal apps can emit arbitrarily). +const MAX_FRAME_BYTES = 64 * 1024 * 1024; // 64MB + +export function createFrameHeader( + type: PtySubprocessIpcType, + payloadLength: number, +): Buffer { + const header = Buffer.allocUnsafe(HEADER_BYTES); + header.writeUInt8(type, 0); + header.writeUInt32LE(payloadLength, 1); + return header; +} + +export function writeFrame( + writable: NodeJS.WritableStream, + type: PtySubprocessIpcType, + payload?: Buffer, +): boolean { + const payloadBuffer = payload ?? EMPTY_PAYLOAD; + const header = createFrameHeader(type, payloadBuffer.length); + + let canWrite = writable.write(header); + + // Always write payload even if the header write returns false. + // Backpressure is represented by the return value + 'drain' events. + if (payloadBuffer.length > 0) { + canWrite = writable.write(payloadBuffer) && canWrite; + } + + return canWrite; +} + +export class PtySubprocessFrameDecoder { + private header = Buffer.allocUnsafe(HEADER_BYTES); + private headerOffset = 0; + private frameType: PtySubprocessIpcType | null = null; + private payload: Buffer | null = null; + private payloadOffset = 0; + + push(chunk: Buffer): PtySubprocessFrame[] { + const frames: PtySubprocessFrame[] = []; + + let offset = 0; + while (offset < chunk.length) { + if (this.payload === null) { + const headerNeeded = HEADER_BYTES - this.headerOffset; + const available = chunk.length - offset; + const toCopy = Math.min(headerNeeded, available); + + chunk.copy(this.header, this.headerOffset, offset, offset + toCopy); + this.headerOffset += toCopy; + offset += toCopy; + + if (this.headerOffset < HEADER_BYTES) { + continue; + } + + const type = this.header.readUInt8(0) as PtySubprocessIpcType; + const payloadLength = this.header.readUInt32LE(1); + + if (payloadLength > MAX_FRAME_BYTES) { + throw new Error( + `PtySubprocess IPC frame too large: ${payloadLength} bytes`, + ); + } + + this.frameType = type; + this.payload = payloadLength > 0 ? Buffer.allocUnsafe(payloadLength) : null; + this.payloadOffset = 0; + this.headerOffset = 0; + + if (payloadLength === 0) { + frames.push({ type, payload: EMPTY_PAYLOAD }); + this.frameType = null; + } + } else { + const payloadNeeded = this.payload.length - this.payloadOffset; + const available = chunk.length - offset; + const toCopy = Math.min(payloadNeeded, available); + + chunk.copy(this.payload, this.payloadOffset, offset, offset + toCopy); + this.payloadOffset += toCopy; + offset += toCopy; + + if (this.payloadOffset < this.payload.length) { + continue; + } + + const type = this.frameType ?? PtySubprocessIpcType.Error; + const payload = this.payload; + + this.frameType = null; + this.payload = null; + this.payloadOffset = 0; + + frames.push({ type, payload }); + } + } + + return frames; + } +} + diff --git a/apps/desktop/src/main/terminal-host/pty-subprocess.ts b/apps/desktop/src/main/terminal-host/pty-subprocess.ts new file mode 100644 index 00000000000..01cf0472685 --- /dev/null +++ b/apps/desktop/src/main/terminal-host/pty-subprocess.ts @@ -0,0 +1,415 @@ +/** + * PTY Subprocess + * + * This runs as a completely separate process, owning a single PTY. + * Process isolation guarantees that a blocked PTY won't stall the daemon. + * + * Communication via stdin/stdout using a small binary framing protocol + * to avoid JSON escaping overhead on escape-sequence-heavy PTY output. + */ + +import * as pty from "node-pty"; +import type { IPty } from "node-pty"; +import { write as fsWrite } from "node:fs"; +import { + PtySubprocessFrameDecoder, + PtySubprocessIpcType, + writeFrame, +} from "./pty-subprocess-ipc"; + +// ============================================================================= +// Types (kept local to avoid bundling/import surprises) +// ============================================================================= + +interface SpawnPayload { + shell: string; + args: string[]; + cwd: string; + cols: number; + rows: number; + env: Record; +} + +// ============================================================================= +// State +// ============================================================================= + +let ptyProcess: IPty | null = null; +let ptyFd: number | null = null; + +// Write queue for stdin (uses async fs.write on the PTY fd to avoid blocking the event loop) +const writeQueue: Buffer[] = []; +let queuedBytes = 0; +let flushing = false; +let writeBackoffMs = 0; +const MIN_WRITE_BACKOFF_MS = 2; +const MAX_WRITE_BACKOFF_MS = 50; + +let stdinPaused = false; +const INPUT_QUEUE_HIGH_WATERMARK_BYTES = 8 * 1024 * 1024; // 8MB +const INPUT_QUEUE_LOW_WATERMARK_BYTES = 4 * 1024 * 1024; // 4MB +// Hard cap to avoid runaway memory usage if upstream misbehaves. +const INPUT_QUEUE_HARD_LIMIT_BYTES = 64 * 1024 * 1024; // 64MB + +// Output batching - collect PTY output and send periodically. +// CRITICAL: Use array buffering to avoid O(n²) string concatenation. +let outputChunks: string[] = []; +let outputBytesQueued = 0; +let outputFlushScheduled = false; +const OUTPUT_FLUSH_INTERVAL_MS = 32; // ~30 fps max +const MAX_OUTPUT_BATCH_SIZE_BYTES = 128 * 1024; // 128KB max per flush + +// Backpressure - track if stdout is draining +let stdoutDraining = true; +let ptyPaused = false; + +const DEBUG_OUTPUT_BATCHING = + process.env.SUPERSET_PTY_SUBPROCESS_DEBUG === "1"; + +// ============================================================================= +// Helpers +// ============================================================================= + +function send(type: PtySubprocessIpcType, payload?: Buffer): void { + stdoutDraining = writeFrame(process.stdout, type, payload); + + // If stdout buffer is full, pause PTY reads (reduces runaway buffering/CPU). + if (!stdoutDraining && ptyProcess && !ptyPaused) { + ptyPaused = true; + ptyProcess.pause(); + } +} + +process.stdout.on("drain", () => { + stdoutDraining = true; + if (ptyPaused && ptyProcess) { + ptyPaused = false; + ptyProcess.resume(); + } +}); + +function sendError(message: string): void { + send(PtySubprocessIpcType.Error, Buffer.from(message, "utf8")); +} + +/** + * Queue PTY output for batched sending. + * Flushes immediately if batch exceeds MAX_OUTPUT_BATCH_SIZE_BYTES. + */ +function queueOutput(data: string): void { + outputChunks.push(data); + outputBytesQueued += Buffer.byteLength(data, "utf8"); + + if (outputBytesQueued >= MAX_OUTPUT_BATCH_SIZE_BYTES) { + outputFlushScheduled = false; + flushOutput(); + return; + } + + if (!outputFlushScheduled) { + outputFlushScheduled = true; + setTimeout(flushOutput, OUTPUT_FLUSH_INTERVAL_MS); + } +} + +function flushOutput(): void { + outputFlushScheduled = false; + if (outputChunks.length === 0) return; + + const data = outputChunks.join(""); + const chunkCount = outputChunks.length; + outputChunks = []; + outputBytesQueued = 0; + + const payload = Buffer.from(data, "utf8"); + + if (DEBUG_OUTPUT_BATCHING) { + console.error( + `[pty-subprocess] Flushing ${payload.length} bytes (${chunkCount} chunks batched)`, + ); + } + + send(PtySubprocessIpcType.Data, payload); +} + +function maybePauseStdin(): void { + if (stdinPaused) return; + if (queuedBytes < INPUT_QUEUE_HIGH_WATERMARK_BYTES) return; + + stdinPaused = true; + process.stdin.pause(); +} + +function maybeResumeStdin(): void { + if (!stdinPaused) return; + if (queuedBytes > INPUT_QUEUE_LOW_WATERMARK_BYTES) return; + + stdinPaused = false; + process.stdin.resume(); +} + +function queueWriteBuffer(buf: Buffer): void { + if (queuedBytes + buf.length > INPUT_QUEUE_HARD_LIMIT_BYTES) { + // This should never happen for normal pastes; avoid OOM if it does. + sendError("Input backlog exceeded hard limit"); + return; + } + + writeQueue.push(buf); + queuedBytes += buf.length; + maybePauseStdin(); + scheduleFlush(); +} + +function scheduleFlush(): void { + if (flushing) return; + flushing = true; + setImmediate(flush); +} + +function flush(): void { + if (!ptyProcess || writeQueue.length === 0) { + flushing = false; + return; + } + + // If we can access the PTY fd, use async fs.write to avoid blocking the JS event loop. + if (typeof ptyFd === "number" && ptyFd > 0) { + const buf = writeQueue[0]; + + fsWrite(ptyFd, buf, 0, buf.length, null, (err, bytesWritten) => { + if (err) { + const code = (err as NodeJS.ErrnoException).code; + // PTY fds are often non-blocking. If the kernel buffer is full, + // writes can fail with EAGAIN/EWOULDBLOCK. This is normal backpressure; + // retry later instead of dropping the paste. + if (code === "EAGAIN" || code === "EWOULDBLOCK") { + writeBackoffMs = + writeBackoffMs === 0 + ? MIN_WRITE_BACKOFF_MS + : Math.min(writeBackoffMs * 2, MAX_WRITE_BACKOFF_MS); + if (DEBUG_OUTPUT_BATCHING && writeBackoffMs === MIN_WRITE_BACKOFF_MS) { + console.error("[pty-subprocess] PTY input backpressured (EAGAIN)"); + } + setTimeout(flush, writeBackoffMs); + return; + } + + sendError( + `Write failed: ${err instanceof Error ? err.message : String(err)}`, + ); + writeQueue.length = 0; + queuedBytes = 0; + flushing = false; + return; + } + + const wrote = Math.max(0, bytesWritten ?? 0); + writeBackoffMs = 0; + queuedBytes -= wrote; + + if (wrote >= buf.length) { + writeQueue.shift(); + } else { + writeQueue[0] = buf.subarray(wrote); + } + + maybeResumeStdin(); + + if (writeQueue.length > 0) { + setImmediate(flush); + } else { + flushing = false; + } + }); + return; + } + + // Fallback: node-pty's write() is synchronous and can block. + // This path should rarely be used on macOS, but keep it for safety. + let chunk = writeQueue.shift(); + if (!chunk) { + flushing = false; + return; + } + + queuedBytes -= chunk.length; + maybeResumeStdin(); + + try { + ptyProcess.write(chunk.toString("utf8")); + } catch (error) { + sendError( + `Write failed: ${error instanceof Error ? error.message : String(error)}`, + ); + writeQueue.length = 0; + queuedBytes = 0; + flushing = false; + return; + } + + if (writeQueue.length > 0) { + setImmediate(flush); + return; + } + + flushing = false; +} + +// ============================================================================= +// Message Handlers +// ============================================================================= + +function handleSpawn(payload: Buffer): void { + if (ptyProcess) { + sendError("PTY already spawned"); + return; + } + + let msg: SpawnPayload; + try { + msg = JSON.parse(payload.toString("utf8")) as SpawnPayload; + } catch (error) { + sendError( + `Spawn payload parse failed: ${error instanceof Error ? error.message : String(error)}`, + ); + return; + } + + try { + ptyProcess = pty.spawn(msg.shell, msg.args, { + name: "xterm-256color", + cols: msg.cols, + rows: msg.rows, + cwd: msg.cwd, + env: msg.env, + }); + + ptyFd = (ptyProcess as unknown as { fd?: number }).fd ?? null; + if (DEBUG_OUTPUT_BATCHING) { + console.error( + `[pty-subprocess] PTY fd ${ptyFd ?? "unknown"} (${typeof ptyFd === "number" ? "async fs.write enabled" : "falling back to pty.write"})`, + ); + } + + ptyProcess.onData((data) => { + queueOutput(data); + }); + + ptyProcess.onExit(({ exitCode, signal }) => { + flushOutput(); + + const exitPayload = Buffer.allocUnsafe(8); + exitPayload.writeInt32LE(exitCode ?? 0, 0); + exitPayload.writeInt32LE(signal ?? 0, 4); + send(PtySubprocessIpcType.Exit, exitPayload); + + ptyProcess = null; + ptyFd = null; + setTimeout(() => process.exit(0), 100); + }); + + const pidPayload = Buffer.allocUnsafe(4); + pidPayload.writeUInt32LE(ptyProcess.pid ?? 0, 0); + send(PtySubprocessIpcType.Spawned, pidPayload); + } catch (error) { + sendError( + `Spawn failed: ${error instanceof Error ? error.message : String(error)}`, + ); + } +} + +function handleWrite(payload: Buffer): void { + if (!ptyProcess) { + sendError("PTY not spawned"); + return; + } + + queueWriteBuffer(payload); +} + +function handleResize(payload: Buffer): void { + if (!ptyProcess) return; + if (payload.length < 8) return; + try { + const cols = payload.readUInt32LE(0); + const rows = payload.readUInt32LE(4); + ptyProcess.resize(cols, rows); + } catch { + // Ignore resize errors + } +} + +function handleKill(payload: Buffer): void { + if (!ptyProcess) return; + try { + const signal = payload.length > 0 ? payload.toString("utf8") : undefined; + ptyProcess.kill(signal); + } catch { + // Ignore + } +} + +function handleDispose(): void { + flushOutput(); + + writeQueue.length = 0; + queuedBytes = 0; + flushing = false; + outputChunks = []; + outputBytesQueued = 0; + outputFlushScheduled = false; + ptyFd = null; + + if (ptyProcess) { + try { + ptyProcess.kill("SIGKILL"); + } catch { + // Ignore + } + ptyProcess = null; + } + + process.exit(0); +} + +// ============================================================================= +// Main +// ============================================================================= + +const decoder = new PtySubprocessFrameDecoder(); + +process.stdin.on("data", (chunk: Buffer) => { + try { + const frames = decoder.push(chunk); + for (const frame of frames) { + switch (frame.type) { + case PtySubprocessIpcType.Spawn: + handleSpawn(frame.payload); + break; + case PtySubprocessIpcType.Write: + handleWrite(frame.payload); + break; + case PtySubprocessIpcType.Resize: + handleResize(frame.payload); + break; + case PtySubprocessIpcType.Kill: + handleKill(frame.payload); + break; + case PtySubprocessIpcType.Dispose: + handleDispose(); + break; + } + } + } catch (error) { + sendError( + `Failed to parse frame: ${error instanceof Error ? error.message : String(error)}`, + ); + } +}); + +process.stdin.on("end", () => { + handleDispose(); +}); + +send(PtySubprocessIpcType.Ready); diff --git a/apps/desktop/src/main/terminal-host/session.ts b/apps/desktop/src/main/terminal-host/session.ts index 2ff403eadec..f4d52e258f9 100644 --- a/apps/desktop/src/main/terminal-host/session.ts +++ b/apps/desktop/src/main/terminal-host/session.ts @@ -2,23 +2,30 @@ * Terminal Host Session * * A session owns: - * - A PTY process (node-pty) + * - A PTY subprocess (isolates blocking writes from main daemon) * - A HeadlessEmulator instance for state tracking * - A set of attached clients * - Output capture to disk */ +import * as path from "node:path"; import type { Socket } from "node:net"; -import * as pty from "node-pty"; +import { spawn, type ChildProcess } from "node:child_process"; import { HeadlessEmulator } from "../lib/terminal-host/headless-emulator"; import type { CreateOrAttachRequest, IpcEvent, SessionMeta, TerminalDataEvent, + TerminalErrorEvent, TerminalExitEvent, TerminalSnapshot, } from "../lib/terminal-host/types"; +import { + PtySubprocessFrameDecoder, + PtySubprocessIpcType, + createFrameHeader, +} from "./pty-subprocess-ipc"; // ============================================================================= // Types @@ -57,12 +64,25 @@ export class Session { readonly shell: string; readonly createdAt: Date; - private ptyProcess: pty.IPty | null = null; + private subprocess: ChildProcess | null = null; + private subprocessReady = false; + private ptyPid: number | null = null; private emulator: HeadlessEmulator; private attachedClients: Map = new Map(); + private clientSocketsWaitingForDrain: Set = new Set(); + private subprocessStdoutPaused = false; private lastAttachedAt: Date; private exitCode: number | null = null; private disposed = false; + private subprocessDecoder: PtySubprocessFrameDecoder | null = null; + private subprocessStdinQueue: Buffer[] = []; + private subprocessStdinQueuedBytes = 0; + private subprocessStdinDrainArmed = false; + + private emulatorWriteQueue: string[] = []; + private emulatorWriteQueuedBytes = 0; + private emulatorWriteScheduled = false; + private emulatorFlushWaiters: Array<() => void> = []; // Callbacks private onSessionExit?: ( @@ -93,16 +113,18 @@ export class Session { // Listen for emulator output (query responses) this.emulator.onData((data) => { // If no clients attached, send responses back to PTY - // This allows TUIs to function while app is closed - if (this.attachedClients.size === 0 && this.ptyProcess) { - this.ptyProcess.write(data); + if ( + this.attachedClients.size === 0 && + this.subprocess && + this.subprocessReady + ) { + this.sendWriteToSubprocess(data); } - // When clients are attached, the renderer handles responses }); } /** - * Spawn the PTY process + * Spawn the PTY process via subprocess */ spawn(options: { cwd: string; @@ -110,7 +132,7 @@ export class Session { rows: number; env?: Record; }): void { - if (this.ptyProcess) { + if (this.subprocess) { throw new Error("PTY already spawned"); } @@ -119,53 +141,368 @@ export class Session { // Build environment - filter out undefined values and ELECTRON_RUN_AS_NODE const processEnv: Record = {}; for (const [key, value] of Object.entries(process.env)) { - // Skip ELECTRON_RUN_AS_NODE (daemon runs with this, but spawned shells shouldn't) if (key === "ELECTRON_RUN_AS_NODE") continue; if (value !== undefined) { processEnv[key] = value; } } - // Add custom env vars Object.assign(processEnv, env); - // Ensure TERM is set processEnv.TERM = "xterm-256color"; // Get shell args const shellArgs = this.getShellArgs(this.shell); - this.ptyProcess = pty.spawn(this.shell, shellArgs, { - name: "xterm-256color", + // Spawn PTY subprocess + // The subprocess script is bundled alongside terminal-host.js + const subprocessPath = path.join(__dirname, "pty-subprocess.js"); + + // Use electron as node to run the subprocess + const electronPath = process.execPath; + this.subprocess = spawn(electronPath, [subprocessPath], { + stdio: ["pipe", "pipe", "inherit"], // pipe stdin/stdout, inherit stderr + env: { + ...process.env, + ELECTRON_RUN_AS_NODE: "1", + }, + }); + + // Read framed messages from subprocess stdout + if (this.subprocess.stdout) { + this.subprocessDecoder = new PtySubprocessFrameDecoder(); + this.subprocess.stdout.on("data", (chunk: Buffer) => { + try { + const frames = this.subprocessDecoder?.push(chunk) ?? []; + for (const frame of frames) { + this.handleSubprocessFrame(frame.type, frame.payload); + } + } catch (error) { + console.error( + `[Session ${this.sessionId}] Failed to parse subprocess frames:`, + error, + ); + } + }); + } + + // Handle subprocess exit + this.subprocess.on("exit", (code) => { + console.log( + `[Session ${this.sessionId}] Subprocess exited with code ${code}`, + ); + this.handleSubprocessExit(code ?? -1); + }); + + this.subprocess.on("error", (error) => { + console.error(`[Session ${this.sessionId}] Subprocess error:`, error); + this.handleSubprocessExit(-1); + }); + + // Store pending spawn config + this.pendingSpawn = { + shell: this.shell, + args: shellArgs, + cwd, cols, rows, - cwd, env: processEnv, - }); + }; + } - // Handle PTY data - this.ptyProcess.onData((data) => { - // Feed data to emulator for state tracking - this.emulator.write(data); + private pendingSpawn: { + shell: string; + args: string[]; + cwd: string; + cols: number; + rows: number; + env: Record; + } | null = null; - // Send to all attached clients - this.broadcastEvent("data", { - type: "data", - data, - } satisfies TerminalDataEvent); - }); + /** + * Handle frames from the PTY subprocess + */ + private handleSubprocessFrame( + type: PtySubprocessIpcType, + payload: Buffer, + ): void { + switch (type) { + case PtySubprocessIpcType.Ready: + this.subprocessReady = true; + console.log( + `[Session ${this.sessionId}] Subprocess ready, spawning PTY`, + ); + if (this.pendingSpawn) { + this.sendSpawnToSubprocess(this.pendingSpawn); + this.pendingSpawn = null; + } + break; + + case PtySubprocessIpcType.Spawned: + this.ptyPid = payload.length >= 4 ? payload.readUInt32LE(0) : null; + console.log( + `[Session ${this.sessionId}] PTY spawned with pid ${this.ptyPid}`, + ); + break; + + case PtySubprocessIpcType.Data: { + if (payload.length === 0) break; + const data = payload.toString("utf8"); + + this.enqueueEmulatorWrite(data); + + this.broadcastEvent("data", { + type: "data", + data, + } satisfies TerminalDataEvent); + break; + } + + case PtySubprocessIpcType.Exit: { + const exitCode = payload.length >= 4 ? payload.readInt32LE(0) : 0; + const signal = payload.length >= 8 ? payload.readInt32LE(4) : 0; + this.exitCode = exitCode; + + this.broadcastEvent("exit", { + type: "exit", + exitCode, + signal: signal !== 0 ? signal : undefined, + } satisfies TerminalExitEvent); + + this.onSessionExit?.( + this.sessionId, + exitCode, + signal !== 0 ? signal : undefined, + ); + break; + } - // Handle PTY exit - this.ptyProcess.onExit(({ exitCode, signal }) => { + case PtySubprocessIpcType.Error: { + const errorMessage = + payload.length > 0 + ? payload.toString("utf8") + : "Unknown subprocess error"; + + console.error( + `[Session ${this.sessionId}] Subprocess error:`, + errorMessage, + ); + + this.broadcastEvent("error", { + type: "error", + error: errorMessage, + code: errorMessage.includes("Write queue full") + ? "WRITE_QUEUE_FULL" + : "SUBPROCESS_ERROR", + } satisfies TerminalErrorEvent); + break; + } + } + } + + /** + * Handle subprocess exiting + */ + private handleSubprocessExit(exitCode: number): void { + if (this.exitCode === null) { this.exitCode = exitCode; - // Notify attached clients this.broadcastEvent("exit", { type: "exit", exitCode, - signal, } satisfies TerminalExitEvent); - // Notify session manager - this.onSessionExit?.(this.sessionId, exitCode, signal); + this.onSessionExit?.(this.sessionId, exitCode); + } + + this.subprocess = null; + this.subprocessReady = false; + this.subprocessDecoder = null; + this.subprocessStdinQueue = []; + this.subprocessStdinQueuedBytes = 0; + this.subprocessStdinDrainArmed = false; + this.subprocessStdoutPaused = false; + + this.emulatorWriteQueue = []; + this.emulatorWriteQueuedBytes = 0; + this.emulatorWriteScheduled = false; + const waiters = this.emulatorFlushWaiters; + this.emulatorFlushWaiters = []; + for (const resolve of waiters) resolve(); + } + + /** + * Flush queued frames to subprocess stdin, respecting stream backpressure. + */ + private flushSubprocessStdinQueue(): void { + if (!this.subprocess?.stdin || this.disposed) return; + + while (this.subprocessStdinQueue.length > 0) { + const buf = this.subprocessStdinQueue[0]; + const canWrite = this.subprocess.stdin.write(buf); + if (!canWrite) { + if (!this.subprocessStdinDrainArmed) { + this.subprocessStdinDrainArmed = true; + this.subprocess.stdin.once("drain", () => { + this.subprocessStdinDrainArmed = false; + this.flushSubprocessStdinQueue(); + }); + } + return; + } + + this.subprocessStdinQueue.shift(); + this.subprocessStdinQueuedBytes -= buf.length; + } + } + + /** + * Send a frame to the subprocess. + * Returns false if write buffer is full (caller should handle). + */ + private sendFrameToSubprocess( + type: PtySubprocessIpcType, + payload?: Buffer, + ): boolean { + if (!this.subprocess?.stdin || this.disposed) return false; + + const payloadBuffer = payload ?? Buffer.alloc(0); + const header = createFrameHeader(type, payloadBuffer.length); + + this.subprocessStdinQueue.push(header); + this.subprocessStdinQueuedBytes += header.length; + + if (payloadBuffer.length > 0) { + this.subprocessStdinQueue.push(payloadBuffer); + this.subprocessStdinQueuedBytes += payloadBuffer.length; + } + + const wasBackpressured = this.subprocessStdinDrainArmed; + this.flushSubprocessStdinQueue(); + + if (this.subprocessStdinDrainArmed && !wasBackpressured) { + console.warn( + `[Session ${this.sessionId}] stdin buffer full, write may be delayed`, + ); + } + + return !this.subprocessStdinDrainArmed; + } + + private sendSpawnToSubprocess(payload: { + shell: string; + args: string[]; + cwd: string; + cols: number; + rows: number; + env: Record; + }): boolean { + return this.sendFrameToSubprocess( + PtySubprocessIpcType.Spawn, + Buffer.from(JSON.stringify(payload), "utf8"), + ); + } + + private sendWriteToSubprocess(data: string): boolean { + // Chunk large writes to avoid allocating/queuing massive single frames. + const MAX_CHUNK_CHARS = 8192; + let ok = true; + + for (let offset = 0; offset < data.length; offset += MAX_CHUNK_CHARS) { + const part = data.slice(offset, offset + MAX_CHUNK_CHARS); + ok = + this.sendFrameToSubprocess( + PtySubprocessIpcType.Write, + Buffer.from(part, "utf8"), + ) && ok; + } + + return ok; + } + + private sendResizeToSubprocess(cols: number, rows: number): boolean { + const payload = Buffer.allocUnsafe(8); + payload.writeUInt32LE(cols, 0); + payload.writeUInt32LE(rows, 4); + return this.sendFrameToSubprocess(PtySubprocessIpcType.Resize, payload); + } + + private sendKillToSubprocess(signal?: string): boolean { + const payload = signal ? Buffer.from(signal, "utf8") : undefined; + return this.sendFrameToSubprocess(PtySubprocessIpcType.Kill, payload); + } + + private sendDisposeToSubprocess(): boolean { + return this.sendFrameToSubprocess(PtySubprocessIpcType.Dispose); + } + + private enqueueEmulatorWrite(data: string): void { + this.emulatorWriteQueue.push(data); + this.emulatorWriteQueuedBytes += data.length; + this.scheduleEmulatorWrite(); + } + + private scheduleEmulatorWrite(): void { + if (this.emulatorWriteScheduled || this.disposed) return; + this.emulatorWriteScheduled = true; + setImmediate(() => { + this.processEmulatorWriteQueue(); + }); + } + + private processEmulatorWriteQueue(): void { + if (this.disposed) { + this.emulatorWriteQueue = []; + this.emulatorWriteQueuedBytes = 0; + this.emulatorWriteScheduled = false; + const waiters = this.emulatorFlushWaiters; + this.emulatorFlushWaiters = []; + for (const resolve of waiters) resolve(); + return; + } + + const start = performance.now(); + const hasClients = this.attachedClients.size > 0; + const backlogBytes = this.emulatorWriteQueuedBytes; + + // Keep the daemon responsive while still ensuring the emulator catches up eventually. + const baseBudgetMs = hasClients ? 5 : 25; + const budgetMs = backlogBytes > 1024 * 1024 ? Math.max(baseBudgetMs, 25) : baseBudgetMs; + const MAX_CHUNK_CHARS = 8192; + + while (this.emulatorWriteQueue.length > 0) { + if (performance.now() - start > budgetMs) break; + + let chunk = this.emulatorWriteQueue[0]; + if (chunk.length > MAX_CHUNK_CHARS) { + this.emulatorWriteQueue[0] = chunk.slice(MAX_CHUNK_CHARS); + chunk = chunk.slice(0, MAX_CHUNK_CHARS); + } else { + this.emulatorWriteQueue.shift(); + } + this.emulatorWriteQueuedBytes -= chunk.length; + this.emulator.write(chunk); + } + + if (this.emulatorWriteQueue.length > 0) { + setImmediate(() => { + this.processEmulatorWriteQueue(); + }); + return; + } + + this.emulatorWriteScheduled = false; + const waiters = this.emulatorFlushWaiters; + this.emulatorFlushWaiters = []; + for (const resolve of waiters) resolve(); + } + + private async flushEmulatorWrites(): Promise { + if (this.emulatorWriteQueue.length === 0 && !this.emulatorWriteScheduled) { + return; + } + + await new Promise((resolve) => { + this.emulatorFlushWaiters.push(resolve); + this.scheduleEmulatorWrite(); }); } @@ -173,7 +510,7 @@ export class Session { * Check if session is alive (PTY running) */ get isAlive(): boolean { - return this.ptyProcess !== null && this.exitCode === null; + return this.subprocess !== null && this.exitCode === null; } /** @@ -185,25 +522,19 @@ export class Session { /** * Attach a client to this session - * Returns a snapshot after flushing any pending writes to ensure consistency - * - * Note: Socket disconnect handling is centralized in the daemon's handleConnection - * to avoid adding per-session listeners which could cause MaxListenersExceededWarning */ async attach(socket: Socket): Promise { if (this.disposed) { throw new Error("Session disposed"); } - // Track client this.attachedClients.set(socket, { socket, attachedAt: Date.now(), }); this.lastAttachedAt = new Date(); - // Return current snapshot after flushing pending writes - // This ensures any output produced while no clients were attached is included + await this.flushEmulatorWrites(); return this.emulator.getSnapshotAsync(); } @@ -212,24 +543,26 @@ export class Session { */ detach(socket: Socket): void { this.attachedClients.delete(socket); + this.clientSocketsWaitingForDrain.delete(socket); + this.maybeResumeSubprocessStdout(); } /** - * Write data to PTY + * Write data to PTY (non-blocking - sent to subprocess) */ write(data: string): void { - if (!this.ptyProcess) { + if (!this.subprocess || !this.subprocessReady) { throw new Error("PTY not spawned"); } - this.ptyProcess.write(data); + this.sendWriteToSubprocess(data); } /** * Resize PTY and emulator */ resize(cols: number, rows: number): void { - if (this.ptyProcess) { - this.ptyProcess.resize(cols, rows); + if (this.subprocess && this.subprocessReady) { + this.sendResizeToSubprocess(cols, rows); } this.emulator.resize(cols, rows); } @@ -242,7 +575,7 @@ export class Session { } /** - * Get session snapshot (for debugging/inspection) + * Get session snapshot */ getSnapshot(): TerminalSnapshot { return this.emulator.getSnapshot(); @@ -270,12 +603,17 @@ export class Session { * Kill the PTY process */ kill(signal: string = "SIGTERM"): void { - if (this.ptyProcess) { - try { - this.ptyProcess.kill(signal); - } catch { - // Process might already be dead - } + if (this.subprocess && this.subprocessReady) { + this.sendKillToSubprocess(signal); + return; + } + + // If the subprocess isn't ready yet, fall back to killing the subprocess itself + // so session termination is reliable ( differentiation isn't meaningful pre-spawn). + try { + this.subprocess?.kill(signal as NodeJS.Signals); + } catch { + // Ignore } } @@ -286,15 +624,31 @@ export class Session { if (this.disposed) return; this.disposed = true; - // Kill PTY - this.kill("SIGKILL"); - this.ptyProcess = null; + if (this.subprocess) { + this.sendDisposeToSubprocess(); + // Force kill after timeout + setTimeout(() => { + this.subprocess?.kill("SIGKILL"); + }, 1000); + this.subprocess = null; + } + this.subprocessReady = false; + this.subprocessDecoder = null; + this.subprocessStdinQueue = []; + this.subprocessStdinQueuedBytes = 0; + this.subprocessStdinDrainArmed = false; + + this.emulatorWriteQueue = []; + this.emulatorWriteQueuedBytes = 0; + this.emulatorWriteScheduled = false; + const waiters = this.emulatorFlushWaiters; + this.emulatorFlushWaiters = []; + for (const resolve of waiters) resolve(); - // Dispose emulator this.emulator.dispose(); - - // Clear clients this.attachedClients.clear(); + this.clientSocketsWaitingForDrain.clear(); + this.subprocessStdoutPaused = false; } /** @@ -311,11 +665,11 @@ export class Session { // =========================================================================== /** - * Broadcast an event to all attached clients + * Broadcast an event to all attached clients with backpressure awareness. */ private broadcastEvent( eventType: string, - payload: TerminalDataEvent | TerminalExitEvent, + payload: TerminalDataEvent | TerminalExitEvent | TerminalErrorEvent, ): void { const event: IpcEvent = { type: "event", @@ -328,14 +682,49 @@ export class Session { for (const { socket } of this.attachedClients.values()) { try { - socket.write(message); + const canWrite = socket.write(message); + if (!canWrite) { + // Socket buffer full - data will be queued but may cause memory pressure + // In production, could track this and pause PTY output temporarily + console.warn( + `[Session ${this.sessionId}] Client socket buffer full, output may be delayed`, + ); + this.handleClientBackpressure(socket); + } } catch { - // Client might have disconnected this.attachedClients.delete(socket); + this.clientSocketsWaitingForDrain.delete(socket); } } } + private handleClientBackpressure(socket: Socket): void { + // If the client can’t keep up, pause reading from the subprocess stdout. + // This will backpressure the subprocess stdout pipe, which in turn pauses + // PTY reads inside the subprocess (preventing runaway buffering/CPU). + if (!this.subprocessStdoutPaused && this.subprocess?.stdout) { + this.subprocessStdoutPaused = true; + this.subprocess.stdout.pause(); + } + + if (this.clientSocketsWaitingForDrain.has(socket)) return; + this.clientSocketsWaitingForDrain.add(socket); + + socket.once("drain", () => { + this.clientSocketsWaitingForDrain.delete(socket); + this.maybeResumeSubprocessStdout(); + }); + } + + private maybeResumeSubprocessStdout(): void { + if (this.clientSocketsWaitingForDrain.size > 0) return; + if (!this.subprocessStdoutPaused) return; + if (!this.subprocess?.stdout) return; + + this.subprocessStdoutPaused = false; + this.subprocess.stdout.resume(); + } + /** * Get default shell for the platform */ @@ -352,9 +741,8 @@ export class Session { private getShellArgs(shell: string): string[] { const shellName = shell.split("/").pop() || ""; - // Common shells that support login shell if (["zsh", "bash", "sh", "ksh", "fish"].includes(shellName)) { - return ["-l"]; // Login shell + return ["-l"]; } return []; diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index 7cc0100210f..8d278fb72ab 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -2,6 +2,7 @@ import { toast } from "@superset/ui/sonner"; import type { FitAddon } from "@xterm/addon-fit"; import type { SearchAddon } from "@xterm/addon-search"; import type { IDisposable, Terminal as XTerm } from "@xterm/xterm"; +import { toast } from "@superset/ui/sonner"; import "@xterm/xterm/css/xterm.css"; import debounce from "lodash/debounce"; import { useCallback, useEffect, useRef, useState } from "react"; @@ -29,6 +30,11 @@ import { shellEscapePaths } from "./utils"; const FIRST_RENDER_RESTORE_FALLBACK_MS = 250; +// Module-level map to track pending detach timeouts. +// This survives React StrictMode's unmount/remount cycle, allowing us to +// cancel a pending detach if the component immediately remounts. +const pendingDetaches = new Map(); + type CreateOrAttachResult = { wasRecovered: boolean; isNew: boolean; @@ -88,6 +94,10 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { // Track alternate screen mode ourselves (xterm.buffer.active.type is unreliable after HMR/recovery) // Updated from: snapshot.modes.alternateScreen on restore, escape sequences in stream const isAlternateScreenRef = useRef(false); + // Track bracketed paste mode so large pastes can preserve a single bracketed-paste envelope. + const isBracketedPasteRef = useRef(false); + // Track mode toggles across chunk boundaries (escape sequences can span stream frames). + const modeScanBufferRef = useRef(""); // Refs avoid effect re-runs when these values change const isFocusedRef = useRef(isFocused); @@ -103,6 +113,11 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const { data: workspaceCwd } = trpc.terminal.getWorkspaceCwd.useQuery(workspaceId); + // Use ref for workspaceCwd to avoid terminal recreation when query loads + // (changing from undefined→string triggers useEffect, causing xterm errors) + const workspaceCwdRef = useRef(workspaceCwd); + workspaceCwdRef.current = workspaceCwd; + // Query terminal link behavior setting const { data: terminalLinkBehavior } = trpc.settings.getTerminalLinkBehavior.useQuery(); @@ -238,6 +253,36 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { }, 100), ); + const updateModesFromData = useCallback((data: string) => { + // Escape sequences can be split across streamed frames, so scan using a small carry buffer. + const combined = modeScanBufferRef.current + data; + + const enterAltIndex = Math.max( + combined.lastIndexOf("\x1b[?1049h"), + combined.lastIndexOf("\x1b[?47h"), + ); + const exitAltIndex = Math.max( + combined.lastIndexOf("\x1b[?1049l"), + combined.lastIndexOf("\x1b[?47l"), + ); + if (enterAltIndex !== -1 || exitAltIndex !== -1) { + isAlternateScreenRef.current = enterAltIndex > exitAltIndex; + } + + const enableBracketedIndex = combined.lastIndexOf("\x1b[?2004h"); + const disableBracketedIndex = combined.lastIndexOf("\x1b[?2004l"); + if (enableBracketedIndex !== -1 || disableBracketedIndex !== -1) { + isBracketedPasteRef.current = + enableBracketedIndex > disableBracketedIndex; + } + + // Keep a small tail in case the next chunk starts mid-sequence. + modeScanBufferRef.current = combined.slice(-32); + }, []); + + const updateModesFromDataRef = useRef(updateModesFromData); + updateModesFromDataRef.current = updateModesFromData; + const flushPendingEvents = useCallback(() => { const xterm = xtermRef.current; if (!xterm) return; @@ -250,20 +295,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { for (const event of events) { if (event.type === "data") { - // Track alternate screen mode from queued events too - // (escape sequences sent before stream was ready) - if ( - event.data.includes("\x1b[?1049h") || - event.data.includes("\x1b[?47h") - ) { - isAlternateScreenRef.current = true; - } - if ( - event.data.includes("\x1b[?1049l") || - event.data.includes("\x1b[?47l") - ) { - isAlternateScreenRef.current = false; - } + updateModesFromDataRef.current(event.data); xterm.write(event.data); updateCwdRef.current(event.data); } else if (event.type === "exit") { @@ -281,8 +313,16 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { : event.error; console.warn("[Terminal] stream error:", message); - // Don't block interaction for non-fatal issues like a paste drop. - if (event.code === "WRITE_QUEUE_FULL") { + toast.error("Terminal error", { + description: message, + }); + + // Don't block interaction for non-fatal issues like a paste drop or a + // transient write failure (we keep the session alive). + if ( + event.code === "WRITE_QUEUE_FULL" || + event.code === "WRITE_FAILED" + ) { xterm.writeln(`\r\n[Terminal] ${message}`); } else { setConnectionError(message); @@ -308,6 +348,8 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { // Track alternate screen mode from snapshot for our own reference // (xterm.buffer.active.type is unreliable after HMR/recovery) isAlternateScreenRef.current = !!result.snapshot?.modes.alternateScreen; + isBracketedPasteRef.current = !!result.snapshot?.modes.bracketedPaste; + modeScanBufferRef.current = ""; // Also parse scrollback for escape sequences in case snapshot.modes is incomplete // This handles cases where the daemon didn't track the mode but the sequences are in history @@ -322,6 +364,15 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { if (hasEnterAlt && !hasExitAlt) { isAlternateScreenRef.current = true; } + + // Bracketed paste mode can toggle during a session - use the last seen state. + const bracketEnableIndex = result.scrollback.lastIndexOf("\x1b[?2004h"); + const bracketDisableIndex = + result.scrollback.lastIndexOf("\x1b[?2004l"); + if (bracketEnableIndex !== -1 || bracketDisableIndex !== -1) { + isBracketedPasteRef.current = + bracketEnableIndex > bracketDisableIndex; + } } // If session was in alternate screen mode, enter it BEFORE writing content. @@ -442,20 +493,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { } if (event.type === "data") { - // Track alternate screen mode changes from escape sequences - // Check for both modern (1049) and legacy (47) alternate screen sequences - if ( - event.data.includes("\x1b[?1049h") || - event.data.includes("\x1b[?47h") - ) { - isAlternateScreenRef.current = true; - } - if ( - event.data.includes("\x1b[?1049l") || - event.data.includes("\x1b[?47l") - ) { - isAlternateScreenRef.current = false; - } + updateModesFromDataRef.current(event.data); xtermRef.current.write(event.data); updateCwdFromData(event.data); } else if (event.type === "exit") { @@ -474,7 +512,11 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { : event.error; console.warn("[Terminal] stream error:", message); - if (event.code === "WRITE_QUEUE_FULL") { + toast.error("Terminal error", { + description: message, + }); + + if (event.code === "WRITE_QUEUE_FULL" || event.code === "WRITE_FAILED") { xtermRef.current.writeln(`\r\n[Terminal] ${message}`); } else { setConnectionError(message); @@ -520,6 +562,15 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const container = terminalRef.current; if (!container) return; + // Cancel any pending detach from a previous unmount (e.g., React StrictMode's + // simulated unmount/remount cycle). This prevents the detach from corrupting + // the terminal state when we're immediately remounting. + const pendingDetach = pendingDetaches.get(paneId); + if (pendingDetach) { + clearTimeout(pendingDetach); + pendingDetaches.delete(paneId); + } + let isUnmounted = false; const { @@ -528,7 +579,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { renderer, cleanup: cleanupQuerySuppression, } = createTerminalInstance(container, { - cwd: workspaceCwd, + cwd: workspaceCwdRef.current, initialTheme: initialThemeRef.current, onFileLinkClick: (path, line, column) => handleFileLinkClickRef.current(path, line, column), @@ -581,6 +632,8 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { isExitedRef.current = false; isStreamReadyRef.current = false; isAlternateScreenRef.current = false; // Reset for new shell + isBracketedPasteRef.current = false; + modeScanBufferRef.current = ""; xterm.clear(); createOrAttachRef.current( { @@ -725,6 +778,8 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { onPaste: (text) => { commandBufferRef.current += text; }, + onWrite: handleWrite, + isBracketedPasteEnabled: () => isBracketedPasteRef.current, }); return () => { @@ -743,26 +798,39 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { cleanupQuerySuppression(); unregisterClearCallbackRef.current(paneId); debouncedSetTabAutoTitleRef.current?.cancel?.(); - // Detach instead of kill to keep PTY running for reattachment - detachRef.current({ paneId }); + + // Debounce detach to handle React StrictMode's unmount/remount cycle. + // If the component remounts quickly (as in StrictMode), the new mount will + // cancel this timeout, preventing the detach from corrupting terminal state. + const detachTimeout = setTimeout(() => { + detachRef.current({ paneId }); + pendingDetaches.delete(paneId); + }, 50); + pendingDetaches.set(paneId, detachTimeout); + isStreamReadyRef.current = false; didFirstRenderRef.current = false; pendingInitialStateRef.current = null; isAlternateScreenRef.current = false; + isBracketedPasteRef.current = false; + modeScanBufferRef.current = ""; renderDisposableRef.current?.dispose(); renderDisposableRef.current = null; - xterm.dispose(); + + // Delay xterm.dispose() to let internal timeouts complete. + // xterm.open() schedules a setTimeout for Viewport.syncScrollArea. + // If we dispose synchronously, that timeout fires after _renderer is + // cleared, causing "Cannot read properties of undefined (reading 'dimensions')". + // Using setTimeout(0) ensures our dispose runs after xterm's internal callback. + setTimeout(() => { + xterm.dispose(); + }, 0); + xtermRef.current = null; searchAddonRef.current = null; rendererRef.current = null; }; - }, [ - paneId, - workspaceId, - workspaceCwd, - flushPendingEvents, - maybeApplyInitialState, - ]); + }, [paneId, workspaceId, flushPendingEvents, maybeApplyInitialState]); useEffect(() => { const xterm = xtermRef.current; diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/helpers.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/helpers.ts index c726f7f8cc3..c63b0b610b1 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/helpers.ts +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/helpers.ts @@ -139,17 +139,35 @@ export function createTerminalInstance( const unicode11Addon = new Unicode11Addon(); const imageAddon = new ImageAddon(); + // Track cleanup state to prevent operations on disposed terminal + let isDisposed = false; + let renderer: { dispose: () => void } | null = null; + let rafId: number | null = null; + xterm.open(container); + // Load non-renderer addons synchronously - these are safe and needed immediately xterm.loadAddon(fitAddon); - const renderer = loadRenderer(xterm); - xterm.loadAddon(clipboardAddon); xterm.loadAddon(unicode11Addon); xterm.loadAddon(imageAddon); + // Defer GPU renderer loading to next animation frame. + // xterm.open() schedules a setTimeout for Viewport.syncScrollArea which expects + // the renderer to be ready. Loading WebGL/Canvas immediately after open() can + // cause a race condition where the setTimeout fires during addon initialization, + // when _renderer is temporarily undefined (old renderer disposed, new not yet set). + // Deferring to rAF ensures xterm's internal setTimeout completes first with the + // default DOM renderer, then we safely swap to WebGL/Canvas. + rafId = requestAnimationFrame(() => { + rafId = null; + if (isDisposed) return; + renderer = loadRenderer(xterm); + }); + import("@xterm/addon-ligatures") .then(({ LigaturesAddon }) => { + if (isDisposed) return; try { xterm.loadAddon(new LigaturesAddon()); } catch { @@ -201,8 +219,12 @@ export function createTerminalInstance( fitAddon, renderer, cleanup: () => { + isDisposed = true; + if (rafId !== null) { + cancelAnimationFrame(rafId); + } cleanupQuerySuppression(); - renderer.dispose(); + renderer?.dispose(); }, }; } @@ -217,6 +239,10 @@ export interface KeyboardHandlerOptions { export interface PasteHandlerOptions { /** Callback when text is pasted, receives the pasted text */ onPaste?: (text: string) => void; + /** Optional direct write callback to bypass xterm's paste burst */ + onWrite?: (data: string) => void; + /** Whether bracketed paste mode is enabled for the current terminal */ + isBracketedPasteEnabled?: () => boolean; } /** @@ -240,6 +266,8 @@ export function setupPasteHandler( const textarea = xterm.textarea; if (!textarea) return () => {}; + let cancelActivePaste: (() => void) | null = null; + const handlePaste = (event: ClipboardEvent) => { const text = event.clipboardData?.getData("text/plain"); if (!text) return; @@ -248,12 +276,100 @@ export function setupPasteHandler( event.stopImmediatePropagation(); options.onPaste?.(text); - xterm.paste(text); + + // Cancel any in-flight chunked paste to avoid overlapping writes. + cancelActivePaste?.(); + cancelActivePaste = null; + + // Chunk large pastes to avoid sending a single massive input burst that can + // overwhelm the PTY pipeline (especially when the app is repainting heavily). + const MAX_SYNC_PASTE_CHARS = 16_384; + + // If no direct write callback is provided, fall back to xterm's paste() + // (it handles newline normalization and bracketed paste mode internally). + if (!options.onWrite) { + const CHUNK_CHARS = 4096; + const CHUNK_DELAY_MS = 5; + + if (text.length <= MAX_SYNC_PASTE_CHARS) { + xterm.paste(text); + return; + } + + let cancelled = false; + let offset = 0; + + const pasteNext = () => { + if (cancelled) return; + + const chunk = text.slice(offset, offset + CHUNK_CHARS); + offset += CHUNK_CHARS; + xterm.paste(chunk); + + if (offset < text.length) { + setTimeout(pasteNext, CHUNK_DELAY_MS); + } + }; + + cancelActivePaste = () => { + cancelled = true; + }; + + pasteNext(); + return; + } + + // Direct write path: replicate xterm's paste normalization, but stream in + // controlled chunks while preserving bracketed-paste semantics. + const preparedText = text.replace(/\r?\n/g, "\r"); + const bracketedPasteEnabled = options.isBracketedPasteEnabled?.() ?? false; + const shouldBracket = bracketedPasteEnabled; + + // For small/medium pastes, preserve the fast path and avoid timers. + if (preparedText.length <= MAX_SYNC_PASTE_CHARS) { + options.onWrite( + shouldBracket ? `\x1b[200~${preparedText}\x1b[201~` : preparedText, + ); + return; + } + + let cancelled = false; + let offset = 0; + const CHUNK_CHARS = 16_384; + const CHUNK_DELAY_MS = 0; + + const pasteNext = () => { + if (cancelled) return; + + const chunk = preparedText.slice(offset, offset + CHUNK_CHARS); + offset += CHUNK_CHARS; + + if (shouldBracket) { + // Wrap each chunk to avoid long-running "open" bracketed paste blocks, + // which some TUIs may defer repainting until the closing sequence arrives. + options.onWrite?.(`\x1b[200~${chunk}\x1b[201~`); + } else { + options.onWrite?.(chunk); + } + + if (offset < preparedText.length) { + setTimeout(pasteNext, CHUNK_DELAY_MS); + return; + } + }; + + cancelActivePaste = () => { + cancelled = true; + }; + + pasteNext(); }; textarea.addEventListener("paste", handlePaste, { capture: true }); return () => { + cancelActivePaste?.(); + cancelActivePaste = null; textarea.removeEventListener("paste", handlePaste, { capture: true }); }; } From 3caadf7c0dfee30254d379f7b620a26109475a60 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Wed, 31 Dec 2025 13:19:52 +0200 Subject: [PATCH 74/98] fix(desktop): force terminal redraw on tab switch - Track async GPU renderer via ref to reliably clear WebGL atlas - Schedule fit+refresh on focus/resize to avoid partial renders when switching panes --- .../TabsContent/Terminal/Terminal.tsx | 65 +++++++++++++++++-- .../TabsContent/Terminal/helpers.ts | 27 ++++++-- 2 files changed, 83 insertions(+), 9 deletions(-) diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index 8d278fb72ab..a711f67f0e5 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -21,7 +21,7 @@ import { setupKeyboardHandler, setupPasteHandler, setupResizeHandlers, - type TerminalRenderer, + type TerminalRendererRef, } from "./helpers"; import { parseCwd } from "./parseCwd"; import { TerminalSearch } from "./TerminalSearch"; @@ -62,7 +62,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const xtermRef = useRef(null); const fitAddonRef = useRef(null); const searchAddonRef = useRef(null); - const rendererRef = useRef(null); + const rendererRef = useRef(null); const isExitedRef = useRef(false); const pendingEventsRef = useRef([]); const commandBufferRef = useRef(""); @@ -103,6 +103,49 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const isFocusedRef = useRef(isFocused); isFocusedRef.current = isFocused; + // Some GPU renderers (notably xterm-webgl) can fail to repaint correctly after + // pane/tab switching until a resize happens. Schedule a redraw on focus. + const redrawRafRef = useRef(null); + const scheduleRedraw = useCallback(() => { + if (redrawRafRef.current !== null) return; + + redrawRafRef.current = requestAnimationFrame(() => { + redrawRafRef.current = null; + + const xterm = xtermRef.current; + const fitAddon = fitAddonRef.current; + if (!xterm || !fitAddon) return; + + try { + fitAddon.fit(); + } catch { + // Ignore fit errors + } + + const cols = xterm.cols; + const rows = xterm.rows; + if (cols <= 0 || rows <= 0) return; + + // Keep PTY dimensions in sync even when FitAddon doesn't change cols/rows. + resizeRef.current({ paneId, cols, rows }); + + const renderer = rendererRef.current?.current; + if (renderer?.kind === "webgl") { + renderer.clearTextureAtlas?.(); + } + xterm.refresh(0, rows - 1); + }); + }, [paneId]); + + useEffect(() => { + return () => { + if (redrawRafRef.current !== null) { + cancelAnimationFrame(redrawRafRef.current); + redrawRafRef.current = null; + } + }; + }, []); + const paneInitialCommandsRef = useRef(paneInitialCommands); const paneInitialCwdRef = useRef(paneInitialCwd); const clearPaneInitialDataRef = useRef(clearPaneInitialData); @@ -415,7 +458,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { resizeRef.current({ paneId, cols, rows }); if (!result.isNew) { - const renderer = rendererRef.current; + const renderer = rendererRef.current?.current; if (renderer?.kind === "webgl") { // Clear twice: once immediately, and once after fonts settle. // This reduces restore artifacts (especially for TUIs like opencode) @@ -546,8 +589,13 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { useEffect(() => { if (isFocused && xtermRef.current) { xtermRef.current.focus(); + scheduleRedraw(); + void document.fonts?.ready.then(() => { + if (!isFocusedRef.current) return; + scheduleRedraw(); + }); } - }, [isFocused]); + }, [isFocused, scheduleRedraw]); useAppHotkey( "FIND_IN_TERMINAL", @@ -772,6 +820,15 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { fitAddon, (cols, rows) => { resizeRef.current({ paneId, cols, rows }); + // Repaint immediately after a resize; without this, WebGL terminals can + // remain partially drawn until the next user interaction. + if (rows > 0) { + const renderer = rendererRef.current?.current; + if (renderer?.kind === "webgl") { + renderer.clearTextureAtlas?.(); + } + xterm.refresh(0, rows - 1); + } }, ); const cleanupPaste = setupPasteHandler(xterm, { diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/helpers.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/helpers.ts index c63b0b610b1..b93770df30e 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/helpers.ts +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/helpers.ts @@ -118,13 +118,21 @@ export interface CreateTerminalOptions { onFileLinkClick?: (path: string, line?: number, column?: number) => void; } +/** + * Mutable reference to the terminal renderer. + * Used because the GPU renderer is loaded asynchronously after the terminal is created. + */ +export interface TerminalRendererRef { + current: TerminalRenderer; +} + export function createTerminalInstance( container: HTMLDivElement, options: CreateTerminalOptions = {}, ): { xterm: XTerm; fitAddon: FitAddon; - renderer: TerminalRenderer; + renderer: TerminalRendererRef; cleanup: () => void; } { const { cwd, initialTheme, onFileLinkClick } = options; @@ -141,9 +149,18 @@ export function createTerminalInstance( // Track cleanup state to prevent operations on disposed terminal let isDisposed = false; - let renderer: { dispose: () => void } | null = null; let rafId: number | null = null; + // Use a ref pattern so the renderer can be updated after rAF. + // Start with a no-op DOM renderer - the actual GPU renderer is loaded async. + const rendererRef: TerminalRendererRef = { + current: { + kind: "dom", + dispose: () => {}, + clearTextureAtlas: undefined, + }, + }; + xterm.open(container); // Load non-renderer addons synchronously - these are safe and needed immediately @@ -162,7 +179,7 @@ export function createTerminalInstance( rafId = requestAnimationFrame(() => { rafId = null; if (isDisposed) return; - renderer = loadRenderer(xterm); + rendererRef.current = loadRenderer(xterm); }); import("@xterm/addon-ligatures") @@ -217,14 +234,14 @@ export function createTerminalInstance( return { xterm, fitAddon, - renderer, + renderer: rendererRef, cleanup: () => { isDisposed = true; if (rafId !== null) { cancelAnimationFrame(rafId); } cleanupQuerySuppression(); - renderer?.dispose(); + rendererRef.current.dispose(); }, }; } From 056544aaca31b3980c81854675380f399b69fffa Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Wed, 31 Dec 2025 13:37:15 +0200 Subject: [PATCH 75/98] fix(desktop): reduce terminal redraw side effects Avoid fit/PTY resizes and WebGL atlas clears on focus; do a lightweight refresh instead. --- .../TabsContent/Terminal/Terminal.tsx | 27 ++----------------- 1 file changed, 2 insertions(+), 25 deletions(-) diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index a711f67f0e5..0558be86a4e 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -104,7 +104,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { isFocusedRef.current = isFocused; // Some GPU renderers (notably xterm-webgl) can fail to repaint correctly after - // pane/tab switching until a resize happens. Schedule a redraw on focus. + // pane/tab switching until a resize happens. Schedule a lightweight redraw on focus. const redrawRafRef = useRef(null); const scheduleRedraw = useCallback(() => { if (redrawRafRef.current !== null) return; @@ -113,26 +113,12 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { redrawRafRef.current = null; const xterm = xtermRef.current; - const fitAddon = fitAddonRef.current; - if (!xterm || !fitAddon) return; - - try { - fitAddon.fit(); - } catch { - // Ignore fit errors - } + if (!xterm) return; const cols = xterm.cols; const rows = xterm.rows; if (cols <= 0 || rows <= 0) return; - // Keep PTY dimensions in sync even when FitAddon doesn't change cols/rows. - resizeRef.current({ paneId, cols, rows }); - - const renderer = rendererRef.current?.current; - if (renderer?.kind === "webgl") { - renderer.clearTextureAtlas?.(); - } xterm.refresh(0, rows - 1); }); }, [paneId]); @@ -820,15 +806,6 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { fitAddon, (cols, rows) => { resizeRef.current({ paneId, cols, rows }); - // Repaint immediately after a resize; without this, WebGL terminals can - // remain partially drawn until the next user interaction. - if (rows > 0) { - const renderer = rendererRef.current?.current; - if (renderer?.kind === "webgl") { - renderer.clearTextureAtlas?.(); - } - xterm.refresh(0, rows - 1); - } }, ); const cleanupPaste = setupPasteHandler(xterm, { From 4c795058a21e51d6590c3ee53cbb3358f024ff5c Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Wed, 31 Dec 2025 13:39:05 +0200 Subject: [PATCH 76/98] fix(desktop): address terminal persistence PR feedback - Remove duplicate terminalError handler in daemon-manager.ts (was causing duplicate event emissions) - Fix failing write test in manager.test.ts (add async wait for PtyWriteQueue flush before assertion) - Fix attach() hang with continuous output in session.ts (add 500ms timeout to flushEmulatorWrites to prevent indefinite hang when processes like tail -f produce continuous output) - Apply biome formatting fixes --- .../src/main/lib/terminal-host/client.ts | 8 ++-- .../src/main/lib/terminal/daemon-manager.ts | 9 ----- .../src/main/lib/terminal/manager.test.ts | 3 ++ apps/desktop/src/main/terminal-host/index.ts | 6 ++- .../main/terminal-host/pty-subprocess-ipc.ts | 4 +- .../src/main/terminal-host/pty-subprocess.ts | 14 ++++--- .../desktop/src/main/terminal-host/session.ts | 37 +++++++++++++++---- .../TabsContent/Terminal/Terminal.tsx | 3 +- 8 files changed, 51 insertions(+), 33 deletions(-) diff --git a/apps/desktop/src/main/lib/terminal-host/client.ts b/apps/desktop/src/main/lib/terminal-host/client.ts index 25e9491d9f1..51fa67a6f45 100644 --- a/apps/desktop/src/main/lib/terminal-host/client.ts +++ b/apps/desktop/src/main/lib/terminal-host/client.ts @@ -79,8 +79,6 @@ const SPAWN_LOCK_TIMEOUT_MS = 10000; // Max time to hold spawn lock // ============================================================================= class NdjsonParser { - // Use array buffering to avoid O(n²) string concatenation on high-volume streams - private chunks: string[] = []; private remainder = ""; parse(chunk: string): Array { @@ -154,7 +152,6 @@ export class TerminalHostClient extends EventEmitter { private connectionState = ConnectionState.DISCONNECTED; private disposed = false; private notifyQueue: string[] = []; - private notifyQueueBytes = 0; private notifyDrainArmed = false; // =========================================================================== @@ -720,7 +717,10 @@ export class TerminalHostClient extends EventEmitter { this.sendNotification("write", request); }) .catch((error) => { - this.emit("error", error instanceof Error ? error : new Error(String(error))); + this.emit( + "error", + error instanceof Error ? error : new Error(String(error)), + ); }); } diff --git a/apps/desktop/src/main/lib/terminal/daemon-manager.ts b/apps/desktop/src/main/lib/terminal/daemon-manager.ts index 4fbaea5b8e0..b32eeff4213 100644 --- a/apps/desktop/src/main/lib/terminal/daemon-manager.ts +++ b/apps/desktop/src/main/lib/terminal/daemon-manager.ts @@ -97,15 +97,6 @@ export class DaemonTerminalManager extends EventEmitter { }, ); - // Forward terminal-specific error events (e.g., write queue full) - this.client.on( - "terminalError", - (sessionId: string, error: string, code?: string) => { - const paneId = sessionId; - this.emit(`error:${paneId}`, { error, code }); - }, - ); - // Handle client disconnection - notify all active sessions this.client.on("disconnected", () => { console.warn("[DaemonTerminalManager] Disconnected from daemon"); diff --git a/apps/desktop/src/main/lib/terminal/manager.test.ts b/apps/desktop/src/main/lib/terminal/manager.test.ts index f6d2c9d6146..87fd7767168 100644 --- a/apps/desktop/src/main/lib/terminal/manager.test.ts +++ b/apps/desktop/src/main/lib/terminal/manager.test.ts @@ -165,6 +165,9 @@ describe("TerminalManager", () => { data: "ls -la\n", }); + // Wait for PtyWriteQueue async flush (uses setTimeout internally) + await new Promise((resolve) => setTimeout(resolve, 20)); + expect(mockPty.write).toHaveBeenCalledWith("ls -la\n"); }); diff --git a/apps/desktop/src/main/terminal-host/index.ts b/apps/desktop/src/main/terminal-host/index.ts index 9353f240011..f4a92d144f0 100644 --- a/apps/desktop/src/main/terminal-host/index.ts +++ b/apps/desktop/src/main/terminal-host/index.ts @@ -30,8 +30,8 @@ import { type DetachRequest, type HelloRequest, type HelloResponse, - type IpcEvent, type IpcErrorResponse, + type IpcEvent, type IpcRequest, type IpcSuccessResponse, type KillAllRequest, @@ -273,7 +273,9 @@ const handlers: Record = { } satisfies TerminalErrorEvent, }; socket.write(`${JSON.stringify(event)}\n`); - log("warn", `Write failed for ${request.sessionId}`, { error: message }); + log("warn", `Write failed for ${request.sessionId}`, { + error: message, + }); return; } diff --git a/apps/desktop/src/main/terminal-host/pty-subprocess-ipc.ts b/apps/desktop/src/main/terminal-host/pty-subprocess-ipc.ts index 28d35c156a1..c4eb0780d1e 100644 --- a/apps/desktop/src/main/terminal-host/pty-subprocess-ipc.ts +++ b/apps/desktop/src/main/terminal-host/pty-subprocess-ipc.ts @@ -90,7 +90,8 @@ export class PtySubprocessFrameDecoder { } this.frameType = type; - this.payload = payloadLength > 0 ? Buffer.allocUnsafe(payloadLength) : null; + this.payload = + payloadLength > 0 ? Buffer.allocUnsafe(payloadLength) : null; this.payloadOffset = 0; this.headerOffset = 0; @@ -125,4 +126,3 @@ export class PtySubprocessFrameDecoder { return frames; } } - diff --git a/apps/desktop/src/main/terminal-host/pty-subprocess.ts b/apps/desktop/src/main/terminal-host/pty-subprocess.ts index 01cf0472685..fc7bf5db4a6 100644 --- a/apps/desktop/src/main/terminal-host/pty-subprocess.ts +++ b/apps/desktop/src/main/terminal-host/pty-subprocess.ts @@ -8,9 +8,9 @@ * to avoid JSON escaping overhead on escape-sequence-heavy PTY output. */ -import * as pty from "node-pty"; -import type { IPty } from "node-pty"; import { write as fsWrite } from "node:fs"; +import type { IPty } from "node-pty"; +import * as pty from "node-pty"; import { PtySubprocessFrameDecoder, PtySubprocessIpcType, @@ -63,8 +63,7 @@ const MAX_OUTPUT_BATCH_SIZE_BYTES = 128 * 1024; // 128KB max per flush let stdoutDraining = true; let ptyPaused = false; -const DEBUG_OUTPUT_BATCHING = - process.env.SUPERSET_PTY_SUBPROCESS_DEBUG === "1"; +const DEBUG_OUTPUT_BATCHING = process.env.SUPERSET_PTY_SUBPROCESS_DEBUG === "1"; // ============================================================================= // Helpers @@ -188,7 +187,10 @@ function flush(): void { writeBackoffMs === 0 ? MIN_WRITE_BACKOFF_MS : Math.min(writeBackoffMs * 2, MAX_WRITE_BACKOFF_MS); - if (DEBUG_OUTPUT_BATCHING && writeBackoffMs === MIN_WRITE_BACKOFF_MS) { + if ( + DEBUG_OUTPUT_BATCHING && + writeBackoffMs === MIN_WRITE_BACKOFF_MS + ) { console.error("[pty-subprocess] PTY input backpressured (EAGAIN)"); } setTimeout(flush, writeBackoffMs); @@ -227,7 +229,7 @@ function flush(): void { // Fallback: node-pty's write() is synchronous and can block. // This path should rarely be used on macOS, but keep it for safety. - let chunk = writeQueue.shift(); + const chunk = writeQueue.shift(); if (!chunk) { flushing = false; return; diff --git a/apps/desktop/src/main/terminal-host/session.ts b/apps/desktop/src/main/terminal-host/session.ts index f4d52e258f9..e8be10ebdad 100644 --- a/apps/desktop/src/main/terminal-host/session.ts +++ b/apps/desktop/src/main/terminal-host/session.ts @@ -8,9 +8,9 @@ * - Output capture to disk */ -import * as path from "node:path"; +import { type ChildProcess, spawn } from "node:child_process"; import type { Socket } from "node:net"; -import { spawn, type ChildProcess } from "node:child_process"; +import * as path from "node:path"; import { HeadlessEmulator } from "../lib/terminal-host/headless-emulator"; import type { CreateOrAttachRequest, @@ -22,11 +22,21 @@ import type { TerminalSnapshot, } from "../lib/terminal-host/types"; import { + createFrameHeader, PtySubprocessFrameDecoder, PtySubprocessIpcType, - createFrameHeader, } from "./pty-subprocess-ipc"; +// ============================================================================= +// Constants +// ============================================================================= + +/** + * Timeout for flushing emulator writes during attach. + * Prevents indefinite hang when continuous output (e.g., tail -f) keeps the queue non-empty. + */ +const ATTACH_FLUSH_TIMEOUT_MS = 500; + // ============================================================================= // Types // ============================================================================= @@ -76,7 +86,6 @@ export class Session { private disposed = false; private subprocessDecoder: PtySubprocessFrameDecoder | null = null; private subprocessStdinQueue: Buffer[] = []; - private subprocessStdinQueuedBytes = 0; private subprocessStdinDrainArmed = false; private emulatorWriteQueue: string[] = []; @@ -465,7 +474,8 @@ export class Session { // Keep the daemon responsive while still ensuring the emulator catches up eventually. const baseBudgetMs = hasClients ? 5 : 25; - const budgetMs = backlogBytes > 1024 * 1024 ? Math.max(baseBudgetMs, 25) : baseBudgetMs; + const budgetMs = + backlogBytes > 1024 * 1024 ? Math.max(baseBudgetMs, 25) : baseBudgetMs; const MAX_CHUNK_CHARS = 8192; while (this.emulatorWriteQueue.length > 0) { @@ -495,15 +505,25 @@ export class Session { for (const resolve of waiters) resolve(); } - private async flushEmulatorWrites(): Promise { + private async flushEmulatorWrites(timeoutMs?: number): Promise { if (this.emulatorWriteQueue.length === 0 && !this.emulatorWriteScheduled) { return; } - await new Promise((resolve) => { + const flushPromise = new Promise((resolve) => { this.emulatorFlushWaiters.push(resolve); this.scheduleEmulatorWrite(); }); + + if (timeoutMs !== undefined) { + // Race against timeout to prevent indefinite hang with continuous output + await Promise.race([ + flushPromise, + new Promise((resolve) => setTimeout(resolve, timeoutMs)), + ]); + } else { + await flushPromise; + } } /** @@ -534,7 +554,8 @@ export class Session { }); this.lastAttachedAt = new Date(); - await this.flushEmulatorWrites(); + // Use timeout to prevent indefinite hang with continuous output (e.g., tail -f) + await this.flushEmulatorWrites(ATTACH_FLUSH_TIMEOUT_MS); return this.emulator.getSnapshotAsync(); } diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index 0558be86a4e..b2bdd67610d 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -2,7 +2,6 @@ import { toast } from "@superset/ui/sonner"; import type { FitAddon } from "@xterm/addon-fit"; import type { SearchAddon } from "@xterm/addon-search"; import type { IDisposable, Terminal as XTerm } from "@xterm/xterm"; -import { toast } from "@superset/ui/sonner"; import "@xterm/xterm/css/xterm.css"; import debounce from "lodash/debounce"; import { useCallback, useEffect, useRef, useState } from "react"; @@ -121,7 +120,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { xterm.refresh(0, rows - 1); }); - }, [paneId]); + }, []); useEffect(() => { return () => { From d73c4ebc36c9df8b96370dc8d097b896b6e61289 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Wed, 31 Dec 2025 13:42:52 +0200 Subject: [PATCH 77/98] fix(desktop): restore missing queue byte counters --- apps/desktop/src/main/lib/terminal-host/client.ts | 1 + apps/desktop/src/main/terminal-host/session.ts | 1 + 2 files changed, 2 insertions(+) diff --git a/apps/desktop/src/main/lib/terminal-host/client.ts b/apps/desktop/src/main/lib/terminal-host/client.ts index 51fa67a6f45..a04896a9f83 100644 --- a/apps/desktop/src/main/lib/terminal-host/client.ts +++ b/apps/desktop/src/main/lib/terminal-host/client.ts @@ -152,6 +152,7 @@ export class TerminalHostClient extends EventEmitter { private connectionState = ConnectionState.DISCONNECTED; private disposed = false; private notifyQueue: string[] = []; + private notifyQueueBytes = 0; private notifyDrainArmed = false; // =========================================================================== diff --git a/apps/desktop/src/main/terminal-host/session.ts b/apps/desktop/src/main/terminal-host/session.ts index e8be10ebdad..ca6252196c1 100644 --- a/apps/desktop/src/main/terminal-host/session.ts +++ b/apps/desktop/src/main/terminal-host/session.ts @@ -86,6 +86,7 @@ export class Session { private disposed = false; private subprocessDecoder: PtySubprocessFrameDecoder | null = null; private subprocessStdinQueue: Buffer[] = []; + private subprocessStdinQueuedBytes = 0; private subprocessStdinDrainArmed = false; private emulatorWriteQueue: string[] = []; From 67ffd50b506a489b3d1b90dc7ec3528115496fa8 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Wed, 31 Dec 2025 13:43:02 +0200 Subject: [PATCH 78/98] fix(desktop): avoid terminal refresh while hidden Retry focus redraw until container has non-zero size to avoid WebGL glitches on tab switches. --- .../TabsContent/Terminal/Terminal.tsx | 39 ++++++++++++++----- 1 file changed, 30 insertions(+), 9 deletions(-) diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index b2bdd67610d..b05ae5649f2 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -108,18 +108,39 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const scheduleRedraw = useCallback(() => { if (redrawRafRef.current !== null) return; - redrawRafRef.current = requestAnimationFrame(() => { - redrawRafRef.current = null; + let attempt = 0; + const MAX_REDRAW_ATTEMPTS = 5; - const xterm = xtermRef.current; - if (!xterm) return; + const tick = () => { + redrawRafRef.current = requestAnimationFrame(() => { + redrawRafRef.current = null; - const cols = xterm.cols; - const rows = xterm.rows; - if (cols <= 0 || rows <= 0) return; + const xterm = xtermRef.current; + if (!xterm) return; - xterm.refresh(0, rows - 1); - }); + // Avoid refreshing while the terminal is still hidden/laying out (e.g. tab switch), + // as WebGL renderers can glitch when asked to render into a 0×0 container. + const container = terminalRef.current; + const rect = container?.getBoundingClientRect(); + if ( + rect && + (rect.width < 10 || rect.height < 10) && + attempt < MAX_REDRAW_ATTEMPTS + ) { + attempt += 1; + tick(); + return; + } + + const cols = xterm.cols; + const rows = xterm.rows; + if (cols <= 0 || rows <= 0) return; + + xterm.refresh(0, rows - 1); + }); + }; + + tick(); }, []); useEffect(() => { From 5612ee3ee196644c28e88ddca48b9d27704beef0 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Wed, 31 Dec 2025 14:06:47 +0200 Subject: [PATCH 79/98] fix(desktop): stabilize terminal rendering on macOS - Default xterm renderer to Canvas on macOS to avoid WebGL corruption on tab switches - Remove focus redraw hacks that were amplifying WebGL glitches --- .../TabsContent/Terminal/Terminal.tsx | 57 +------------------ .../TabsContent/Terminal/helpers.ts | 32 +++++++++++ 2 files changed, 33 insertions(+), 56 deletions(-) diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index b05ae5649f2..b12eef68e69 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -102,56 +102,6 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const isFocusedRef = useRef(isFocused); isFocusedRef.current = isFocused; - // Some GPU renderers (notably xterm-webgl) can fail to repaint correctly after - // pane/tab switching until a resize happens. Schedule a lightweight redraw on focus. - const redrawRafRef = useRef(null); - const scheduleRedraw = useCallback(() => { - if (redrawRafRef.current !== null) return; - - let attempt = 0; - const MAX_REDRAW_ATTEMPTS = 5; - - const tick = () => { - redrawRafRef.current = requestAnimationFrame(() => { - redrawRafRef.current = null; - - const xterm = xtermRef.current; - if (!xterm) return; - - // Avoid refreshing while the terminal is still hidden/laying out (e.g. tab switch), - // as WebGL renderers can glitch when asked to render into a 0×0 container. - const container = terminalRef.current; - const rect = container?.getBoundingClientRect(); - if ( - rect && - (rect.width < 10 || rect.height < 10) && - attempt < MAX_REDRAW_ATTEMPTS - ) { - attempt += 1; - tick(); - return; - } - - const cols = xterm.cols; - const rows = xterm.rows; - if (cols <= 0 || rows <= 0) return; - - xterm.refresh(0, rows - 1); - }); - }; - - tick(); - }, []); - - useEffect(() => { - return () => { - if (redrawRafRef.current !== null) { - cancelAnimationFrame(redrawRafRef.current); - redrawRafRef.current = null; - } - }; - }, []); - const paneInitialCommandsRef = useRef(paneInitialCommands); const paneInitialCwdRef = useRef(paneInitialCwd); const clearPaneInitialDataRef = useRef(clearPaneInitialData); @@ -595,13 +545,8 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { useEffect(() => { if (isFocused && xtermRef.current) { xtermRef.current.focus(); - scheduleRedraw(); - void document.fonts?.ready.then(() => { - if (!isFocusedRef.current) return; - scheduleRedraw(); - }); } - }, [isFocused, scheduleRedraw]); + }, [isFocused]); useAppHotkey( "FIND_IN_TERMINAL", diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/helpers.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/helpers.ts index b93770df30e..179fb5d16f7 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/helpers.ts +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/helpers.ts @@ -66,11 +66,34 @@ export type TerminalRenderer = { clearTextureAtlas?: () => void; }; +type PreferredRenderer = TerminalRenderer["kind"] | "auto"; + +function getPreferredRenderer(): PreferredRenderer { + try { + const stored = localStorage.getItem("terminal-renderer"); + if (stored === "webgl" || stored === "canvas" || stored === "dom") { + return stored; + } + } catch { + // ignore + } + + // Default: avoid xterm-webgl on macOS. We've seen repeated corruption/glitching + // when terminals are hidden/shown or switched between panes. + return navigator.userAgent.includes("Macintosh") ? "canvas" : "webgl"; +} + function loadRenderer(xterm: XTerm): TerminalRenderer { let renderer: WebglAddon | CanvasAddon | null = null; let webglAddon: WebglAddon | null = null; let kind: TerminalRenderer["kind"] = "dom"; + const preferred = getPreferredRenderer(); + + if (preferred === "dom") { + return { kind: "dom", dispose: () => {}, clearTextureAtlas: undefined }; + } + const tryLoadCanvas = () => { try { renderer = new CanvasAddon(); @@ -81,6 +104,15 @@ function loadRenderer(xterm: XTerm): TerminalRenderer { } }; + if (preferred === "canvas") { + tryLoadCanvas(); + return { + kind, + dispose: () => renderer?.dispose(), + clearTextureAtlas: undefined, + }; + } + try { webglAddon = new WebglAddon(); From 9b6f1ac6fab48c000db860140e4431615beaf573 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Wed, 31 Dec 2025 14:53:53 +0200 Subject: [PATCH 80/98] fix(desktop): address P0/P1 terminal persistence PR feedback - Fix initialCommands race: use waitForReady() instead of setTimeout(100) - Add PTY ready promise in session to signal when subprocess spawned - Add queue limits for both subprocess stdin and client notify queues - Emit terminalError when writeNoAck drops input due to full queue - Complete detachAllListeners: add disconnect: and error: prefixes - Shutdown orphaned daemon when persistence disabled on app startup --- apps/desktop/src/main/index.ts | 6 ++- .../src/main/lib/terminal-host/client.ts | 31 ++++++++++-- .../src/main/lib/terminal/daemon-manager.ts | 7 ++- apps/desktop/src/main/lib/terminal/index.ts | 30 ++++++++++++ apps/desktop/src/main/lib/terminal/manager.ts | 7 ++- .../desktop/src/main/terminal-host/session.ts | 47 +++++++++++++++++++ .../src/main/terminal-host/terminal-host.ts | 22 ++++++--- 7 files changed, 136 insertions(+), 14 deletions(-) diff --git a/apps/desktop/src/main/index.ts b/apps/desktop/src/main/index.ts index 6afdda3832b..b485b5af0f2 100644 --- a/apps/desktop/src/main/index.ts +++ b/apps/desktop/src/main/index.ts @@ -13,7 +13,7 @@ import { initAppState } from "./lib/app-state"; import { authService, handleAuthDeepLink, isAuthDeepLink } from "./lib/auth"; import { setupAutoUpdater } from "./lib/auto-updater"; import { localDb } from "./lib/local-db"; -import { terminalManager } from "./lib/terminal"; +import { shutdownOrphanedDaemon, terminalManager } from "./lib/terminal"; import { MainWindow } from "./windows/main"; // Initialize local SQLite database (runs migrations + legacy data migration on import) @@ -221,6 +221,10 @@ if (!gotTheLock) { await app.whenReady(); await initAppState(); + + // Cleanup any orphaned daemon if persistence is now disabled + await shutdownOrphanedDaemon(); + await authService.initialize(); try { diff --git a/apps/desktop/src/main/lib/terminal-host/client.ts b/apps/desktop/src/main/lib/terminal-host/client.ts index a04896a9f83..83490909734 100644 --- a/apps/desktop/src/main/lib/terminal-host/client.ts +++ b/apps/desktop/src/main/lib/terminal-host/client.ts @@ -74,6 +74,9 @@ const SPAWN_WAIT_MS = 2000; const REQUEST_TIMEOUT_MS = 30000; const SPAWN_LOCK_TIMEOUT_MS = 10000; // Max time to hold spawn lock +// Queue limits +const MAX_NOTIFY_QUEUE_BYTES = 2_000_000; // 2MB cap to prevent OOM + // ============================================================================= // NDJSON Parser // ============================================================================= @@ -641,18 +644,26 @@ export class TerminalHostClient extends EventEmitter { * Used for high-frequency messages like terminal input, where request/response * overhead can cause timeouts under load and drop data. The daemon may still * send a response for compatibility, but this client will ignore it. + * + * Returns false if queue is full (caller should handle). */ - private sendNotification(type: string, payload: unknown): void { - if (!this.socket) return; + private sendNotification(type: string, payload: unknown): boolean { + if (!this.socket) return false; const id = `notify_${++this.requestCounter}`; const message = `${JSON.stringify({ id, type, payload })}\n`; + const messageBytes = Buffer.byteLength(message, "utf8"); + + // Check queue limit to prevent OOM under backpressure + if (this.notifyQueueBytes + messageBytes > MAX_NOTIFY_QUEUE_BYTES) { + return false; + } // If we're already backpressured, just queue. if (this.notifyDrainArmed || this.notifyQueue.length > 0) { this.notifyQueue.push(message); - this.notifyQueueBytes += Buffer.byteLength(message, "utf8"); - return; + this.notifyQueueBytes += messageBytes; + return true; } const canWrite = this.socket.write(message); @@ -661,6 +672,7 @@ export class TerminalHostClient extends EventEmitter { // subsequent notifications we enqueue. this.notifyDrainArmed = true; } + return true; } private flushNotifyQueue(): void { @@ -715,7 +727,16 @@ export class TerminalHostClient extends EventEmitter { writeNoAck(request: WriteRequest): void { void this.ensureConnected() .then(() => { - this.sendNotification("write", request); + const sent = this.sendNotification("write", request); + if (!sent) { + // Queue full - notify the session so it can surface the error to the user + this.emit( + "terminalError", + request.sessionId, + "Write queue full - input dropped", + "QUEUE_FULL", + ); + } }) .catch((error) => { this.emit( diff --git a/apps/desktop/src/main/lib/terminal/daemon-manager.ts b/apps/desktop/src/main/lib/terminal/daemon-manager.ts index b32eeff4213..bcb22886359 100644 --- a/apps/desktop/src/main/lib/terminal/daemon-manager.ts +++ b/apps/desktop/src/main/lib/terminal/daemon-manager.ts @@ -458,7 +458,12 @@ export class DaemonTerminalManager extends EventEmitter { detachAllListeners(): void { for (const event of this.eventNames()) { const name = String(event); - if (name.startsWith("data:") || name.startsWith("exit:")) { + if ( + name.startsWith("data:") || + name.startsWith("exit:") || + name.startsWith("disconnect:") || + name.startsWith("error:") + ) { this.removeAllListeners(event); } } diff --git a/apps/desktop/src/main/lib/terminal/index.ts b/apps/desktop/src/main/lib/terminal/index.ts index 8d71a4fcc32..2b564a4a53f 100644 --- a/apps/desktop/src/main/lib/terminal/index.ts +++ b/apps/desktop/src/main/lib/terminal/index.ts @@ -1,5 +1,9 @@ import { settings } from "@superset/local-db"; import { localDb } from "main/lib/local-db"; +import { + disposeTerminalHostClient, + getTerminalHostClient, +} from "main/lib/terminal-host/client"; import { DaemonTerminalManager, getDaemonTerminalManager, @@ -75,3 +79,29 @@ export function getActiveTerminalManager(): } return terminalManager; } + +/** + * Shutdown any orphaned daemon process. + * Should be called on app startup when daemon mode is disabled to clean up + * any daemon left running from a previous session with persistence enabled. + */ +export async function shutdownOrphanedDaemon(): Promise { + if (isDaemonModeEnabled()) { + // Daemon mode is enabled, don't shutdown + return; + } + + try { + const client = getTerminalHostClient(); + // Try to connect and shutdown - if no daemon is running, this will fail + // which is fine (nothing to clean up) + await client.shutdown({ killSessions: true }); + console.log("[TerminalManager] Shutdown orphaned daemon successfully"); + } catch { + // No daemon running or failed to connect - this is expected + console.log("[TerminalManager] No orphaned daemon to shutdown"); + } finally { + // Always dispose the client to clean up any partial state + disposeTerminalHostClient(); + } +} diff --git a/apps/desktop/src/main/lib/terminal/manager.ts b/apps/desktop/src/main/lib/terminal/manager.ts index dc1aeb34563..e85096293ca 100644 --- a/apps/desktop/src/main/lib/terminal/manager.ts +++ b/apps/desktop/src/main/lib/terminal/manager.ts @@ -411,7 +411,12 @@ export class TerminalManager extends EventEmitter { detachAllListeners(): void { for (const event of this.eventNames()) { const name = String(event); - if (name.startsWith("data:") || name.startsWith("exit:")) { + if ( + name.startsWith("data:") || + name.startsWith("exit:") || + name.startsWith("disconnect:") || + name.startsWith("error:") + ) { this.removeAllListeners(event); } } diff --git a/apps/desktop/src/main/terminal-host/session.ts b/apps/desktop/src/main/terminal-host/session.ts index ca6252196c1..a3db6618843 100644 --- a/apps/desktop/src/main/terminal-host/session.ts +++ b/apps/desktop/src/main/terminal-host/session.ts @@ -37,6 +37,13 @@ import { */ const ATTACH_FLUSH_TIMEOUT_MS = 500; +/** + * Maximum bytes allowed in subprocess stdin queue. + * Prevents OOM if subprocess stdin is backpressured (e.g., slow PTY consumer). + * 2MB is generous - typical large paste is ~50KB. + */ +const MAX_SUBPROCESS_STDIN_QUEUE_BYTES = 2_000_000; + // ============================================================================= // Types // ============================================================================= @@ -89,6 +96,10 @@ export class Session { private subprocessStdinQueuedBytes = 0; private subprocessStdinDrainArmed = false; + // Promise that resolves when PTY is ready to accept writes + private ptyReadyPromise: Promise; + private ptyReadyResolve: (() => void) | null = null; + private emulatorWriteQueue: string[] = []; private emulatorWriteQueuedBytes = 0; private emulatorWriteScheduled = false; @@ -110,6 +121,11 @@ export class Session { this.createdAt = new Date(); this.lastAttachedAt = new Date(); + // Initialize PTY ready promise + this.ptyReadyPromise = new Promise((resolve) => { + this.ptyReadyResolve = resolve; + }); + // Create headless emulator this.emulator = new HeadlessEmulator({ cols: options.cols, @@ -251,6 +267,11 @@ export class Session { console.log( `[Session ${this.sessionId}] PTY spawned with pid ${this.ptyPid}`, ); + // Resolve the ready promise so callers can await PTY readiness + if (this.ptyReadyResolve) { + this.ptyReadyResolve(); + this.ptyReadyResolve = null; + } break; case PtySubprocessIpcType.Data: { @@ -375,6 +396,24 @@ export class Session { if (!this.subprocess?.stdin || this.disposed) return false; const payloadBuffer = payload ?? Buffer.alloc(0); + const frameSize = 5 + payloadBuffer.length; // 5-byte header + payload + + // Check queue limit to prevent OOM under backpressure + if ( + this.subprocessStdinQueuedBytes + frameSize > + MAX_SUBPROCESS_STDIN_QUEUE_BYTES + ) { + console.warn( + `[Session ${this.sessionId}] stdin queue full (${this.subprocessStdinQueuedBytes} bytes), dropping frame`, + ); + this.broadcastEvent("error", { + type: "error", + error: "Write queue full - input dropped", + code: "WRITE_QUEUE_FULL", + } satisfies TerminalErrorEvent); + return false; + } + const header = createFrameHeader(type, payloadBuffer.length); this.subprocessStdinQueue.push(header); @@ -534,6 +573,14 @@ export class Session { return this.subprocess !== null && this.exitCode === null; } + /** + * Wait for PTY to be ready to accept writes. + * Returns immediately if already ready, or waits for Spawned event. + */ + waitForReady(): Promise { + return this.ptyReadyPromise; + } + /** * Get number of attached clients */ diff --git a/apps/desktop/src/main/terminal-host/terminal-host.ts b/apps/desktop/src/main/terminal-host/terminal-host.ts index b3e9f793fe0..40d5e0f9494 100644 --- a/apps/desktop/src/main/terminal-host/terminal-host.ts +++ b/apps/desktop/src/main/terminal-host/terminal-host.ts @@ -66,15 +66,25 @@ export class TerminalHost { env: request.env, }); - // Run initial commands if provided + // Run initial commands if provided (after PTY is ready) if (request.initialCommands && request.initialCommands.length > 0) { - // Wait a bit for shell to initialize, then run commands - setTimeout(() => { + const initialCommands = request.initialCommands; + // Wait for PTY to be ready, then run commands + session.waitForReady().then(() => { + // Double-check session is still alive after await if (session?.isAlive) { - const cmdString = `${request.initialCommands?.join(" && ")}\n`; - session.write(cmdString); + try { + const cmdString = `${initialCommands.join(" && ")}\n`; + session.write(cmdString); + } catch (error) { + // Log but don't crash - initialCommands are best-effort + console.error( + `[TerminalHost] Failed to run initial commands for ${sessionId}:`, + error, + ); + } } - }, 100); + }); } this.sessions.set(sessionId, session); From 1095ad006c18034cb969ad446a2dd23fa14c1390 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Wed, 31 Dec 2025 15:23:01 +0200 Subject: [PATCH 81/98] refactor(desktop): improve code quality and organization - Extract magic number to SESSION_CLEANUP_DELAY_MS constant in daemon-manager - Move planning docs to docs/ directory - Extract useTerminalConnection hook to encapsulate tRPC mutations and refs - Refactor Terminal.tsx to use the new hook, reducing component complexity --- .../src/main/lib/terminal/daemon-manager.ts | 9 ++- .../TabsContent/Terminal/Terminal.tsx | 36 +++++----- .../TabsContent/Terminal/hooks/index.ts | 2 + .../Terminal/hooks/useTerminalConnection.ts | 67 +++++++++++++++++++ ...rminal-host-daemon-terminal-persistence.md | 0 .../LARGE_PASTE_HANG_ANALYSIS.md | 0 6 files changed, 92 insertions(+), 22 deletions(-) create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/hooks/index.ts create mode 100644 apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/hooks/useTerminalConnection.ts rename 20251229-1858-terminal-host-daemon-terminal-persistence.md => docs/20251229-1858-terminal-host-daemon-terminal-persistence.md (100%) rename LARGE_PASTE_HANG_ANALYSIS.md => docs/LARGE_PASTE_HANG_ANALYSIS.md (100%) diff --git a/apps/desktop/src/main/lib/terminal/daemon-manager.ts b/apps/desktop/src/main/lib/terminal/daemon-manager.ts index bcb22886359..1bf680c0255 100644 --- a/apps/desktop/src/main/lib/terminal/daemon-manager.ts +++ b/apps/desktop/src/main/lib/terminal/daemon-manager.ts @@ -20,6 +20,13 @@ import { buildTerminalEnv, getDefaultShell } from "./env"; import { portManager } from "./port-manager"; import type { CreateSessionParams, SessionResult } from "./types"; +// ============================================================================= +// Constants +// ============================================================================= + +/** Delay before removing session from local cache after exit event */ +const SESSION_CLEANUP_DELAY_MS = 5000; + // ============================================================================= // Types // ============================================================================= @@ -93,7 +100,7 @@ export class DaemonTerminalManager extends EventEmitter { // Clean up session after delay setTimeout(() => { this.sessions.delete(paneId); - }, 5000); + }, SESSION_CLEANUP_DELAY_MS); }, ); diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index b12eef68e69..bf717b987bf 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -22,6 +22,7 @@ import { setupResizeHandlers, type TerminalRendererRef, } from "./helpers"; +import { useTerminalConnection } from "./hooks"; import { parseCwd } from "./parseCwd"; import { TerminalSearch } from "./TerminalSearch"; import type { TerminalProps, TerminalStreamEvent } from "./types"; @@ -68,7 +69,6 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const [isSearchOpen, setIsSearchOpen] = useState(false); const [terminalCwd, setTerminalCwd] = useState(null); const [cwdConfirmed, setCwdConfirmed] = useState(false); - const [connectionError, setConnectionError] = useState(null); const setFocusedPane = useTabsStore((s) => s.setFocusedPane); const setTabAutoTitle = useTabsStore((s) => s.setTabAutoTitle); const updatePaneCwd = useTabsStore((s) => s.updatePaneCwd); @@ -76,6 +76,20 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const addFileViewerPane = useTabsStore((s) => s.addFileViewerPane); const terminalTheme = useTerminalTheme(); + // Terminal connection state and mutations (extracted to hook for cleaner code) + const { + connectionError, + setConnectionError, + workspaceCwd, + refs: { + createOrAttach: createOrAttachRef, + write: writeRef, + resize: resizeRef, + detach: detachRef, + clearScrollback: clearScrollbackRef, + }, + } = useTerminalConnection({ workspaceId }); + // Ref for initial theme to avoid recreating terminal on theme change const initialThemeRef = useRef(terminalTheme); @@ -109,9 +123,6 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { paneInitialCwdRef.current = paneInitialCwd; clearPaneInitialDataRef.current = clearPaneInitialData; - const { data: workspaceCwd } = - trpc.terminal.getWorkspaceCwd.useQuery(workspaceId); - // Use ref for workspaceCwd to avoid terminal recreation when query loads // (changing from undefined→string triggers useEffect, causing xterm errors) const workspaceCwdRef = useRef(workspaceCwd); @@ -216,23 +227,6 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const updateCwdRef = useRef(updateCwdFromData); updateCwdRef.current = updateCwdFromData; - const createOrAttachMutation = trpc.terminal.createOrAttach.useMutation(); - const writeMutation = trpc.terminal.write.useMutation(); - const resizeMutation = trpc.terminal.resize.useMutation(); - const detachMutation = trpc.terminal.detach.useMutation(); - const clearScrollbackMutation = trpc.terminal.clearScrollback.useMutation(); - - const createOrAttachRef = useRef(createOrAttachMutation.mutate); - const writeRef = useRef(writeMutation.mutate); - const resizeRef = useRef(resizeMutation.mutate); - const detachRef = useRef(detachMutation.mutate); - const clearScrollbackRef = useRef(clearScrollbackMutation.mutate); - createOrAttachRef.current = createOrAttachMutation.mutate; - writeRef.current = writeMutation.mutate; - resizeRef.current = resizeMutation.mutate; - detachRef.current = detachMutation.mutate; - clearScrollbackRef.current = clearScrollbackMutation.mutate; - const registerClearCallbackRef = useRef( useTerminalCallbacksStore.getState().registerClearCallback, ); diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/hooks/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/hooks/index.ts new file mode 100644 index 00000000000..7b3a4dcbde0 --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/hooks/index.ts @@ -0,0 +1,2 @@ +export { useTerminalConnection } from "./useTerminalConnection"; +export type { UseTerminalConnectionOptions } from "./useTerminalConnection"; diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/hooks/useTerminalConnection.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/hooks/useTerminalConnection.ts new file mode 100644 index 00000000000..f98bd58276f --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/hooks/useTerminalConnection.ts @@ -0,0 +1,67 @@ +import { useRef, useState } from "react"; +import { trpc } from "renderer/lib/trpc"; + +export interface UseTerminalConnectionOptions { + workspaceId: string; +} + +/** + * Hook to manage terminal connection state and mutations. + * + * Encapsulates: + * - tRPC mutations (createOrAttach, write, resize, detach, clearScrollback) + * - Stable refs to mutation functions (to avoid re-renders) + * - Connection error state + * - Workspace CWD query + * + * NOTE: Stream subscription is intentionally NOT included here because it needs + * direct access to xterm refs for event handling. Keep that in the component. + */ +export function useTerminalConnection({ + workspaceId, +}: UseTerminalConnectionOptions) { + const [connectionError, setConnectionError] = useState(null); + + // tRPC mutations + const createOrAttachMutation = trpc.terminal.createOrAttach.useMutation(); + const writeMutation = trpc.terminal.write.useMutation(); + const resizeMutation = trpc.terminal.resize.useMutation(); + const detachMutation = trpc.terminal.detach.useMutation(); + const clearScrollbackMutation = trpc.terminal.clearScrollback.useMutation(); + + // Query for workspace cwd + const { data: workspaceCwd } = + trpc.terminal.getWorkspaceCwd.useQuery(workspaceId); + + // Stable refs to mutation functions - these don't change identity on re-render + const createOrAttachRef = useRef(createOrAttachMutation.mutate); + const writeRef = useRef(writeMutation.mutate); + const resizeRef = useRef(resizeMutation.mutate); + const detachRef = useRef(detachMutation.mutate); + const clearScrollbackRef = useRef(clearScrollbackMutation.mutate); + + // Keep refs up to date + createOrAttachRef.current = createOrAttachMutation.mutate; + writeRef.current = writeMutation.mutate; + resizeRef.current = resizeMutation.mutate; + detachRef.current = detachMutation.mutate; + clearScrollbackRef.current = clearScrollbackMutation.mutate; + + return { + // Connection error state + connectionError, + setConnectionError, + + // Workspace CWD from query + workspaceCwd, + + // Stable refs to mutation functions (use these in effects/callbacks) + refs: { + createOrAttach: createOrAttachRef, + write: writeRef, + resize: resizeRef, + detach: detachRef, + clearScrollback: clearScrollbackRef, + }, + }; +} diff --git a/20251229-1858-terminal-host-daemon-terminal-persistence.md b/docs/20251229-1858-terminal-host-daemon-terminal-persistence.md similarity index 100% rename from 20251229-1858-terminal-host-daemon-terminal-persistence.md rename to docs/20251229-1858-terminal-host-daemon-terminal-persistence.md diff --git a/LARGE_PASTE_HANG_ANALYSIS.md b/docs/LARGE_PASTE_HANG_ANALYSIS.md similarity index 100% rename from LARGE_PASTE_HANG_ANALYSIS.md rename to docs/LARGE_PASTE_HANG_ANALYSIS.md From ca368d442e1a74a720c9161ca75ae7427eee26f3 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Wed, 31 Dec 2025 17:16:30 +0200 Subject: [PATCH 82/98] fix(desktop): avoid spawning daemon during orphan cleanup when persistence disabled Previously, shutdownOrphanedDaemon() would call client.shutdown() which internally calls ensureConnected(), spawning a new daemon just to immediately shut it down. This happened on every app startup when terminal persistence was disabled. Added tryConnectAndAuthenticate() and shutdownIfRunning() methods to TerminalHostClient that only attempt cleanup if a daemon is already running, avoiding wasteful spawn+kill cycles. --- .../src/main/lib/terminal-host/client.ts | 59 +++++++++++++++++++ apps/desktop/src/main/lib/terminal/index.ts | 24 +++++--- 2 files changed, 76 insertions(+), 7 deletions(-) diff --git a/apps/desktop/src/main/lib/terminal-host/client.ts b/apps/desktop/src/main/lib/terminal-host/client.ts index 83490909734..1096d7c2ebb 100644 --- a/apps/desktop/src/main/lib/terminal-host/client.ts +++ b/apps/desktop/src/main/lib/terminal-host/client.ts @@ -244,6 +244,44 @@ export class TerminalHostClient extends EventEmitter { } } + /** + * Try to connect and authenticate to an existing daemon without spawning. + * Returns true if successfully connected and authenticated, false if no daemon running. + * This is useful for cleanup operations that should only act on existing daemons. + */ + async tryConnectAndAuthenticate(): Promise { + // Already connected and authenticated + if ( + this.connectionState === ConnectionState.CONNECTED && + this.socket && + this.authenticated + ) { + return true; + } + + // Don't interfere with an in-progress connection + if (this.connectionState === ConnectionState.CONNECTING) { + return false; + } + + this.connectionState = ConnectionState.CONNECTING; + + try { + const connected = await this.tryConnect(); + if (!connected) { + this.connectionState = ConnectionState.DISCONNECTED; + return false; + } + + await this.authenticate(); + this.connectionState = ConnectionState.CONNECTED; + return true; + } catch { + this.connectionState = ConnectionState.DISCONNECTED; + return false; + } + } + /** * Try to connect to the daemon socket. * Returns true if connected, false if daemon not running. @@ -818,6 +856,27 @@ export class TerminalHostClient extends EventEmitter { return response; } + /** + * Shutdown the daemon if it's currently running, without spawning a new one. + * Returns true if daemon was running and shutdown was sent, false if no daemon was running. + * This is useful for cleanup operations that should only affect existing daemons. + */ + async shutdownIfRunning( + request: ShutdownRequest = {}, + ): Promise<{ wasRunning: boolean }> { + const connected = await this.tryConnectAndAuthenticate(); + if (!connected) { + return { wasRunning: false }; + } + + try { + await this.sendRequest("shutdown", request); + } finally { + this.disconnect(); + } + return { wasRunning: true }; + } + /** * Disconnect from daemon (but don't stop it) */ diff --git a/apps/desktop/src/main/lib/terminal/index.ts b/apps/desktop/src/main/lib/terminal/index.ts index 2b564a4a53f..ef80cfb8e00 100644 --- a/apps/desktop/src/main/lib/terminal/index.ts +++ b/apps/desktop/src/main/lib/terminal/index.ts @@ -84,6 +84,8 @@ export function getActiveTerminalManager(): * Shutdown any orphaned daemon process. * Should be called on app startup when daemon mode is disabled to clean up * any daemon left running from a previous session with persistence enabled. + * + * Uses shutdownIfRunning() to avoid spawning a new daemon just to shut it down. */ export async function shutdownOrphanedDaemon(): Promise { if (isDaemonModeEnabled()) { @@ -93,13 +95,21 @@ export async function shutdownOrphanedDaemon(): Promise { try { const client = getTerminalHostClient(); - // Try to connect and shutdown - if no daemon is running, this will fail - // which is fine (nothing to clean up) - await client.shutdown({ killSessions: true }); - console.log("[TerminalManager] Shutdown orphaned daemon successfully"); - } catch { - // No daemon running or failed to connect - this is expected - console.log("[TerminalManager] No orphaned daemon to shutdown"); + // Use shutdownIfRunning to avoid spawning a daemon if none exists + const { wasRunning } = await client.shutdownIfRunning({ + killSessions: true, + }); + if (wasRunning) { + console.log("[TerminalManager] Shutdown orphaned daemon successfully"); + } else { + console.log("[TerminalManager] No orphaned daemon to shutdown"); + } + } catch (error) { + // Unexpected error during shutdown attempt + console.warn( + "[TerminalManager] Error during orphan daemon cleanup:", + error, + ); } finally { // Always dispose the client to clean up any partial state disposeTerminalHostClient(); From 9349f9d3c13e8025df7713aa1633111739914708 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Thu, 1 Jan 2026 13:02:32 +0200 Subject: [PATCH 83/98] docs(desktop): add terminal reattach/rendering research log --- .../TERMINAL_RENDERING_REATTACH_RESEARCH.md | 253 ++++++++++++++++++ 1 file changed, 253 insertions(+) create mode 100644 apps/desktop/docs/TERMINAL_RENDERING_REATTACH_RESEARCH.md diff --git a/apps/desktop/docs/TERMINAL_RENDERING_REATTACH_RESEARCH.md b/apps/desktop/docs/TERMINAL_RENDERING_REATTACH_RESEARCH.md new file mode 100644 index 00000000000..624c9871b0e --- /dev/null +++ b/apps/desktop/docs/TERMINAL_RENDERING_REATTACH_RESEARCH.md @@ -0,0 +1,253 @@ +# Terminal Rendering + Reattach Research Log (Scratchpad) + +This doc is a living scratchpad for understanding and fixing two related UX problems in Superset Desktop terminals: + +1. **TUI corruption after switching away and back** (e.g. OpenCode/vim-like apps). +2. **Jittery resizing** (especially noticeable on macOS with Canvas rendering). + +It’s written for engineers who **do not have the original investigation context**. + +--- + +## TL;DR + +- **Corruption on tab switch** is usually not “random rendering”; it’s a *reattach correctness* problem: TUIs emit **incremental** escape sequences that assume a precise current screen/mode/cursor state. If we detach/unmount the renderer and later rebuild it from a snapshot, any tiny mismatch becomes visible as corruption when the TUI continues sending incremental updates. +- **Resize jitter** is mostly a throughput problem: resizing causes frequent PTY resizes + full-screen repaints from TUIs, and xterm.js processes input in **time-sliced batches** to avoid blocking the UI thread. Under heavy output, it can’t stay at 60fps without aggressive resize coalescing and/or a GPU-first renderer. + +--- + +## Current Architecture (as implemented in this repo) + +High-level data flow: + +``` +Renderer (xterm.js in React) + ↕ TRPC stream/write calls +Electron main + ↕ Unix socket IPC +terminal-host daemon (Node.js) + ↕ stdin/stdout IPC +per-session PTY subprocess (Node.js + node-pty) + ↕ PTY +shell / TUI (opencode, vim, etc.) +``` + +Key concepts: + +- **Daemon owns sessions** so terminals persist across app restarts. +- **Headless emulator** in daemon maintains a model of the terminal state (screen + modes) and produces a snapshot for reattach. +- **Renderer is recreated** on React mount; on “switch away” we may detach/unmount and later reattach to the daemon session. + +Related docs/code: +- Large paste reliability notes: `LARGE_PASTE_HANG_ANALYSIS.md` (repo root). +- Headless emulator: `apps/desktop/src/main/lib/terminal-host/headless-emulator.ts`. +- Renderer creation / GPU renderer selection: `apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/helpers.ts`. + +Related problem area: +- **Large paste reliability** was previously a major source of hangs/dropped input. The current direction is per-PTY subprocess isolation + explicit backpressure handling (treating `EAGAIN` as retry/backoff instead of “drop”). See `LARGE_PASTE_HANG_ANALYSIS.md` for details. + +--- + +## Symptom 1: TUI corruption after switching away and back + +### What we observe + +- Happens when switching away from a terminal and then returning to it. +- Not necessarily tied to full app restart. +- Affects TUIs that are screen-oriented and repaint frequently (OpenCode is a common reproduction). + +### Why this is hard (fundamental) + +Most TUIs do **incremental drawing**: +- move cursor +- rewrite a few cells +- update a small region +- assume a specific active buffer (normal vs alternate screen) +- assume a specific mode state (cursor keys, mouse tracking, bracketed paste, etc.) + +If we “reattach” by creating a new xterm renderer and restoring the screen from a snapshot, then: +- if the snapshot is taken **mid-update** (or we rehydrate in the wrong order), +- or if any output is missed/duplicated around the detach boundary, +- or if modes differ slightly between headless model and the new renderer, + +…the next incremental updates from the TUI apply relative to the wrong baseline and appear as corruption. + +This is not unique to Superset: xterm.js itself historically describes the only reliable way to “set” terminal state via public API as **replaying the commands that produced it**, and points toward headless/serialization as a reconnection primitive. + +### Key point: persistence vs rendering + +- **Persistence feature** increases exposure because it introduces **detach/attach** as a common lifecycle event. +- The corruption itself is typically a combination of: + - **reattach semantics** (state mismatch), and sometimes + - **renderer quirks** (WebGL issues on macOS, hidden/visible transitions). + +If you never detach/unmount the renderer on tab switch, you remove the most failure-prone step. + +--- + +## Symptom 2: Resize feels jittery + +### What we observe + +- Resizing panes feels less “buttery” than modern terminals like Warp. +- Jitter is especially noticeable with TUI output in flight and when using CPU rendering (Canvas). + +### Why this happens (fundamental) + +Resizing is expensive in a terminal for two reasons: + +1) **Logical resize triggers PTY resize → TUIs repaint** +- When cols/rows change, the PTY receives a resize (SIGWINCH on Unix-like systems). +- TUIs often repaint large regions or the entire screen in response. +- That yields a burst of output (escape-sequence heavy) right while we are doing layout work. + +2) **xterm.js has limited throughput and is intentionally time-sliced** +- `term.write()` is non-blocking; xterm buffers data and processes it in chunks designed to stay under ~one frame budget (≈16ms) to avoid blocking the UI thread. +- When producers are “too fast”, the terminal gets sluggish and may stop responding to input; hence flow control/backpressure is required in high-throughput pipelines. + +So “resize jitter” often means: **we’re asking xterm to keep up with heavy output + frequent resizes** faster than it can process/render. + +### Why Warp feels smooth + +Warp’s architecture is built around a GPU-first renderer (Metal on macOS) and careful minimization of bottlenecks (PTY read/parse, render, scroll). + +That doesn’t automatically mean “WebGL fixes it” inside xterm.js; in practice `xterm-webgl` has had regressions and rendering issues, and on macOS we’ve repeatedly seen corruption when hiding/showing terminals or switching panes. + +--- + +## Renderer notes (macOS) + +### WebGL vs Canvas vs DOM + +- **WebGL**: best performance potential, but can be fragile (glyph atlas / context loss / hidden-canvas transitions). +- **Canvas**: more stable but more CPU-bound (often leads to jitter under load). +- **DOM**: typically slowest, mostly a fallback. + +xterm.js’ core rendering and addons list includes WebGL and Serialize, but they come with tradeoffs. + +Current repo approach (as of recent fixes): +- Default to **Canvas on macOS** to avoid WebGL corruption on tab switching. +- Allow overriding for testing via localStorage: + - `localStorage.setItem('terminal-renderer', 'webgl' | 'canvas' | 'dom')` + - `localStorage.removeItem('terminal-renderer')` to revert to default. + +--- + +## Why switching away/back is specifically triggering corruption + +When a terminal is unmounted/hidden and later recreated: + +- A **new xterm instance** is created. +- We restore from daemon snapshot (serialize output + “rehydrate sequences”). +- The TUI process never stopped; it keeps emitting updates based on its own internal model. + +The critical window is the detach/attach boundary: + +- If the daemon snapshot isn’t taken at a stable boundary (e.g. “frame complete”), +- or if output continues while we are capturing/restoring and we apply it in a different order, +- or if we rehydrate modes (alternate screen, cursor modes, mouse tracking, bracketed paste) in the wrong sequence, + +…the restored xterm state can be “close enough” for plain shells but not for screen-oriented TUIs. + +This aligns with how terminal state restoration is generally discussed in the ecosystem: the most robust systems keep an authoritative server-side screen model and redraw it to clients on attach (tmux-style). + +--- + +## Design Options (out-of-the-box) + +These are “shape of the system” ideas, not small bug fixes. + +### Option A — Don’t detach on tab switch (keep renderer alive) + +Make tab switching purely a show/hide operation: +- keep the xterm instance alive in memory (and ideally attached to the session) +- avoid rehydrate/snapshot on routine navigation + +Pros: +- Removes the core “reattach baseline mismatch” failure mode. +- Likely the fastest path to eliminating OpenCode corruption on switch-back. + +Cons: +- More memory/CPU if many terminals are open. +- Might need policies (e.g. keep last N terminals “hot”; hibernate older ones). + +### Option B — tmux-style server authoritative screen diff + +Make the daemon the “truth” for terminal UI: +- daemon maintains the full screen grid and cursor/mode state +- on attach: send full state (grid + modes) +- during run: send diffs/updates to clients + +Pros: +- Reattach becomes robust (clients can come/go without state mismatch). +- Matches how tmux achieves persistence. + +Cons: +- Significant engineering effort: you’re effectively building a multiplexer protocol. +- Must ensure your screen model matches what the client renders (font metrics, wrapping, etc.). + +### Option C — Use tmux/screen as the persistence layer + +Put tmux behind the scenes: +- daemon starts tmux, each terminal is a tmux pane +- renderer is a normal terminal client + +Pros: +- tmux already solved “detach/reattach with a stable screen model”. +- Avoids inventing a custom diff protocol. + +Cons: +- External dependency and platform concerns. +- Integrating with our UX/workspace model could be awkward. + +### Option D — Per-terminal WebContents / BrowserView “view host” + +Instead of recreating terminals in React, host each terminal view in a persistent Electron view: +- switch visibility at the compositor level + +Pros: +- Avoid rehydrate for navigation. +- Strong isolation between terminal views. + +Cons: +- More complex Electron lifecycle; resource usage can rise. + +### Option E — Own the renderer (Warp/WezTerm direction) + +Long-term: a native/GPU-first terminal renderer and more control over resizing. + +Pros: +- Best chance at “buttery” resize + fewer corruption classes. +- Warp shows the ceiling when you own the rendering pipeline. + +Cons: +- Very large scope; essentially building a terminal engine inside the app. + +--- + +## Practical experiment ideas (near-term) + +These are experiments that can confirm root causes quickly: + +1) **Keep renderer alive on tab switch** (no detach/reattach) and see if OpenCode corruption disappears. +2) **Coalesce resizes**: + - “visual resize” during drag (scale), only “logical resize” (PTY cols/rows) on settle. + - lower-frequency resize dispatch (debounce/throttle) to reduce repaint storms. +3) **Force TUI redraw on attach**: + - e.g. synthetic resize nudge or sending a reset sequence (careful: many resets have side effects). + - This is a mitigation, not a root fix. +4) **Instrument attach boundary**: + - capture sequence numbers: last byte processed in emulator vs first byte delivered to client after attach + - detect and log gaps/duplication + - confirm mode parity (alternate screen, bracketed paste, mouse modes) + +--- + +## Reference links + +- xterm.js flow control guide (buffering, time-sliced processing, throughput limits): https://xtermjs.org/docs/guides/flowcontrol/ +- xterm.js issue: “Support saving and restoring of terminal state” (headless + “replay commands” framing): https://github.com/xtermjs/xterm.js/issues/595 +- xterm.js supported terminal sequences (what is/ isn’t supported): https://xtermjs.org/docs/api/vtfeatures/ +- xterm.js WebGL regression example: https://github.com/xtermjs/xterm.js/issues/4665 +- tmux client/server architecture overview (high level): https://www.augmentcode.com/open-source/tmux/tmux +- Warp “How Warp Works” (GPU-first and performance bottlenecks): https://www.warp.dev/blog/how-warp-works From 0991c79a2e3b06484dde530fd64720c0314f817e Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Thu, 1 Jan 2026 14:04:14 +0200 Subject: [PATCH 84/98] chore(desktop): improve code hygiene for PR review - Reframe PtyWriteQueue docstring to accurately describe limitations (reduces event loop starvation, does not prevent blocking) - Rename prototype/ to __tests__/ for conventional test organization --- .../headless-roundtrip.test.ts | 0 .../src/main/lib/terminal/pty-write-queue.ts | 25 +++++++++++++------ 2 files changed, 17 insertions(+), 8 deletions(-) rename apps/desktop/src/main/lib/terminal-host/{prototype => __tests__}/headless-roundtrip.test.ts (100%) diff --git a/apps/desktop/src/main/lib/terminal-host/prototype/headless-roundtrip.test.ts b/apps/desktop/src/main/lib/terminal-host/__tests__/headless-roundtrip.test.ts similarity index 100% rename from apps/desktop/src/main/lib/terminal-host/prototype/headless-roundtrip.test.ts rename to apps/desktop/src/main/lib/terminal-host/__tests__/headless-roundtrip.test.ts diff --git a/apps/desktop/src/main/lib/terminal/pty-write-queue.ts b/apps/desktop/src/main/lib/terminal/pty-write-queue.ts index f0e35c90a9b..e0e4131bb15 100644 --- a/apps/desktop/src/main/lib/terminal/pty-write-queue.ts +++ b/apps/desktop/src/main/lib/terminal/pty-write-queue.ts @@ -1,18 +1,27 @@ import type { IPty } from "node-pty"; /** - * A write queue for PTY that prevents blocking the event loop. + * A write queue for PTY that reduces event loop starvation. * - * Problem: node-pty's write() is synchronous and blocks when the kernel's - * PTY buffer fills up (~4KB on macOS). Large pastes (e.g., 16KB+) can freeze - * the entire daemon, causing all requests to timeout. + * Context: This is used in the non-daemon (in-process) terminal mode. + * For daemon mode, the real backpressure handling (EAGAIN retry with backoff) + * is implemented in pty-subprocess.ts. * - * Solution: Queue writes and process them in chunks, yielding to the event - * loop between chunks. This keeps the daemon responsive while still delivering - * all data to the PTY. + * Problem: node-pty's write() is synchronous. While the kernel buffer rarely + * fills completely, processing large pastes in a single event loop tick can + * starve other work (IPC handlers, UI updates). + * + * Solution: Queue writes and process them in small chunks, yielding to the + * event loop between chunks via setTimeout. This improves responsiveness + * during large pastes. + * + * Limitations: + * - Does NOT handle true kernel-level backpressure (EAGAIN/EWOULDBLOCK) + * - If node-pty.write() blocks, this cannot prevent it + * - For robust backpressure handling, use daemon mode with subprocess isolation * * Features: - * - Chunked writes to prevent blocking + * - Chunked writes to reduce event loop starvation * - Memory-bounded queue to prevent OOM * - Backpressure signaling when queue is full * - Graceful handling of PTY closure From c06b7339249b566d43945175cdae0c8ddc9ee42c Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Thu, 1 Jan 2026 20:43:09 +0200 Subject: [PATCH 85/98] fix(desktop): resolve TUI corruption on tab switch via SIGWINCH redraw For TUI sessions (alternate screen mode), serialized snapshots render incorrectly due to styled spaces and positioning issues. Instead of trying to perfectly serialize and restore TUI state, we now: 1. Skip writing the broken snapshot for alt-screen sessions 2. Enter alt-screen mode directly 3. Enable streaming first so live PTY output comes through 4. Trigger SIGWINCH via resize down/up - TUI redraws itself Trade-off: Brief visual flash as TUI redraws, but the result is correct. Normal shell sessions still use the snapshot approach which works well. - Add SIGWINCH-based redraw for TUI (alt-screen) session reattach - Remove dead resize nudge code (now handled by SIGWINCH approach) - Clean up verbose debug logging from investigation - Update research doc with final fix documentation - Add snapshot boundary tracking for consistent daemon-side captures --- .../TERMINAL_RENDERING_REATTACH_RESEARCH.md | 227 ++++++++++++++++++ .../lib/terminal-host/headless-emulator.ts | 51 ++++ .../src/main/lib/terminal-host/types.ts | 18 ++ .../src/main/lib/terminal/daemon-manager.ts | 1 + apps/desktop/src/main/lib/terminal/types.ts | 14 ++ .../desktop/src/main/terminal-host/session.ts | 130 +++++++++- .../TabsContent/Terminal/Terminal.tsx | 117 ++++++++- 7 files changed, 543 insertions(+), 15 deletions(-) diff --git a/apps/desktop/docs/TERMINAL_RENDERING_REATTACH_RESEARCH.md b/apps/desktop/docs/TERMINAL_RENDERING_REATTACH_RESEARCH.md index 624c9871b0e..951a70f7991 100644 --- a/apps/desktop/docs/TERMINAL_RENDERING_REATTACH_RESEARCH.md +++ b/apps/desktop/docs/TERMINAL_RENDERING_REATTACH_RESEARCH.md @@ -243,6 +243,233 @@ These are experiments that can confirm root causes quickly: --- +## Investigation Log (January 2026) + +### Observed Corruption + +When switching workspaces with OpenCode running, the restored terminal shows **missing content**: +- The "opencode" ASCII art logo is completely missing +- The "Ask anything..." input box is missing +- Only partial UI elements remain (agent name, status bar) +- Cursor position is wrong (middle of screen instead of input area) + +This is NOT garbled characters or wrong colors—it's **missing screen regions**, suggesting the snapshot content is incomplete or truncated. + +### Hypotheses Tested and Ruled Out + +| # | Hypothesis | Test | Result | +|---|------------|------|--------| +| 1 | **Live events interleaving with snapshot** - Events arrive before snapshot is applied | Added logging: `PENDING_EVENTS` count at snapshot time | ❌ PENDING_EVENTS=0 in all cases | +| 2 | **Double alt-screen entry** - Manual `\x1b[?1049h` + scrollback's copy | Disabled manual entry, logged if scrollback contains it | ❌ Still corrupted with manual entry disabled | +| 3 | **WebGL renderer issues** - Glyph atlas corruption | Forced Canvas renderer via localStorage | ❌ Still corrupted with Canvas | +| 4 | **Dimension mismatch** - Snapshot written at wrong cols/rows | Logged xterm vs snapshot dimensions | ❌ MATCH=true (106x60 = 106x60) | +| 5 | **Alt-screen buffer mismatch** - modes.altScreen disagrees with scrollback's last transition | Logged lastIndexOf for enter/exit sequences | ❌ CONSISTENT=true | + +### Key Observations from Logs + +``` +APPLYING SNAPSHOT: scrollback=8247 rehydrate=48 altScreen=true PENDING_EVENTS=0 +ALT-SCREEN CHECK: modes.altScreen=true scrollbackHasAlt=true +ALT-SCREEN TRANSITION: lastEnterIdx=275 lastExitIdx=-1 lastTransition=ENTER CONSISTENT=true +DIMENSION CHECK: xterm=106x60 snapshot=106x60 MATCH=true +``` + +- Dimensions match perfectly +- Alt-screen mode is consistent between daemon and scrollback +- No pending events at snapshot time +- rehydrateSequences is only 48 bytes (may be too small for full TUI state?) + +### Remaining Hypotheses (Not Yet Tested) + +1. **Flush timeout during snapshot** - Daemon's `flushEmulatorWrites()` times out under heavy output, capturing incomplete screen state + +2. **Snapshot content is incomplete/stale** - The headless emulator isn't capturing the full screen buffer correctly for alternate screen TUIs + +3. **Missing TUI state in rehydrateSequences** - 48 bytes may not cover all modes TUIs need (scroll region, saved cursor, character sets, etc.) + +4. **Cursor position not in snapshot** - TUI assumes cursor is in input area, but we're not restoring cursor position + +### Next Steps + +1. **Investigate daemon-side snapshot generation** (`headless-emulator.ts`) + - Is the alternate screen buffer being serialized correctly? + - Is cursor position included in the snapshot? + - Does flush timeout occur during capture? + +2. **Log actual snapshot content** - Inspect first/last bytes to see if content is truncated + +3. **Compare headless emulator state vs actual screen** - Hash comparison to detect discrepancies + +### Code Changes Made During Investigation + +Added diagnostic logging to `Terminal.tsx`: +- `APPLYING SNAPSHOT` - scrollback size, rehydrate size, alt screen mode, pending events +- `ALT-SCREEN CHECK` - whether scrollback/rehydrate contain alt-screen sequences +- `ALT-SCREEN TRANSITION` - which transition (enter/exit) came last, consistency check +- `DIMENSION CHECK` - xterm cols/rows vs snapshot cols/rows +- `QUEUING/FLUSHING` - event timing during reattach + +These logs can be removed once the root cause is found. + +--- + +## ROOT CAUSE IDENTIFIED & FIX IMPLEMENTED (January 2026) + +### The Bug: Flush Timeout During Snapshot + +**Location:** `Session.attach()` in `apps/desktop/src/main/terminal-host/session.ts` + +**The Problem Flow:** + +``` +1. User switches tabs, triggering attach() +2. attach() calls flushEmulatorWrites(500ms) to process pending PTY output +3. With continuous TUI output (like OpenCode), the queue NEVER empties in 500ms +4. Promise.race() times out, but emulatorWriteQueue still has unprocessed data +5. attach() immediately calls getSnapshotAsync() +6. Snapshot captures INCOMPLETE state - queued data never made it to xterm! +``` + +**The Data Flow:** +``` +PTY → Session.emulatorWriteQueue → HeadlessEmulator.terminal (xterm) → snapshot + ↑ + STUCK HERE if timeout +``` + +**Why Previous Tests Missed This:** +- Renderer-side logs showed `PENDING_EVENTS=0` - but that's the RENDERER's queue +- The DAEMON's `emulatorWriteQueue` was the culprit +- The bug is invisible from the renderer's perspective + +### The Fix: Snapshot Boundary Tracking + +Instead of waiting for the entire queue to empty (impossible with continuous output), we now: + +1. **Mark a "snapshot boundary"** when attach() is called (current queue length) +2. **Decrement the counter** as items are processed +3. **Resolve when boundary reached** (processed all pre-attach data) +4. **Ignore post-attach data** for snapshot purposes (it will be streamed live) + +**Key Changes:** + +```typescript +// session.ts - New state tracking +private snapshotBoundaryIndex: number | null = null; +private snapshotBoundaryWaiters: Array<() => void> = []; + +// New method: flushToSnapshotBoundary(timeoutMs) +// - Sets boundary = queue.length at call time +// - Waits for that many items to be processed +// - Guarantees consistent point-in-time snapshot + +// attach() now uses: +const reachedBoundary = await this.flushToSnapshotBoundary(ATTACH_FLUSH_TIMEOUT_MS); +// Instead of: +await this.flushEmulatorWrites(ATTACH_FLUSH_TIMEOUT_MS); // OLD - broken +``` + +### Why This Fix Works + +- With continuous output, new data keeps arriving AFTER attach() is called +- We only care about data received BEFORE attach - that's what defines our snapshot point +- By counting items instead of waiting for empty, we get a consistent snapshot +- Post-attach data streams live to the renderer (normal operation) + +### Logging Added for Verification + +**Daemon-side (`session.ts`):** +``` +[Session X] ATTACH FLUSH OK: flushTime=123ms processed=42 items (8192 bytes) +[Session X] ATTACH FLUSH TIMEOUT: flushTime=500ms queueBefore=100 queueAfter=75 +``` + +**Headless emulator (`headless-emulator.ts`):** +``` +[HeadlessEmulator] SNAPSHOT: altScreen=true snapshotSize=12345 rehydrateSize=48 cols=106 rows=60 +``` + +### Testing Needed + +1. Run OpenCode in a terminal +2. Switch to a different workspace tab +3. Switch back +4. Verify: ASCII art logo and input box should now be visible +5. Check logs for "ATTACH FLUSH OK" instead of "ATTACH FLUSH TIMEOUT" + +--- + +## FINAL FIX: SIGWINCH-Based TUI Redraw (January 2026) + +### Why Snapshots Don't Work for TUIs + +After implementing the snapshot boundary fix above, we discovered a **deeper issue**: even with correct snapshots, TUI rendering was still broken. + +**The Problem:** + +1. TUIs use "styled spaces" (spaces with background colors) to create UI elements +2. SerializeAddon captures buffer cell content, but serialization of styled empty cells is inconsistent +3. When restored, the serialized snapshot renders sparsely—missing panels, borders, and UI chrome + +**Diagnostic Data:** +``` +ALT-BUFFER: lines=52 nonEmpty=14 chars=2156 +``` +A full TUI screen (91×52 = 4732 cells) should have far more content. The alt buffer was sparse. + +### The Solution: Skip Snapshot, Trigger SIGWINCH + +Instead of trying to perfectly serialize and restore TUI state, we now: + +1. **Skip writing the broken snapshot** for alt-screen (TUI) sessions +2. **Enter alt-screen mode** directly so TUI output goes to the correct buffer +3. **Enable streaming first** so live PTY output comes through +4. **Trigger SIGWINCH** via resize down/up—TUI redraws itself from scratch + +**Key Code (Terminal.tsx):** +```typescript +if (isAltScreenReattach) { + // Enter alt-screen mode + xterm.write("\x1b[?1049h"); + + // Apply non-alt-screen rehydration sequences + if (result.snapshot?.rehydrateSequences) { ... } + + // Enable streaming BEFORE resize + isStreamReadyRef.current = true; + flushPendingEvents(); + + // Trigger SIGWINCH + resizeRef.current({ paneId, cols, rows: rows - 1 }); + setTimeout(() => { + resizeRef.current({ paneId, cols, rows }); + }, 100); + + return; // Skip normal snapshot flow +} +``` + +### Trade-offs + +| Aspect | Before (Snapshot) | After (SIGWINCH) | +|--------|-------------------|------------------| +| Visual continuity | Broken (sparse/corrupted) | Brief flash as TUI redraws | +| Correctness | Unreliable | Reliable (TUI owns its state) | +| Complexity | High (serialize/deserialize TUI state) | Low (let TUI handle it) | +| Performance | Single write of serialized data | TUI full repaint via stream | + +### Why This Works + +- TUIs maintain their own internal state and can redraw on SIGWINCH +- We're not trying to perfectly capture a moving target (incremental TUI updates) +- The TUI is the authority on its own display—we just trigger a refresh + +### Non-TUI Sessions Unchanged + +Normal shell sessions (not in alternate screen mode) still use the snapshot approach, which works correctly for scrollback history and shell prompts. + +--- + ## Reference links - xterm.js flow control guide (buffering, time-sliced processing, throughput limits): https://xtermjs.org/docs/guides/flowcontrol/ diff --git a/apps/desktop/src/main/lib/terminal-host/headless-emulator.ts b/apps/desktop/src/main/lib/terminal-host/headless-emulator.ts index 15460908784..02522ad4f54 100644 --- a/apps/desktop/src/main/lib/terminal-host/headless-emulator.ts +++ b/apps/desktop/src/main/lib/terminal-host/headless-emulator.ts @@ -229,6 +229,51 @@ export class HeadlessEmulator { const rehydrateSequences = this.generateRehydrateSequences(); + // Build debug diagnostics + const xtermBufferType = this.terminal.buffer.active.type; + const hasAltScreenEntry = snapshotAnsi.includes("\x1b[?1049h"); + + let altBufferDebug: + | { + lines: number; + nonEmptyLines: number; + totalChars: number; + cursorX: number; + cursorY: number; + sampleLines: string[]; + } + | undefined; + + if (this.modes.alternateScreen || xtermBufferType === "alternate") { + const altBuffer = this.terminal.buffer.alternate; + let nonEmptyLines = 0; + let totalChars = 0; + const sampleLines: string[] = []; + + for (let i = 0; i < altBuffer.length; i++) { + const line = altBuffer.getLine(i); + if (line) { + const lineText = line.translateToString(true); + if (lineText.trim().length > 0) { + nonEmptyLines++; + totalChars += lineText.length; + if (sampleLines.length < 3) { + sampleLines.push(lineText.slice(0, 80)); + } + } + } + } + + altBufferDebug = { + lines: altBuffer.length, + nonEmptyLines, + totalChars, + cursorX: altBuffer.cursorX, + cursorY: altBuffer.cursorY, + sampleLines, + }; + } + return { snapshotAnsi, rehydrateSequences, @@ -237,6 +282,12 @@ export class HeadlessEmulator { cols: this.terminal.cols, rows: this.terminal.rows, scrollbackLines: this.getScrollbackLines(), + debug: { + xtermBufferType, + hasAltScreenEntry, + altBuffer: altBufferDebug, + normalBufferLines: this.terminal.buffer.normal.length, + }, }; } diff --git a/apps/desktop/src/main/lib/terminal-host/types.ts b/apps/desktop/src/main/lib/terminal-host/types.ts index f63303b801b..877e7962db5 100644 --- a/apps/desktop/src/main/lib/terminal-host/types.ts +++ b/apps/desktop/src/main/lib/terminal-host/types.ts @@ -90,6 +90,24 @@ export interface TerminalSnapshot { rows: number; /** Scrollback line count */ scrollbackLines: number; + /** Debug diagnostics for troubleshooting (optional) */ + debug?: { + /** xterm's internal buffer type */ + xtermBufferType: string; + /** Whether serialized output contains alt screen entry */ + hasAltScreenEntry: boolean; + /** Alt buffer stats if in alt screen */ + altBuffer?: { + lines: number; + nonEmptyLines: number; + totalChars: number; + cursorX: number; + cursorY: number; + sampleLines: string[]; + }; + /** Normal buffer line count */ + normalBufferLines: number; + }; } // ============================================================================= diff --git a/apps/desktop/src/main/lib/terminal/daemon-manager.ts b/apps/desktop/src/main/lib/terminal/daemon-manager.ts index 1bf680c0255..c591ea17b49 100644 --- a/apps/desktop/src/main/lib/terminal/daemon-manager.ts +++ b/apps/desktop/src/main/lib/terminal/daemon-manager.ts @@ -247,6 +247,7 @@ export class DaemonTerminalManager extends EventEmitter { cols: response.snapshot.cols, rows: response.snapshot.rows, scrollbackLines: response.snapshot.scrollbackLines, + debug: response.snapshot.debug, }, }; } diff --git a/apps/desktop/src/main/lib/terminal/types.ts b/apps/desktop/src/main/lib/terminal/types.ts index b7d2b4eff29..1c656a7534e 100644 --- a/apps/desktop/src/main/lib/terminal/types.ts +++ b/apps/desktop/src/main/lib/terminal/types.ts @@ -50,6 +50,20 @@ export interface SessionResult { cols: number; rows: number; scrollbackLines: number; + /** Debug diagnostics for troubleshooting */ + debug?: { + xtermBufferType: string; + hasAltScreenEntry: boolean; + altBuffer?: { + lines: number; + nonEmptyLines: number; + totalChars: number; + cursorX: number; + cursorY: number; + sampleLines: string[]; + }; + normalBufferLines: number; + }; }; } diff --git a/apps/desktop/src/main/terminal-host/session.ts b/apps/desktop/src/main/terminal-host/session.ts index a3db6618843..8eec4ed148f 100644 --- a/apps/desktop/src/main/terminal-host/session.ts +++ b/apps/desktop/src/main/terminal-host/session.ts @@ -105,6 +105,10 @@ export class Session { private emulatorWriteScheduled = false; private emulatorFlushWaiters: Array<() => void> = []; + // Snapshot boundary tracking - allows capturing consistent state with continuous output + private snapshotBoundaryIndex: number | null = null; + private snapshotBoundaryWaiters: Array<() => void> = []; + // Callbacks private onSessionExit?: ( sessionId: string, @@ -355,9 +359,13 @@ export class Session { this.emulatorWriteQueue = []; this.emulatorWriteQueuedBytes = 0; this.emulatorWriteScheduled = false; + this.snapshotBoundaryIndex = null; const waiters = this.emulatorFlushWaiters; this.emulatorFlushWaiters = []; for (const resolve of waiters) resolve(); + const boundaryWaiters = this.snapshotBoundaryWaiters; + this.snapshotBoundaryWaiters = []; + for (const resolve of boundaryWaiters) resolve(); } /** @@ -502,9 +510,13 @@ export class Session { this.emulatorWriteQueue = []; this.emulatorWriteQueuedBytes = 0; this.emulatorWriteScheduled = false; + this.snapshotBoundaryIndex = null; const waiters = this.emulatorFlushWaiters; this.emulatorFlushWaiters = []; for (const resolve of waiters) resolve(); + const boundaryWaiters = this.snapshotBoundaryWaiters; + this.snapshotBoundaryWaiters = []; + for (const resolve of boundaryWaiters) resolve(); return; } @@ -527,9 +539,35 @@ export class Session { chunk = chunk.slice(0, MAX_CHUNK_CHARS); } else { this.emulatorWriteQueue.shift(); + + // Decrement boundary counter if tracking + if (this.snapshotBoundaryIndex !== null) { + this.snapshotBoundaryIndex--; + } } + this.emulatorWriteQueuedBytes -= chunk.length; this.emulator.write(chunk); + + // Check if we've reached the snapshot boundary (processed all items up to it) + if (this.snapshotBoundaryIndex === 0) { + this.snapshotBoundaryIndex = null; + const boundaryWaiters = this.snapshotBoundaryWaiters; + this.snapshotBoundaryWaiters = []; + for (const resolve of boundaryWaiters) resolve(); + // Continue processing remaining items (arrived after boundary was set) + if (this.emulatorWriteQueue.length > 0) { + setImmediate(() => { + this.processEmulatorWriteQueue(); + }); + return; + } + this.emulatorWriteScheduled = false; + const waiters = this.emulatorFlushWaiters; + this.emulatorFlushWaiters = []; + for (const resolve of waiters) resolve(); + return; + } } if (this.emulatorWriteQueue.length > 0) { @@ -540,6 +578,15 @@ export class Session { } this.emulatorWriteScheduled = false; + + // If we've drained the queue, any pending boundary is also reached + if (this.snapshotBoundaryIndex !== null) { + this.snapshotBoundaryIndex = null; + const boundaryWaiters = this.snapshotBoundaryWaiters; + this.snapshotBoundaryWaiters = []; + for (const resolve of boundaryWaiters) resolve(); + } + const waiters = this.emulatorFlushWaiters; this.emulatorFlushWaiters = []; for (const resolve of waiters) resolve(); @@ -566,6 +613,50 @@ export class Session { } } + /** + * Flush emulator writes up to current queue position (snapshot boundary). + * Unlike flushEmulatorWrites, this captures a consistent point-in-time state + * even with continuous output - we only wait for data received BEFORE this call. + * + * The key insight: snapshotBoundaryIndex tracks how many items REMAIN that + * need to be processed. Each time we shift an item, we decrement it. + * When it reaches 0, we've processed everything up to the boundary. + */ + private async flushToSnapshotBoundary(timeoutMs: number): Promise { + // Mark the current queue length as how many items we need to process + const itemsToProcess = this.emulatorWriteQueue.length; + + if (itemsToProcess === 0 && !this.emulatorWriteScheduled) { + return true; // Already flushed + } + + // Set the boundary counter - processEmulatorWriteQueue will decrement this + this.snapshotBoundaryIndex = itemsToProcess; + + const boundaryPromise = new Promise((resolve) => { + this.snapshotBoundaryWaiters.push(resolve); + this.scheduleEmulatorWrite(); + }); + + const timeoutPromise = new Promise((resolve) => + setTimeout(resolve, timeoutMs), + ); + + await Promise.race([boundaryPromise, timeoutPromise]); + + // Check if we actually reached the boundary or timed out + const reachedBoundary = this.snapshotBoundaryIndex === null; + + // Clean up if timed out (boundary wasn't reached) + if (!reachedBoundary) { + this.snapshotBoundaryIndex = null; + // Remove our waiter from the list + this.snapshotBoundaryWaiters = []; + } + + return reachedBoundary; + } + /** * Check if session is alive (PTY running) */ @@ -602,8 +693,39 @@ export class Session { }); this.lastAttachedAt = new Date(); - // Use timeout to prevent indefinite hang with continuous output (e.g., tail -f) - await this.flushEmulatorWrites(ATTACH_FLUSH_TIMEOUT_MS); + // Use snapshot boundary flush for consistent state with continuous output. + // This ensures we capture all data received BEFORE attach was called, + // even if new data continues to arrive during the flush. + const queuedBefore = this.emulatorWriteQueuedBytes; + const queueItemsBefore = this.emulatorWriteQueue.length; + const flushStart = performance.now(); + + const reachedBoundary = await this.flushToSnapshotBoundary( + ATTACH_FLUSH_TIMEOUT_MS, + ); + + const flushTime = performance.now() - flushStart; + const queuedAfter = this.emulatorWriteQueuedBytes; + + // ALWAYS log attach for debugging + const modes = this.emulator.getModes(); + console.log( + `[Session ${this.sessionId}] ATTACH: ` + + `reachedBoundary=${reachedBoundary} ` + + `flushTime=${flushTime.toFixed(0)}ms ` + + `queueBefore=${queueItemsBefore} queueAfter=${this.emulatorWriteQueue.length} ` + + `altScreen=${modes.alternateScreen}`, + ); + + if (!reachedBoundary) { + console.warn( + `[Session ${this.sessionId}] ATTACH FLUSH TIMEOUT: ` + + `flushTime=${flushTime.toFixed(0)}ms ` + + `queueBefore=${queueItemsBefore} items (${queuedBefore} bytes) ` + + `queueAfter=${this.emulatorWriteQueue.length} items (${queuedAfter} bytes)`, + ); + } + return this.emulator.getSnapshotAsync(); } @@ -710,9 +832,13 @@ export class Session { this.emulatorWriteQueue = []; this.emulatorWriteQueuedBytes = 0; this.emulatorWriteScheduled = false; + this.snapshotBoundaryIndex = null; const waiters = this.emulatorFlushWaiters; this.emulatorFlushWaiters = []; for (const resolve of waiters) resolve(); + const boundaryWaiters = this.snapshotBoundaryWaiters; + this.snapshotBoundaryWaiters = []; + for (const resolve of boundaryWaiters) resolve(); this.emulator.dispose(); this.attachedClients.clear(); diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index bf717b987bf..e899433a1c3 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -47,6 +47,19 @@ type CreateOrAttachResult = { cols: number; rows: number; scrollbackLines: number; + debug?: { + xtermBufferType: string; + hasAltScreenEntry: boolean; + altBuffer?: { + lines: number; + nonEmptyLines: number; + totalChars: number; + cursorX: number; + cursorY: number; + sampleLines: string[]; + }; + normalBufferLines: number; + }; }; }; @@ -279,12 +292,24 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const flushPendingEvents = useCallback(() => { const xterm = xtermRef.current; if (!xterm) return; - if (pendingEventsRef.current.length === 0) return; + if (pendingEventsRef.current.length === 0) { + console.log( + `[Terminal][${paneId.slice(-8)}] FLUSH: no pending events time=${Date.now()}`, + ); + return; + } const events = pendingEventsRef.current.splice( 0, pendingEventsRef.current.length, ); + const totalBytes = events.reduce( + (sum, e) => sum + (e.type === "data" ? e.data.length : 0), + 0, + ); + console.log( + `[Terminal][${paneId.slice(-8)}] FLUSHING ${events.length} events (${totalBytes} bytes) time=${Date.now()}`, + ); for (const event of events) { if (event.type === "data") { @@ -368,20 +393,81 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { } } - // If session was in alternate screen mode, enter it BEFORE writing content. - // rehydrateSequences intentionally excludes alternate screen mode (1049) because - // sending it after content would clear the screen. We must send it first so xterm - // knows to use the alternate buffer, then write content into it. - if (result.snapshot?.modes.alternateScreen) { - xterm.write("\x1b[?1049h"); - } - // Apply rehydration sequences to restore other terminal modes // (app cursor mode, bracketed paste, mouse tracking, etc.) if (result.snapshot?.rehydrateSequences) { xterm.write(result.snapshot.rehydrateSequences); } + // Resize xterm to match snapshot dimensions before applying content. + // The snapshot's cursor positioning assumes specific cols/rows. + const snapshotCols = result.snapshot?.cols; + const snapshotRows = result.snapshot?.rows; + if ( + snapshotCols && + snapshotRows && + (xterm.cols !== snapshotCols || xterm.rows !== snapshotRows) + ) { + xterm.resize(snapshotCols, snapshotRows); + } + + const isAltScreenReattach = + !result.isNew && result.snapshot?.modes.alternateScreen; + + // EXPERIMENTAL: For alt-screen (TUI) sessions, the serialized snapshot often + // renders incorrectly because styled spaces and positioning get lost. + // Instead of writing broken snapshot, enter alt-screen and trigger SIGWINCH + // so the TUI redraws itself via the live stream. + if (isAltScreenReattach) { + console.log( + `[Terminal][${paneId.slice(-8)}] ALT-SCREEN REATTACH: skipping snapshot, triggering SIGWINCH redraw`, + ); + + // Enter alt-screen mode so TUI output goes to correct buffer + xterm.write("\x1b[?1049h"); + + // Apply rehydration sequences for other modes (bracketed paste, etc.) + if (result.snapshot?.rehydrateSequences) { + // Filter out alt-screen sequences since we already entered + const ESC = "\x1b"; + const filteredRehydrate = result.snapshot.rehydrateSequences + .split(ESC + "[?1049h") + .join("") + .split(ESC + "[?47h") + .join(""); + if (filteredRehydrate) { + xterm.write(filteredRehydrate); + } + } + + // Enable streaming BEFORE resize so TUI output comes through + isStreamReadyRef.current = true; + flushPendingEvents(); + + // Fit xterm to container and trigger SIGWINCH + requestAnimationFrame(() => { + if (xtermRef.current !== xterm) return; + fitAddon.fit(); + + const cols = xterm.cols; + const rows = xterm.rows; + if (cols > 0 && rows > 0) { + console.log( + `[Terminal][${paneId.slice(-8)}] ALT-SCREEN SIGWINCH: ${cols}x${rows} -> ${cols}x${rows - 1} -> ${cols}x${rows}`, + ); + // Resize down then up to guarantee SIGWINCH + resizeRef.current({ paneId, cols, rows: rows - 1 }); + setTimeout(() => { + if (xtermRef.current !== xterm) return; + resizeRef.current({ paneId, cols, rows }); + }, 100); + } + }); + + updateCwdRef.current(result.scrollback); + return; // Skip normal snapshot flow + } + // xterm.write() is asynchronous - escape sequences may not be fully // processed when the terminal first renders, causing garbled display. // Force a re-render after write completes to ensure correct display. @@ -433,15 +519,16 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { if (xtermRef.current !== xterm) return; redraw(); }); + + // Enable streaming AFTER xterm has processed the snapshot. + // This prevents live PTY output from interleaving with snapshot replay. + isStreamReadyRef.current = true; + flushPendingEvents(); }); updateCwdRef.current(result.scrollback); } catch (error) { console.error("[Terminal] Restoration failed:", error); } - - // Enable streaming after initial state has been queued into xterm's write buffer. - isStreamReadyRef.current = true; - flushPendingEvents(); }, [flushPendingEvents, paneId]); const handleRetryConnection = useCallback(() => { @@ -481,6 +568,10 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const handleStreamData = (event: TerminalStreamEvent) => { // Queue events until terminal is ready to prevent data loss if (!xtermRef.current || !isStreamReadyRef.current) { + const dataLen = event.type === "data" ? event.data.length : 0; + console.log( + `[Terminal][${paneId.slice(-8)}] QUEUING event type=${event.type} len=${dataLen} totalQueued=${pendingEventsRef.current.length + 1} time=${Date.now()}`, + ); pendingEventsRef.current.push(event); return; } From 0442aa22f9a574264076aa49fb33822b9db85c47 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Thu, 1 Jan 2026 20:55:08 +0200 Subject: [PATCH 86/98] fix(desktop): use position-based alt-screen detection in scrollback fallback MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The fallback logic for detecting alternate screen mode was using presence/absence checks (includes) instead of position comparison (lastIndexOf). This caused incorrect detection when a user entered and exited alternate screen multiple times (e.g., opened vim, closed it, opened it again). Changed to use lastIndexOf comparison, matching the pattern already used in updateModesFromData and for bracketed paste detection. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 --- .../TabsContent/Terminal/Terminal.tsx | 21 +++++++++++-------- 1 file changed, 12 insertions(+), 9 deletions(-) diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index e899433a1c3..faec782feab 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -372,15 +372,18 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { // Also parse scrollback for escape sequences in case snapshot.modes is incomplete // This handles cases where the daemon didn't track the mode but the sequences are in history if (result.scrollback) { - const hasEnterAlt = - result.scrollback.includes("\x1b[?1049h") || - result.scrollback.includes("\x1b[?47h"); - const hasExitAlt = - result.scrollback.includes("\x1b[?1049l") || - result.scrollback.includes("\x1b[?47l"); - // If we see enter without exit, we're likely in alternate screen - if (hasEnterAlt && !hasExitAlt) { - isAlternateScreenRef.current = true; + // Use lastIndexOf to find the final state - handles multiple enter/exit cycles + // (e.g., user opened vim, closed it, opened it again) + const enterAltIndex = Math.max( + result.scrollback.lastIndexOf("\x1b[?1049h"), + result.scrollback.lastIndexOf("\x1b[?47h"), + ); + const exitAltIndex = Math.max( + result.scrollback.lastIndexOf("\x1b[?1049l"), + result.scrollback.lastIndexOf("\x1b[?47l"), + ); + if (enterAltIndex !== -1 || exitAltIndex !== -1) { + isAlternateScreenRef.current = enterAltIndex > exitAltIndex; } // Bracketed paste mode can toggle during a session - use the last seen state. From ee901c73f1f90ac9df44eac21279e4f1236fde69 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Fri, 2 Jan 2026 08:06:12 +0200 Subject: [PATCH 87/98] docs(desktop): consolidate terminal persistence technical notes Merge 3 separate documentation files into a single comprehensive reference: - TERMINAL_RENDERING_REATTACH_RESEARCH.md (research log) - 20251229-terminal-host-daemon-terminal-persistence.md (exec plan) - LARGE_PASTE_HANG_ANALYSIS.md (bug analysis) New file uses date prefix for chronological sorting. --- ...02-terminal-persistence-technical-notes.md | 239 ++++++++ .../TERMINAL_RENDERING_REATTACH_RESEARCH.md | 480 ---------------- ...rminal-host-daemon-terminal-persistence.md | 512 ------------------ docs/LARGE_PASTE_HANG_ANALYSIS.md | 60 -- 4 files changed, 239 insertions(+), 1052 deletions(-) create mode 100644 apps/desktop/docs/2026-01-02-terminal-persistence-technical-notes.md delete mode 100644 apps/desktop/docs/TERMINAL_RENDERING_REATTACH_RESEARCH.md delete mode 100644 docs/20251229-1858-terminal-host-daemon-terminal-persistence.md delete mode 100644 docs/LARGE_PASTE_HANG_ANALYSIS.md diff --git a/apps/desktop/docs/2026-01-02-terminal-persistence-technical-notes.md b/apps/desktop/docs/2026-01-02-terminal-persistence-technical-notes.md new file mode 100644 index 00000000000..5acd30a22e4 --- /dev/null +++ b/apps/desktop/docs/2026-01-02-terminal-persistence-technical-notes.md @@ -0,0 +1,239 @@ +# Terminal Persistence — Technical Notes + +> **Date**: January 2026 +> **Feature**: Terminal session persistence via daemon process +> **PR**: #541 + +This document captures the technical decisions, debugging investigations, and solutions for the terminal persistence feature. It's intended for engineers who need to understand **why** certain approaches were chosen. + +--- + +## Table of Contents + +1. [Architecture Overview](#architecture-overview) +2. [TUI Restoration: Why SIGWINCH Instead of Snapshots](#tui-restoration-why-sigwinch-instead-of-snapshots) +3. [Large Paste Reliability: Subprocess Isolation + Backpressure](#large-paste-reliability-subprocess-isolation--backpressure) +4. [Renderer Notes: WebGL vs Canvas on macOS](#renderer-notes-webgl-vs-canvas-on-macos) +5. [Design Options Considered](#design-options-considered) +6. [Reference Links](#reference-links) + +--- + +## Architecture Overview + +High-level data flow: + +``` +Renderer (xterm.js in React) + ↕ TRPC stream/write calls +Electron main + ↕ Unix socket IPC +terminal-host daemon (Node.js) + ↕ stdin/stdout IPC (binary framing) +per-session PTY subprocess (Node.js + node-pty) + ↕ PTY +shell / TUI (opencode, vim, etc.) +``` + +Key concepts: + +- **Daemon owns sessions** so terminals persist across app restarts. +- **Headless emulator** in daemon maintains a model of the terminal state (screen + modes) and produces a snapshot for reattach. +- **Per-session subprocess** isolates each PTY so one terminal can't freeze others. +- **Renderer is recreated** on React mount; on "switch away" we detach and later reattach to the daemon session. + +--- + +## TUI Restoration: Why SIGWINCH Instead of Snapshots + +### The Problem + +When switching away from a terminal running a TUI (like opencode, vim, claude) and switching back, we saw visual corruption—missing ASCII art, input boxes, and UI elements. + +### Why Snapshots Don't Work for TUIs + +1. TUIs use "styled spaces" (spaces with background colors) to create UI elements +2. `SerializeAddon` captures buffer cell content, but serialization of styled empty cells is inconsistent +3. When restored, the serialized snapshot renders sparsely—missing panels, borders, and UI chrome + +**Diagnostic data showed the problem:** +``` +ALT-BUFFER: lines=52 nonEmpty=14 chars=2156 +``` +A full TUI screen (91×52 = 4732 cells) should have far more content. The alt buffer was sparse. + +### Investigation Timeline + +| # | Hypothesis | Test | Result | +|---|------------|------|--------| +| 1 | Live events interleaving with snapshot | Added logging for pending events | ❌ PENDING_EVENTS=0 | +| 2 | Double alt-screen entry | Disabled manual entry | ❌ Still corrupted | +| 3 | WebGL renderer issues | Forced Canvas renderer | ❌ Still corrupted | +| 4 | Dimension mismatch | Logged xterm vs snapshot dims | ❌ MATCH=true | +| 5 | Alt-screen buffer mismatch | Logged transition sequences | ❌ CONSISTENT=true | + +### Root Cause: Flush Timeout During Snapshot + +**Location:** `Session.attach()` in `apps/desktop/src/main/terminal-host/session.ts` + +With continuous TUI output (like OpenCode), the emulator write queue NEVER empties in the timeout window. `Promise.race()` times out, but queued data never made it to xterm before snapshot capture. + +### The Solution: Skip Snapshot, Trigger SIGWINCH + +Instead of trying to perfectly serialize and restore TUI state: + +1. **Skip writing the broken snapshot** for alt-screen (TUI) sessions +2. **Enter alt-screen mode** directly so TUI output goes to the correct buffer +3. **Enable streaming first** so live PTY output comes through +4. **Trigger SIGWINCH** via resize down/up—TUI redraws itself from scratch + +```typescript +if (isAltScreenReattach) { + xterm.write("\x1b[?1049h"); // Enter alt-screen + isStreamReadyRef.current = true; + flushPendingEvents(); + + // Trigger SIGWINCH via resize + resizeRef.current({ paneId, cols, rows: rows - 1 }); + setTimeout(() => { + resizeRef.current({ paneId, cols, rows }); + }, 100); +} +``` + +### Trade-offs + +| Aspect | Snapshot Approach | SIGWINCH Approach | +|--------|-------------------|-------------------| +| Visual continuity | Broken (sparse/corrupted) | Brief flash as TUI redraws | +| Correctness | Unreliable | Reliable (TUI owns its state) | +| Complexity | High | Low | + +**Non-TUI sessions** (normal shells) still use the snapshot approach, which works correctly for scrollback history and shell prompts. + +--- + +## Large Paste Reliability: Subprocess Isolation + Backpressure + +### The Problem + +Pasting large blocks of text (e.g. 3k+ lines) into `vi` could: +- Hang the terminal daemon / freeze all terminals, or +- Partially paste and then silently stop (missing chunks) + +Most visible on macOS (small kernel PTY buffer + very high output volume during `vi` repaints). + +### Two Distinct Failure Modes + +**1) CPU saturation on output (daemon side)** + +Large pastes cause `vi` to repaint aggressively, producing huge volumes of escape-sequence-heavy output. If the daemon tries to parse that output in large unbounded chunks, it monopolizes the event loop. + +**2) Backpressure on input (PTY write side)** + +PTY writes must respect backpressure. When writing to a PTY fd in non-blocking mode, the kernel can return `EAGAIN`/`EWOULDBLOCK`. If treated as fatal, paste chunks get dropped. + +### The Solution + +**Process isolation (per terminal)** + +Each PTY runs in its own subprocess (`pty-subprocess.ts`). One terminal hitting backpressure can't freeze the daemon or other terminals. + +**Binary framing (no JSON on hot paths)** + +Subprocess ↔ daemon communication uses length-prefixed binary framing (`pty-subprocess-ipc.ts`) to avoid JSON overhead on escape-heavy output. + +**Output batching + stdout backpressure** + +Subprocess batches PTY output (32ms cadence, 128KB max) and pauses PTY reads when `process.stdout` is backpressured. + +**Input backpressure (retry, don't drop)** + +Subprocess treats `EAGAIN`/`EWOULDBLOCK` as expected backpressure: +- Keeps queued buffers +- Retries with exponential backoff (2ms → 50ms) +- Pauses upstream when backlog exceeds high watermark + +**Daemon responsiveness (time-sliced emulator)** + +The daemon applies PTY output to the headless emulator in time-budgeted slices. + +### Debugging + +Set these env vars and restart the app: +- `SUPERSET_PTY_SUBPROCESS_DEBUG=1` — subprocess batching + PTY input backpressure logs +- `SUPERSET_TERMINAL_EMULATOR_DEBUG=1` — daemon emulator budget/overrun logs + +```bash +ps aux | rg "terminal-host|pty-subprocess" +``` + +--- + +## Renderer Notes: WebGL vs Canvas on macOS + +### The Problem + +Severe corruption/glitching when switching between terminals on macOS with `xterm-webgl`. + +### Current Approach + +- **Default to Canvas on macOS** for stability +- **WebGL on other platforms** for performance +- Allow override for testing via localStorage: + ```javascript + localStorage.setItem('terminal-renderer', 'webgl' | 'canvas' | 'dom') + localStorage.removeItem('terminal-renderer') // revert to default + ``` + +### Why Warp Feels Smoother + +Warp's architecture is GPU-first (Metal on macOS) with careful minimization of bottlenecks. That doesn't automatically mean "WebGL fixes it" inside xterm.js—in practice `xterm-webgl` has had regressions on macOS. + +--- + +## Design Options Considered + +These were evaluated during the design phase: + +### Option A — Don't detach on tab switch (keep renderer alive) + +Make tab switching purely a show/hide operation. Removes the core "reattach baseline mismatch" failure mode. + +**Pros:** Fastest path to eliminating corruption +**Cons:** More memory if many terminals open; needs hibernation policies + +### Option B — tmux-style server authoritative screen diff + +Daemon maintains full screen grid; sends diffs to clients. + +**Pros:** Robust reattach +**Cons:** Significant engineering effort; essentially building a multiplexer + +### Option C — Use tmux/screen as persistence layer + +Put tmux behind the scenes. + +**Pros:** tmux already solved this +**Cons:** External dependency; platform concerns + +### Option D — Per-terminal WebContents/BrowserView + +Host each terminal in a persistent Electron view. + +**Pros:** Avoid rehydrate for navigation +**Cons:** Complex Electron lifecycle + +### What We Chose + +For v1, we implemented a daemon with SIGWINCH-based TUI restoration. This balances correctness (TUI redraws itself) with implementation complexity. + +--- + +## Reference Links + +- [xterm.js flow control guide](https://xtermjs.org/docs/guides/flowcontrol/) — buffering, time-sliced processing +- [xterm.js issue #595](https://github.com/xtermjs/xterm.js/issues/595) — "Support saving and restoring of terminal state" +- [xterm.js VT features](https://xtermjs.org/docs/api/vtfeatures/) — supported sequences +- [xterm.js WebGL issues](https://github.com/xtermjs/xterm.js/issues/4665) — regression examples +- [How Warp Works](https://www.warp.dev/blog/how-warp-works) — GPU-first architecture diff --git a/apps/desktop/docs/TERMINAL_RENDERING_REATTACH_RESEARCH.md b/apps/desktop/docs/TERMINAL_RENDERING_REATTACH_RESEARCH.md deleted file mode 100644 index 951a70f7991..00000000000 --- a/apps/desktop/docs/TERMINAL_RENDERING_REATTACH_RESEARCH.md +++ /dev/null @@ -1,480 +0,0 @@ -# Terminal Rendering + Reattach Research Log (Scratchpad) - -This doc is a living scratchpad for understanding and fixing two related UX problems in Superset Desktop terminals: - -1. **TUI corruption after switching away and back** (e.g. OpenCode/vim-like apps). -2. **Jittery resizing** (especially noticeable on macOS with Canvas rendering). - -It’s written for engineers who **do not have the original investigation context**. - ---- - -## TL;DR - -- **Corruption on tab switch** is usually not “random rendering”; it’s a *reattach correctness* problem: TUIs emit **incremental** escape sequences that assume a precise current screen/mode/cursor state. If we detach/unmount the renderer and later rebuild it from a snapshot, any tiny mismatch becomes visible as corruption when the TUI continues sending incremental updates. -- **Resize jitter** is mostly a throughput problem: resizing causes frequent PTY resizes + full-screen repaints from TUIs, and xterm.js processes input in **time-sliced batches** to avoid blocking the UI thread. Under heavy output, it can’t stay at 60fps without aggressive resize coalescing and/or a GPU-first renderer. - ---- - -## Current Architecture (as implemented in this repo) - -High-level data flow: - -``` -Renderer (xterm.js in React) - ↕ TRPC stream/write calls -Electron main - ↕ Unix socket IPC -terminal-host daemon (Node.js) - ↕ stdin/stdout IPC -per-session PTY subprocess (Node.js + node-pty) - ↕ PTY -shell / TUI (opencode, vim, etc.) -``` - -Key concepts: - -- **Daemon owns sessions** so terminals persist across app restarts. -- **Headless emulator** in daemon maintains a model of the terminal state (screen + modes) and produces a snapshot for reattach. -- **Renderer is recreated** on React mount; on “switch away” we may detach/unmount and later reattach to the daemon session. - -Related docs/code: -- Large paste reliability notes: `LARGE_PASTE_HANG_ANALYSIS.md` (repo root). -- Headless emulator: `apps/desktop/src/main/lib/terminal-host/headless-emulator.ts`. -- Renderer creation / GPU renderer selection: `apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/helpers.ts`. - -Related problem area: -- **Large paste reliability** was previously a major source of hangs/dropped input. The current direction is per-PTY subprocess isolation + explicit backpressure handling (treating `EAGAIN` as retry/backoff instead of “drop”). See `LARGE_PASTE_HANG_ANALYSIS.md` for details. - ---- - -## Symptom 1: TUI corruption after switching away and back - -### What we observe - -- Happens when switching away from a terminal and then returning to it. -- Not necessarily tied to full app restart. -- Affects TUIs that are screen-oriented and repaint frequently (OpenCode is a common reproduction). - -### Why this is hard (fundamental) - -Most TUIs do **incremental drawing**: -- move cursor -- rewrite a few cells -- update a small region -- assume a specific active buffer (normal vs alternate screen) -- assume a specific mode state (cursor keys, mouse tracking, bracketed paste, etc.) - -If we “reattach” by creating a new xterm renderer and restoring the screen from a snapshot, then: -- if the snapshot is taken **mid-update** (or we rehydrate in the wrong order), -- or if any output is missed/duplicated around the detach boundary, -- or if modes differ slightly between headless model and the new renderer, - -…the next incremental updates from the TUI apply relative to the wrong baseline and appear as corruption. - -This is not unique to Superset: xterm.js itself historically describes the only reliable way to “set” terminal state via public API as **replaying the commands that produced it**, and points toward headless/serialization as a reconnection primitive. - -### Key point: persistence vs rendering - -- **Persistence feature** increases exposure because it introduces **detach/attach** as a common lifecycle event. -- The corruption itself is typically a combination of: - - **reattach semantics** (state mismatch), and sometimes - - **renderer quirks** (WebGL issues on macOS, hidden/visible transitions). - -If you never detach/unmount the renderer on tab switch, you remove the most failure-prone step. - ---- - -## Symptom 2: Resize feels jittery - -### What we observe - -- Resizing panes feels less “buttery” than modern terminals like Warp. -- Jitter is especially noticeable with TUI output in flight and when using CPU rendering (Canvas). - -### Why this happens (fundamental) - -Resizing is expensive in a terminal for two reasons: - -1) **Logical resize triggers PTY resize → TUIs repaint** -- When cols/rows change, the PTY receives a resize (SIGWINCH on Unix-like systems). -- TUIs often repaint large regions or the entire screen in response. -- That yields a burst of output (escape-sequence heavy) right while we are doing layout work. - -2) **xterm.js has limited throughput and is intentionally time-sliced** -- `term.write()` is non-blocking; xterm buffers data and processes it in chunks designed to stay under ~one frame budget (≈16ms) to avoid blocking the UI thread. -- When producers are “too fast”, the terminal gets sluggish and may stop responding to input; hence flow control/backpressure is required in high-throughput pipelines. - -So “resize jitter” often means: **we’re asking xterm to keep up with heavy output + frequent resizes** faster than it can process/render. - -### Why Warp feels smooth - -Warp’s architecture is built around a GPU-first renderer (Metal on macOS) and careful minimization of bottlenecks (PTY read/parse, render, scroll). - -That doesn’t automatically mean “WebGL fixes it” inside xterm.js; in practice `xterm-webgl` has had regressions and rendering issues, and on macOS we’ve repeatedly seen corruption when hiding/showing terminals or switching panes. - ---- - -## Renderer notes (macOS) - -### WebGL vs Canvas vs DOM - -- **WebGL**: best performance potential, but can be fragile (glyph atlas / context loss / hidden-canvas transitions). -- **Canvas**: more stable but more CPU-bound (often leads to jitter under load). -- **DOM**: typically slowest, mostly a fallback. - -xterm.js’ core rendering and addons list includes WebGL and Serialize, but they come with tradeoffs. - -Current repo approach (as of recent fixes): -- Default to **Canvas on macOS** to avoid WebGL corruption on tab switching. -- Allow overriding for testing via localStorage: - - `localStorage.setItem('terminal-renderer', 'webgl' | 'canvas' | 'dom')` - - `localStorage.removeItem('terminal-renderer')` to revert to default. - ---- - -## Why switching away/back is specifically triggering corruption - -When a terminal is unmounted/hidden and later recreated: - -- A **new xterm instance** is created. -- We restore from daemon snapshot (serialize output + “rehydrate sequences”). -- The TUI process never stopped; it keeps emitting updates based on its own internal model. - -The critical window is the detach/attach boundary: - -- If the daemon snapshot isn’t taken at a stable boundary (e.g. “frame complete”), -- or if output continues while we are capturing/restoring and we apply it in a different order, -- or if we rehydrate modes (alternate screen, cursor modes, mouse tracking, bracketed paste) in the wrong sequence, - -…the restored xterm state can be “close enough” for plain shells but not for screen-oriented TUIs. - -This aligns with how terminal state restoration is generally discussed in the ecosystem: the most robust systems keep an authoritative server-side screen model and redraw it to clients on attach (tmux-style). - ---- - -## Design Options (out-of-the-box) - -These are “shape of the system” ideas, not small bug fixes. - -### Option A — Don’t detach on tab switch (keep renderer alive) - -Make tab switching purely a show/hide operation: -- keep the xterm instance alive in memory (and ideally attached to the session) -- avoid rehydrate/snapshot on routine navigation - -Pros: -- Removes the core “reattach baseline mismatch” failure mode. -- Likely the fastest path to eliminating OpenCode corruption on switch-back. - -Cons: -- More memory/CPU if many terminals are open. -- Might need policies (e.g. keep last N terminals “hot”; hibernate older ones). - -### Option B — tmux-style server authoritative screen diff - -Make the daemon the “truth” for terminal UI: -- daemon maintains the full screen grid and cursor/mode state -- on attach: send full state (grid + modes) -- during run: send diffs/updates to clients - -Pros: -- Reattach becomes robust (clients can come/go without state mismatch). -- Matches how tmux achieves persistence. - -Cons: -- Significant engineering effort: you’re effectively building a multiplexer protocol. -- Must ensure your screen model matches what the client renders (font metrics, wrapping, etc.). - -### Option C — Use tmux/screen as the persistence layer - -Put tmux behind the scenes: -- daemon starts tmux, each terminal is a tmux pane -- renderer is a normal terminal client - -Pros: -- tmux already solved “detach/reattach with a stable screen model”. -- Avoids inventing a custom diff protocol. - -Cons: -- External dependency and platform concerns. -- Integrating with our UX/workspace model could be awkward. - -### Option D — Per-terminal WebContents / BrowserView “view host” - -Instead of recreating terminals in React, host each terminal view in a persistent Electron view: -- switch visibility at the compositor level - -Pros: -- Avoid rehydrate for navigation. -- Strong isolation between terminal views. - -Cons: -- More complex Electron lifecycle; resource usage can rise. - -### Option E — Own the renderer (Warp/WezTerm direction) - -Long-term: a native/GPU-first terminal renderer and more control over resizing. - -Pros: -- Best chance at “buttery” resize + fewer corruption classes. -- Warp shows the ceiling when you own the rendering pipeline. - -Cons: -- Very large scope; essentially building a terminal engine inside the app. - ---- - -## Practical experiment ideas (near-term) - -These are experiments that can confirm root causes quickly: - -1) **Keep renderer alive on tab switch** (no detach/reattach) and see if OpenCode corruption disappears. -2) **Coalesce resizes**: - - “visual resize” during drag (scale), only “logical resize” (PTY cols/rows) on settle. - - lower-frequency resize dispatch (debounce/throttle) to reduce repaint storms. -3) **Force TUI redraw on attach**: - - e.g. synthetic resize nudge or sending a reset sequence (careful: many resets have side effects). - - This is a mitigation, not a root fix. -4) **Instrument attach boundary**: - - capture sequence numbers: last byte processed in emulator vs first byte delivered to client after attach - - detect and log gaps/duplication - - confirm mode parity (alternate screen, bracketed paste, mouse modes) - ---- - -## Investigation Log (January 2026) - -### Observed Corruption - -When switching workspaces with OpenCode running, the restored terminal shows **missing content**: -- The "opencode" ASCII art logo is completely missing -- The "Ask anything..." input box is missing -- Only partial UI elements remain (agent name, status bar) -- Cursor position is wrong (middle of screen instead of input area) - -This is NOT garbled characters or wrong colors—it's **missing screen regions**, suggesting the snapshot content is incomplete or truncated. - -### Hypotheses Tested and Ruled Out - -| # | Hypothesis | Test | Result | -|---|------------|------|--------| -| 1 | **Live events interleaving with snapshot** - Events arrive before snapshot is applied | Added logging: `PENDING_EVENTS` count at snapshot time | ❌ PENDING_EVENTS=0 in all cases | -| 2 | **Double alt-screen entry** - Manual `\x1b[?1049h` + scrollback's copy | Disabled manual entry, logged if scrollback contains it | ❌ Still corrupted with manual entry disabled | -| 3 | **WebGL renderer issues** - Glyph atlas corruption | Forced Canvas renderer via localStorage | ❌ Still corrupted with Canvas | -| 4 | **Dimension mismatch** - Snapshot written at wrong cols/rows | Logged xterm vs snapshot dimensions | ❌ MATCH=true (106x60 = 106x60) | -| 5 | **Alt-screen buffer mismatch** - modes.altScreen disagrees with scrollback's last transition | Logged lastIndexOf for enter/exit sequences | ❌ CONSISTENT=true | - -### Key Observations from Logs - -``` -APPLYING SNAPSHOT: scrollback=8247 rehydrate=48 altScreen=true PENDING_EVENTS=0 -ALT-SCREEN CHECK: modes.altScreen=true scrollbackHasAlt=true -ALT-SCREEN TRANSITION: lastEnterIdx=275 lastExitIdx=-1 lastTransition=ENTER CONSISTENT=true -DIMENSION CHECK: xterm=106x60 snapshot=106x60 MATCH=true -``` - -- Dimensions match perfectly -- Alt-screen mode is consistent between daemon and scrollback -- No pending events at snapshot time -- rehydrateSequences is only 48 bytes (may be too small for full TUI state?) - -### Remaining Hypotheses (Not Yet Tested) - -1. **Flush timeout during snapshot** - Daemon's `flushEmulatorWrites()` times out under heavy output, capturing incomplete screen state - -2. **Snapshot content is incomplete/stale** - The headless emulator isn't capturing the full screen buffer correctly for alternate screen TUIs - -3. **Missing TUI state in rehydrateSequences** - 48 bytes may not cover all modes TUIs need (scroll region, saved cursor, character sets, etc.) - -4. **Cursor position not in snapshot** - TUI assumes cursor is in input area, but we're not restoring cursor position - -### Next Steps - -1. **Investigate daemon-side snapshot generation** (`headless-emulator.ts`) - - Is the alternate screen buffer being serialized correctly? - - Is cursor position included in the snapshot? - - Does flush timeout occur during capture? - -2. **Log actual snapshot content** - Inspect first/last bytes to see if content is truncated - -3. **Compare headless emulator state vs actual screen** - Hash comparison to detect discrepancies - -### Code Changes Made During Investigation - -Added diagnostic logging to `Terminal.tsx`: -- `APPLYING SNAPSHOT` - scrollback size, rehydrate size, alt screen mode, pending events -- `ALT-SCREEN CHECK` - whether scrollback/rehydrate contain alt-screen sequences -- `ALT-SCREEN TRANSITION` - which transition (enter/exit) came last, consistency check -- `DIMENSION CHECK` - xterm cols/rows vs snapshot cols/rows -- `QUEUING/FLUSHING` - event timing during reattach - -These logs can be removed once the root cause is found. - ---- - -## ROOT CAUSE IDENTIFIED & FIX IMPLEMENTED (January 2026) - -### The Bug: Flush Timeout During Snapshot - -**Location:** `Session.attach()` in `apps/desktop/src/main/terminal-host/session.ts` - -**The Problem Flow:** - -``` -1. User switches tabs, triggering attach() -2. attach() calls flushEmulatorWrites(500ms) to process pending PTY output -3. With continuous TUI output (like OpenCode), the queue NEVER empties in 500ms -4. Promise.race() times out, but emulatorWriteQueue still has unprocessed data -5. attach() immediately calls getSnapshotAsync() -6. Snapshot captures INCOMPLETE state - queued data never made it to xterm! -``` - -**The Data Flow:** -``` -PTY → Session.emulatorWriteQueue → HeadlessEmulator.terminal (xterm) → snapshot - ↑ - STUCK HERE if timeout -``` - -**Why Previous Tests Missed This:** -- Renderer-side logs showed `PENDING_EVENTS=0` - but that's the RENDERER's queue -- The DAEMON's `emulatorWriteQueue` was the culprit -- The bug is invisible from the renderer's perspective - -### The Fix: Snapshot Boundary Tracking - -Instead of waiting for the entire queue to empty (impossible with continuous output), we now: - -1. **Mark a "snapshot boundary"** when attach() is called (current queue length) -2. **Decrement the counter** as items are processed -3. **Resolve when boundary reached** (processed all pre-attach data) -4. **Ignore post-attach data** for snapshot purposes (it will be streamed live) - -**Key Changes:** - -```typescript -// session.ts - New state tracking -private snapshotBoundaryIndex: number | null = null; -private snapshotBoundaryWaiters: Array<() => void> = []; - -// New method: flushToSnapshotBoundary(timeoutMs) -// - Sets boundary = queue.length at call time -// - Waits for that many items to be processed -// - Guarantees consistent point-in-time snapshot - -// attach() now uses: -const reachedBoundary = await this.flushToSnapshotBoundary(ATTACH_FLUSH_TIMEOUT_MS); -// Instead of: -await this.flushEmulatorWrites(ATTACH_FLUSH_TIMEOUT_MS); // OLD - broken -``` - -### Why This Fix Works - -- With continuous output, new data keeps arriving AFTER attach() is called -- We only care about data received BEFORE attach - that's what defines our snapshot point -- By counting items instead of waiting for empty, we get a consistent snapshot -- Post-attach data streams live to the renderer (normal operation) - -### Logging Added for Verification - -**Daemon-side (`session.ts`):** -``` -[Session X] ATTACH FLUSH OK: flushTime=123ms processed=42 items (8192 bytes) -[Session X] ATTACH FLUSH TIMEOUT: flushTime=500ms queueBefore=100 queueAfter=75 -``` - -**Headless emulator (`headless-emulator.ts`):** -``` -[HeadlessEmulator] SNAPSHOT: altScreen=true snapshotSize=12345 rehydrateSize=48 cols=106 rows=60 -``` - -### Testing Needed - -1. Run OpenCode in a terminal -2. Switch to a different workspace tab -3. Switch back -4. Verify: ASCII art logo and input box should now be visible -5. Check logs for "ATTACH FLUSH OK" instead of "ATTACH FLUSH TIMEOUT" - ---- - -## FINAL FIX: SIGWINCH-Based TUI Redraw (January 2026) - -### Why Snapshots Don't Work for TUIs - -After implementing the snapshot boundary fix above, we discovered a **deeper issue**: even with correct snapshots, TUI rendering was still broken. - -**The Problem:** - -1. TUIs use "styled spaces" (spaces with background colors) to create UI elements -2. SerializeAddon captures buffer cell content, but serialization of styled empty cells is inconsistent -3. When restored, the serialized snapshot renders sparsely—missing panels, borders, and UI chrome - -**Diagnostic Data:** -``` -ALT-BUFFER: lines=52 nonEmpty=14 chars=2156 -``` -A full TUI screen (91×52 = 4732 cells) should have far more content. The alt buffer was sparse. - -### The Solution: Skip Snapshot, Trigger SIGWINCH - -Instead of trying to perfectly serialize and restore TUI state, we now: - -1. **Skip writing the broken snapshot** for alt-screen (TUI) sessions -2. **Enter alt-screen mode** directly so TUI output goes to the correct buffer -3. **Enable streaming first** so live PTY output comes through -4. **Trigger SIGWINCH** via resize down/up—TUI redraws itself from scratch - -**Key Code (Terminal.tsx):** -```typescript -if (isAltScreenReattach) { - // Enter alt-screen mode - xterm.write("\x1b[?1049h"); - - // Apply non-alt-screen rehydration sequences - if (result.snapshot?.rehydrateSequences) { ... } - - // Enable streaming BEFORE resize - isStreamReadyRef.current = true; - flushPendingEvents(); - - // Trigger SIGWINCH - resizeRef.current({ paneId, cols, rows: rows - 1 }); - setTimeout(() => { - resizeRef.current({ paneId, cols, rows }); - }, 100); - - return; // Skip normal snapshot flow -} -``` - -### Trade-offs - -| Aspect | Before (Snapshot) | After (SIGWINCH) | -|--------|-------------------|------------------| -| Visual continuity | Broken (sparse/corrupted) | Brief flash as TUI redraws | -| Correctness | Unreliable | Reliable (TUI owns its state) | -| Complexity | High (serialize/deserialize TUI state) | Low (let TUI handle it) | -| Performance | Single write of serialized data | TUI full repaint via stream | - -### Why This Works - -- TUIs maintain their own internal state and can redraw on SIGWINCH -- We're not trying to perfectly capture a moving target (incremental TUI updates) -- The TUI is the authority on its own display—we just trigger a refresh - -### Non-TUI Sessions Unchanged - -Normal shell sessions (not in alternate screen mode) still use the snapshot approach, which works correctly for scrollback history and shell prompts. - ---- - -## Reference links - -- xterm.js flow control guide (buffering, time-sliced processing, throughput limits): https://xtermjs.org/docs/guides/flowcontrol/ -- xterm.js issue: “Support saving and restoring of terminal state” (headless + “replay commands” framing): https://github.com/xtermjs/xterm.js/issues/595 -- xterm.js supported terminal sequences (what is/ isn’t supported): https://xtermjs.org/docs/api/vtfeatures/ -- xterm.js WebGL regression example: https://github.com/xtermjs/xterm.js/issues/4665 -- tmux client/server architecture overview (high level): https://www.augmentcode.com/open-source/tmux/tmux -- Warp “How Warp Works” (GPU-first and performance bottlenecks): https://www.warp.dev/blog/how-warp-works diff --git a/docs/20251229-1858-terminal-host-daemon-terminal-persistence.md b/docs/20251229-1858-terminal-host-daemon-terminal-persistence.md deleted file mode 100644 index f3297f4ee3e..00000000000 --- a/docs/20251229-1858-terminal-host-daemon-terminal-persistence.md +++ /dev/null @@ -1,512 +0,0 @@ -# Terminal persistence via Superset-owned terminal host daemon (Desktop) - -This ExecPlan is a living document. The sections `Progress`, `Surprises & Discoveries`, `Decision Log`, and `Outcomes & Retrospective` must be kept up to date as work proceeds. - -No `PLANS.md` file was found in this repository at the time of writing. Follow the ExecPlan template requirements embedded in the prompt for structure, idempotence, and validation. - -## Purpose / Big Picture - -After this change, a Superset Desktop user can enable “terminal session persistence” and then: - -1. Open a terminal pane and start a long-running terminal UI (a “TUI”, e.g. `vim`, `htop`, `opencode`, `less`). -2. Quit Superset Desktop (including via auto-update install flow). -3. Reopen Superset Desktop and see the terminal come back exactly as it was (“perfect resume”): the screen contents match, the cursor/modes match, and interactive input works immediately (arrow keys, mouse, bracketed paste, etc.). -4. While the app was closed, the terminal continued running and its output was captured; reopening shows the up-to-date TUI state and recent scrollback. - -The key implementation change is introducing a long-lived background “terminal host” process (a daemon) that owns the PTYs and maintains terminal emulation state while the Electron app is closed. The Electron main process becomes a client of this daemon and continues to expose the same TRPC terminal interface to the renderer. - -## Assumptions - -1. This work targets `origin/main` and will be implemented on a new branch created from `origin/main` (e.g. `feat/terminal-host-daemon`). -2. macOS is the primary supported platform today; Linux is secondary. Windows support is explicitly deferred but must be feasible with the chosen abstractions. -3. The project continues to use `node-pty` as the PTY implementation for macOS/Linux (current dependency in `apps/desktop/package.json`). -4. The renderer continues to use xterm.js (`@xterm/xterm`) as the visible terminal UI (current implementation under `apps/desktop/src/renderer/.../Terminal`). -5. “Survive app updates” means: installing an update (on macOS via `electron-updater`) does not kill terminal sessions; a newly-launched updated app can attach to the already-running sessions. -6. “Perfect TUI resume” is interpreted strictly: the user should not need to “press a key to redraw” or rely on application-specific repaint behavior; the terminal state must be restored deterministically from the daemon-maintained emulator state. - -If any assumption is wrong, record the correction in `Decision Log` and update all impacted sections. - -## Open Questions - -**All questions resolved.** See Decision Log for details. - -1. ~~Persistence default and UX~~ → **RESOLVED**: Opt-in setting in Behaviors page, default off. -2. ~~Update/version skew policy~~ → **RESOLVED**: (A) Old daemon continues; additive protocol changes only. -3. ~~Output retention bounds~~ → **RESOLVED**: Configurable settings; defaults 10k lines + 4 MB disk per session. -4. ~~Multi-window semantics~~ → **RESOLVED**: Not applicable; single client per session. -5. ~~Security posture~~ → **RESOLVED**: User-only socket + token file. -6. ~~"Perfect resume" acceptance set~~ → **RESOLVED**: Test opencode, claude code, codex. - -## Progress - -- [x] (2025-12-29 18:58 local) Create new branch from `origin/main` and add this ExecPlan. -- [x] (2025-12-29 19:30 local) Implement prototyping harness for headless emulation + snapshot round-trip. **Milestone 1 complete** - 29 tests pass. -- [x] (2025-12-29 19:45 local) Implement daemon entrypoint and IPC framing. **Milestone 2 complete** - 6 tests pass. - - Created daemon entrypoint at `apps/desktop/src/main/terminal-host/index.ts` - - Updated `electron.vite.config.ts` to build daemon as separate bundle - - Implemented NDJSON protocol over Unix domain socket - - Implemented token-based authentication - - All hello/auth tests passing -- [x] (2025-12-29 20:00 local) Implement daemon session manager (PTY + headless emulator + capture). **Milestone 3 substantially complete** - 9 tests pass, 4 skipped (PTY tests). - - Created `Session` class with PTY + HeadlessEmulator integration - - Created `TerminalHost` class for session lifecycle management - - Implemented all IPC handlers (createOrAttach, write, resize, detach, kill, killAll, listSessions, clearScrollback) - - Data/exit event streaming to attached clients implemented - - Note: Some integration tests skipped due to bun/node-pty compatibility issue (see Surprises) - - Output capture to disk (ring buffer) deferred to later milestone -- [x] (2025-12-29 19:30 local) Integrate daemon client into Electron main process and preserve existing TRPC API. **Milestone 4 substantially complete**. - - Created `TerminalHostClient` at `apps/desktop/src/main/lib/terminal-host/client.ts` - - Manages connection to daemon socket - - Spawns daemon if not running (detached process with ELECTRON_RUN_AS_NODE=1) - - Handles authentication and request/response framing - - Forwards data/exit events via EventEmitter - - Created `DaemonTerminalManager` at `apps/desktop/src/main/lib/terminal/daemon-manager.ts` - - Same interface as original `TerminalManager` - - Delegates all operations to `TerminalHostClient` - - Maintains EventEmitter compatibility for TRPC subscriptions - - Updated `apps/desktop/src/main/lib/terminal/index.ts` - - Added `getActiveTerminalManager()` function - - Controlled by `SUPERSET_TERMINAL_DAEMON=1` env var for testing - - Updated TRPC terminal router to: - - Use `getActiveTerminalManager()` for manager selection - - Return snapshot payload in `createOrAttach` response - - Build passes, tests pass (362 pass, 4 skip, 1 fail - pre-existing) - - Note: Manual testing pending - set `SUPERSET_TERMINAL_DAEMON=1` and run `bun dev` -- [ ] Update renderer terminal to apply daemon snapshot + mode rehydration before streaming. -- [ ] Add persistence setting + quit/update behavior changes; add "Stop background sessions" control. -- [ ] Add tests + manual acceptance checklist; document known limitations and recovery steps. -- [ ] Fill in Outcomes & Retrospective; move plan to `.agents/plans/done/` when PR is created. - -## Surprises & Discoveries - -- **bun/node-pty test compatibility issue** (2025-12-29): When running integration tests with real PTYs via bun, there's an internal node-pty error: `this._socket.write is not a function`. This affects PTY write operations in the test environment. The existing TerminalManager tests work around this by mocking node-pty entirely. For the daemon, we've skipped the PTY-dependent integration tests and will rely on manual testing until this is resolved. The core daemon infrastructure (socket, auth, NDJSON protocol) is fully tested. - -## Decision Log - -Add entries here as decisions are made and questions are resolved. - -- **Decision (Q1): Persistence default and UX** — RESOLVED - Setting added to Behaviors settings page with default **off**. - Rationale: Lower risk for v1; users consciously opt-in to background daemon behavior. Can flip to default-on in future release once confidence is high. - Date: 2025-12-29. - -- **Decision (Q2): Update/version skew policy** — RESOLVED - **(A) Old daemon continues running** when app updates. New app speaks old protocol. - Protocol changes must be additive-only. If breaking change required, bump `protocolVersion` and show user prompt to restart terminals. - Rationale: The whole point of persistence is surviving app restarts — updates are the primary restart trigger. - Date: 2025-12-29. - -- **Decision (Q3): Output retention bounds** — RESOLVED - Configurable via Behaviors settings page. Defaults: - - Emulator scrollback: **10,000 lines** (range: 1k–100k) - - Disk ring buffer: **4 MB per session** (range: 1–32 MB) - Rationale: Users may have 100+ terminals; conservative defaults (100 sessions × 4 MB = 400 MB disk) prevent resource exhaustion. Power users can increase via settings. - Date: 2025-12-29. - -- **Decision (Q4): Multi-window attach semantics** — RESOLVED - **Not applicable.** The same terminal pane cannot be visible in multiple windows simultaneously due to app architecture. Implementation assumes single attached client per session — no fanout logic needed. - Rationale: Simplifies protocol and eliminates race conditions. - Date: 2025-12-29. - -- **Decision (Q5): Security posture** — RESOLVED - **User-only socket + token file** is sufficient. - - `SUPERSET_HOME_DIR` created with mode `0700` - - Socket at `~/.superset/terminal-host.sock` inherits directory permissions - - Token file at `~/.superset/terminal-host.token` with mode `0600` - - Token is 32+ bytes from `crypto.randomBytes`, hex-encoded - - Token validated on every `hello` request - Rationale: Local-only threat model; if attacker has same-user access, they can already kill the daemon or read process memory. Token prevents accidental cross-user access. - Date: 2025-12-29. - -- **Decision (Q6): "Perfect resume" acceptance set** — RESOLVED - Test the following AI coding agents (primary use case for Superset users): - - **opencode** - - **claude code** (Anthropic's Claude CLI) - - **codex** (OpenAI Codex CLI) - These stress long-running sessions, bracketed paste, and complex terminal modes — the exact workflows being optimized. - Date: 2025-12-29. - -## Outcomes & Retrospective - -(to be filled as milestones complete) - -## Context and Orientation - -This repository is a Bun + Turborepo monorepo. The Superset Desktop app lives under `apps/desktop/` and is built with Electron + `electron-vite`. - -In Desktop, there are three relevant runtime “sides”: - -1. Main process (Node.js/Electron environment): `apps/desktop/src/main/` - This can use Node.js modules and is responsible for creating BrowserWindows, running the local SQLite DB, managing terminals, etc. -2. Renderer process (browser environment): `apps/desktop/src/renderer/` - This cannot import Node.js modules. It renders the UI and hosts xterm.js terminal UI components. -3. Shared modules: `apps/desktop/src/shared/` - These must not import Node.js modules; they’re used by both main and renderer. - -Today’s terminal architecture (before this change): - -1. Renderer terminal UI: `apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx` - - Creates a visible xterm.js instance. - - Calls TRPC mutations to create/attach a session, write input, resize, detach, clear scrollback. - - Subscribes to a TRPC stream of terminal output events. -2. TRPC terminal router: `apps/desktop/src/lib/trpc/routers/terminal/terminal.ts` - - Exposes `createOrAttach`, `write`, `resize`, `kill`, `detach`, `clearScrollback`, and `stream`. - - Delegates to `terminalManager` in the main process. -3. TerminalManager: `apps/desktop/src/main/lib/terminal/manager.ts` - - Owns `node-pty` processes in-memory and emits `data:` and `exit:` events. - - On app quit, the main process calls `terminalManager.cleanup()` from `apps/desktop/src/main/index.ts`, killing PTYs. -4. Terminal history: `apps/desktop/src/main/lib/terminal-history.ts` - - Writes scrollback to disk under `~/.superset*/terminal-history/...` for recovery within a running app session. - -Why this is insufficient for persistence: - -- A PTY session cannot be “reattached” after the owning process exits. Today, the Electron main process owns the PTYs, so quitting the app necessarily kills sessions. - -New architecture required: - -- Introduce a persistent background process that owns PTYs and the “terminal emulator state” so sessions outlive app restarts and TUIs remain correct even when the renderer is closed. - -Terminology used in this plan (definitions): - -- PTY (pseudo-terminal): the OS interface that lets us run a shell/program as if it’s connected to a terminal. `node-pty` provides a cross-platform-ish API to spawn PTYs. -- TUI: a text-based interactive UI that relies on terminal modes, cursor addressing, alternate screen buffers, mouse tracking, etc. -- Terminal emulator: software that interprets control sequences (ANSI/VT) to maintain a screen buffer and state. xterm.js is one. -- Daemon (terminal host): a background process that continues running after the Electron app exits. -- Snapshot/rehydration: the daemon provides enough information (screen contents + mode state) for the renderer to recreate the exact terminal state on attach. - -## Plan of Work - -This work is intentionally milestone-driven. Each milestone must leave the repository in a runnable/testable state and must be independently verifiable. Do not attempt to “big bang” the whole daemon + UI rewrite in one pass. - -### Milestone 1: Prototyping spike — prove “perfect resume” is achievable - -Goal: demonstrate, in code checked into this repo, that we can: - -1. Feed terminal output into a headless terminal emulator (in Node), keep it running while no UI exists, and -2. Produce a snapshot that can be applied to a fresh xterm.js instance such that interactive input behavior matches (application cursor keys, bracketed paste, mouse tracking). - -Work to do: - -1. Add a prototyping script + tests under `apps/desktop/src/main/lib/terminal-host/prototype/`: - - `apps/desktop/src/main/lib/terminal-host/prototype/headless-roundtrip.test.ts` - - The test should: - - Create a headless emulator instance. - - Apply a sequence of terminal bytes that: - - Enters alternate screen, draws a screen, moves cursor. - - Enables application cursor keys (`CSI ? 1 h`) and bracketed paste (`CSI ? 2004 h`). - - Enables mouse mode (choose one: `CSI ? 1000 h` and SGR `CSI ? 1006 h`). - - Produce a snapshot payload: `{ snapshotAnsi: string, modes: {...} }`. - - Apply it into a fresh xterm.js instance in Node (or a second headless instance) and assert: - - The visible buffer text matches expected lines. - - The emulator’s mode flags are consistent (for flags we explicitly track). -2. Dependency choice: - - Add `@xterm/headless` to `apps/desktop/package.json` (used only in main/daemon code). - - Reuse `@xterm/addon-serialize` (already present) for snapshot generation. -3. Decide “source of truth” for query responses: - - While *no renderer client is attached*, the daemon must send xterm-generated query responses back to the PTY. - - While *a renderer client is attached*, the renderer continues sending xterm’s `onData` to backend (as today), and the daemon must not double-respond. - -Exit criteria / proof: - -- `cd apps/desktop && bun test` includes the new headless round-trip test and it passes. - -If the spike fails (serialize cannot rehydrate required state), update this ExecPlan with a pivot: track mode state explicitly and reapply via control sequences on attach, even if the snapshot only contains screen text. - -### Milestone 2: Add a terminal host daemon entrypoint and IPC framing - -Goal: add a runnable daemon process that can start, accept a connection, and respond to a `hello` request. No PTYs yet. - -Work to do: - -1. Create a new daemon entrypoint: - - `apps/desktop/src/main/terminal-host/index.ts` - This file is executed in a Node context (via Electron with `ELECTRON_RUN_AS_NODE=1`) and must not import any renderer/shared browser-only modules. -2. Update build configuration to produce the daemon bundle: - - In `apps/desktop/electron.vite.config.ts`, add an additional Rollup input for the main build so `dist/main/terminal-host.js` is built alongside `dist/main/index.js`. -3. Implement IPC message framing: - - Use a newline-delimited JSON protocol (NDJSON) over a local socket: - - request: `{ id: string, type: string, payload: object }` - - response: `{ id: string, ok: true, payload: object }` or `{ id: string, ok: false, error: { code: string, message: string } }` - - events: `{ type: "event", event: string, payload: object }` - - This keeps early prototypes simple and debuggable. -4. Socket location: - - macOS/Linux: Unix domain socket at `join(SUPERSET_HOME_DIR, "terminal-host.sock")`. - - Ensure permissions by relying on existing `SUPERSET_HOME_DIR` mode `0700` (created by local-db initialization). If that’s not guaranteed early enough, explicitly `mkdir/chmod` within daemon. -5. Auth token: - - Generate a random token on first run and write to `join(SUPERSET_HOME_DIR, "terminal-host.token")` with `0600`. - - Require the client to send it in `hello`. - -Exit criteria / proof: - -- A small Node script in main can connect and get a valid `hello` response. - -### Milestone 3: Daemon session manager (PTY + headless emulator + capture) - -Goal: daemon can create sessions (spawn PTY), keep them running when no clients are attached, continuously capture output to disk, and provide attach snapshots. - -Work to do: - -1. Define daemon session identity and lifecycle: - - Session ID should be stable across restarts and updates. Use `workspaceId` + `paneId` from existing TRPC inputs. - - Store per-session metadata (cwd, createdAt, lastAttachedAt, cols/rows). -2. Implement a `TerminalHost` in `apps/desktop/src/main/lib/terminal-host/`: - - `TerminalHost` holds a `Map`. - - Each `Session` owns: - - the `node-pty` process - - a headless xterm instance (“emulator of record”) - - a bounded on-disk log (ring buffer) and minimal metadata file - - a set of currently attached clients (0 or more) and their stream subscriptions -3. Emulator responsibilities: - - All PTY output is fed into the headless emulator to maintain state. - - The headless emulator’s `onData` is treated as “terminal-generated responses”. - - If `attachedClients === 0`: write these responses to the PTY (so TUIs keep functioning while app closed). - - If `attachedClients > 0`: do not write (renderer is responsible; avoids duplicate responses). -4. Snapshot API: - - `attach(sessionId, cols, rows)` returns: - - `snapshotAnsi`: serialized screen state string suitable to `xterm.write()`. - - `rehydrateSequences`: a small set of control sequences to restore input-affecting modes (application cursor keys, bracketed paste, mouse reporting, focus reporting, alt-screen, cursor visibility). - - `cwd` (best-effort, derived from OSC-7 parsing in output; see note below). - - `meta` including `attachedAt`, `cols/rows`. - - The daemon must keep mode state explicitly (don’t rely on private xterm internals). - - Track DECSET/DECRST `CSI ? Pm h/l` for the specific mode numbers needed. -5. CWD tracking: - - Move OSC-7 parsing to a shared module under `apps/desktop/src/shared/parse-cwd.ts` (no Node imports). - - The daemon parses PTY output stream to update `session.cwd`. -6. Output capture while closed: - - Write the raw output stream (post-clear-filtering if desired) to a bounded file (ring). - - Also keep emulator scrollback bounded via xterm options. - -Exit criteria / proof: - -- Manual: start daemon, create session, run a TUI, detach client (simulate by closing app window), confirm process continues and output grows in ring file, then reattach and see correct screen. -- Automated: add at least one integration-style test that spawns a short-lived PTY program that uses alternate screen + cursor movement and validate snapshot round-trip. - -### Milestone 4: Electron main integration (client + TRPC compatibility) - -Goal: keep the renderer’s TRPC interface mostly unchanged, but route terminal operations through the daemon instead of owning PTYs in-process. - -Work to do: - -1. Add a `TerminalHostClient` in main: - - `apps/desktop/src/main/lib/terminal-host/client.ts` - - Responsibilities: - - Ensure daemon is running (start if not). - - Maintain a connection pool (or single connection) and reconnect logic. - - Expose typed methods: `createOrAttach`, `write`, `resize`, `detach`, `kill`, `clearScrollback`, `subscribe`. -2. Start/ensure daemon: - - Spawn detached `process.execPath` with `ELECTRON_RUN_AS_NODE=1` and script path pointing at `dist/main/terminal-host.js`. - - In dev, use the built script path in the workspace; in prod, resolve via `app.getAppPath()` + `dist/main/terminal-host.js` equivalent. -3. Preserve `terminalManager` interface: - - Refactor `apps/desktop/src/main/lib/terminal/manager.ts` into a thin adapter that: - - keeps the existing EventEmitter (`data:`, `exit:`) - - delegates operations to `TerminalHostClient` - - no longer spawns `node-pty` directly (that code moves into daemon). -4. Update TRPC router: - - `apps/desktop/src/lib/trpc/routers/terminal/terminal.ts` should continue to work with the same calls, but `createOrAttach` must return the daemon snapshot payload. - - Add a backwards-compatible response shape by adding optional fields rather than breaking existing ones, then migrate renderer. - -Exit criteria / proof: - -- `bun dev` for Desktop works; opening a terminal shows output; basic typing works. - -### Milestone 5: Renderer rehydration path (snapshot + mode restore + streaming) - -Goal: on attach, the renderer restores a perfect terminal state before streaming live output. - -Work to do: - -1. Update `apps/desktop/src/renderer/.../Terminal/Terminal.tsx`: - - Replace “write `result.scrollback`” with: - - apply `result.rehydrateSequences` first (these are control sequences that update xterm mode state) - - apply `result.snapshotAnsi` next - - only then enable subscription consumption (`subscriptionEnabled = true`) and flush queued events. -2. Ensure user input is sent unchanged: - - Keep using `xterm.onData` and send to backend via TRPC `write`. - - This includes query responses; daemon must ignore responses while attached (per Milestone 3). -3. Handle resize: - - On resize, send `resize` to daemon; daemon resizes PTY and also updates emulator dimensions. -4. Recovery UI: - - If attach fails due to daemon mismatch or missing session, show a small UI affordance: - - “Session ended” (if PTY exited) - - “Restart terminal” (creates new session) - -Exit criteria / proof: - -- Manual acceptance: pick a TUI, quit app, reopen, resume and immediately interact with correct behavior. - -### Milestone 6: Persistence setting + quit/update behavior + “stop daemon” control - -Goal: make persistence user-controlled, safe by default, and compatible with auto-update install flow. - -Work to do: - -1. Local DB settings: - - Add to local DB schema (`packages/local-db/src/schema/schema.ts`): - - `terminalPersistenceEnabled` boolean (default: false) - - `terminalScrollbackLines` integer (default: 10000, range: 1000–100000) - - `terminalDiskBufferMb` integer (default: 4, range: 1–32) - - Expose via settings TRPC router (`apps/desktop/src/lib/trpc/routers/settings/index.ts`) with optimistic UI patterns consistent with existing settings. -2. Behavior settings UI: - - Add under behavior settings in the renderer: - - Toggle: "Enable terminal persistence" (default off) — Keep terminal sessions alive when Superset is closed - - Number input: "Scrollback lines" (default 10000) — Lines of history kept per terminal - - Number input: "Disk buffer per terminal" (default 4 MB) — Output captured while app is closed - - Add an explicit button: "Stop background terminal sessions": - - Calls daemon `killAll` and stops daemon (or marks it idle and allows exit). -3. App quit behavior: - - When persistence is enabled, do not kill sessions on quit. The app should simply detach/disconnect. - - When persistence is disabled, keep the current behavior (cleanup kills PTYs). -4. Auto-update install behavior: - - Ensure the “install update” path does not kill sessions even if it triggers a forced quit. - -Exit criteria / proof: - -- Toggle on → sessions survive quit/reopen. -- Toggle off → quitting kills sessions (existing behavior). -- Update install flow (manual) does not kill sessions. - -### Milestone 7: Hardening, tests, and future-proofing (Windows) - -Goal: reduce operational risk and lay groundwork for Windows. - -Work to do: - -1. Orphan cleanup: - - On app start, compare current panes (from app state) with daemon sessions; kill sessions not referenced after a grace period. -2. Crash recovery: - - If daemon crashes, main should detect and show “sessions lost; restart terminal” rather than hanging. -3. Protocol compatibility: - - Establish a stable protocol version (`protocolVersion: 1`) and enforce additive changes only. - - Add a compatibility test that simulates missing optional fields. -4. Windows groundwork (no implementation yet): - - Abstract socket path selection so future named pipe support can be plugged in without rewriting the daemon. - - Identify the Windows-specific risks (ConPTY differences, process detachment semantics) and document them in-code. - -Exit criteria / proof: - -- `cd apps/desktop && bun test` passes. -- Manual acceptance checklist completed and recorded in PR description (not in this ExecPlan). - -## Concrete Steps - -All commands are from repo root unless stated otherwise. - -1. Create work branch: - - - `cd /Users/andreasasprou/Documents/superset` - - `git checkout -b feat/terminal-host-daemon origin/main` - -2. Run Desktop tests while iterating: - - - `cd apps/desktop` - - `bun test` - - Expected: existing tests pass; new tests added by this plan should fail before their implementation and pass after. - -3. Run Desktop dev build: - - - `cd /Users/andreasasprou/Documents/superset` - - `bun dev` - - Expected: Electron app launches; terminals function. - -4. Manual persistence demo (post-implementation): - - - Enable persistence toggle in Settings → Behavior. - - Open a terminal pane and run one of the target AI agents: `opencode`, `claude`, or `codex`. - - Interact with the agent (start a conversation, let it generate code). - - Quit the app (Cmd+Q). - - Reopen the app and verify: - - Screen content matches pre-quit state exactly. - - Cursor is in correct position. - - Arrow keys work correctly (not printing escape codes). - - Can immediately continue interacting without redraw. - - While app is closed, optionally run a command that prints periodically (e.g. `watch date`) and confirm it progressed when reattached. - -## Validation and Acceptance - -Acceptance is met when all of the following are true: - -1. Persistence disabled (default): quitting Superset kills terminal sessions (current behavior). -2. Persistence enabled: terminal sessions survive app quit/reopen; output continues to be captured while app is closed. -3. Perfect TUI resume: the following AI coding agents resume with correct screen state and correct interactive input semantics immediately on reopen: - - **opencode** - - **claude code** (Anthropic's Claude CLI) - - **codex** (OpenAI Codex CLI) -4. Update survival: using the in-app update install flow does not kill persistent sessions; reopening the updated app can attach to existing sessions. -5. Automated tests exist for the headless snapshot round-trip and pass in CI-equivalent `bun test` runs. - -## Idempotence and Recovery - -This plan should be safe to apply incrementally: - -- Each milestone adds functionality behind stable interfaces and can be rerun. -- Socket + token files under `SUPERSET_HOME_DIR` must be created with safe permissions and should not be overwritten unexpectedly. If regeneration is needed (e.g. token compromised), provide an explicit “reset daemon” action and document it. -- If the daemon fails to start or protocol mismatch occurs, the app must fail gracefully: show a recoverable error and allow “Restart terminal” (non-persistent) rather than hanging. - -Rollback strategy (if needed): - -- Keep the old in-process `TerminalManager` path behind a feature flag during migration (temporary). -- If daemon integration is unstable, disable the persistence toggle and fall back to in-process PTY ownership. - -## Artifacts and Notes - -When implementing, capture short evidence snippets here (examples, not code fences): - -- Example of successful daemon handshake log output. -- Example of a snapshot payload size and attach timing. -- Example of a TUI resume manual checklist with timestamps. - -## Interfaces and Dependencies - -### New dependencies (Desktop app) - -In `apps/desktop/package.json`, add: - -- `@xterm/headless` (Node-only headless emulator in daemon) - -Reuse existing: - -- `@xterm/addon-serialize` (snapshot generation) -- `node-pty` (PTY spawning in daemon) - -### Required modules and types - -Create `apps/desktop/src/main/lib/terminal-host/types.ts` with stable protocol shapes: - - export interface TerminalHostHelloRequest { token: string; protocolVersion: 1 } - export interface TerminalHostHelloResponse { protocolVersion: 1; daemonVersion: string } - - export interface AttachResult { - snapshotAnsi: string; - rehydrateSequences: string; - cwd: string | null; - } - - export type TerminalHostRequest = - | { type: "hello"; payload: TerminalHostHelloRequest } - | { type: "createOrAttach"; payload: { sessionId: string; cols: number; rows: number; cwd?: string; env?: Record } } - | { type: "write"; payload: { sessionId: string; data: string } } - | { type: "resize"; payload: { sessionId: string; cols: number; rows: number } } - | { type: "detach"; payload: { sessionId: string } } - | { type: "kill"; payload: { sessionId: string } } - | { type: "killAll"; payload: {} }; - -Daemon must implement these and keep them backwards compatible (additive changes only). - -### Main process integration points - -Files that will change: - -- `apps/desktop/electron.vite.config.ts` (build daemon entry) -- `apps/desktop/src/main/index.ts` (quit behavior based on setting; ensure daemon survival on quit/update) -- `apps/desktop/src/main/lib/terminal/manager.ts` (delegate to daemon client) -- `apps/desktop/src/lib/trpc/routers/terminal/terminal.ts` (return snapshot payload; stream from daemon) -- `apps/desktop/src/renderer/.../Terminal/Terminal.tsx` (apply snapshot/rehydrate) -- `packages/local-db/src/schema/schema.ts` and migrations (new setting) -- `apps/desktop/src/lib/trpc/routers/settings/index.ts` + renderer settings UI (toggle + “stop daemon”) - -Windows future: - -- Design IPC so it can swap UDS for named pipes without changing higher-level interfaces. - diff --git a/docs/LARGE_PASTE_HANG_ANALYSIS.md b/docs/LARGE_PASTE_HANG_ANALYSIS.md deleted file mode 100644 index 3006a8f353d..00000000000 --- a/docs/LARGE_PASTE_HANG_ANALYSIS.md +++ /dev/null @@ -1,60 +0,0 @@ -# Large Paste into `vi` — Postmortem & Fix - -## Problem -Pasting large blocks of text (e.g. 3k+ lines) into `vi` inside Superset Desktop’s persistent terminal could: -- hang the terminal daemon / freeze all terminals, or -- partially paste and then silently stop (missing chunks). - -This was most visible on macOS (small kernel PTY buffer + very high output volume during `vi` repaints). - -## What Was Actually Happening -There were two distinct failure modes. - -### 1) CPU saturation on output (daemon side) -Large pastes cause `vi` to repaint aggressively, producing huge volumes of escape-sequence-heavy output. If the daemon tries to parse and apply that output to the headless xterm emulator in large, unbounded chunks, it can monopolize the event loop and trigger request timeouts / “frozen terminals”. - -### 2) Backpressure on input (PTY write side) -PTY writes must respect backpressure. When writing directly to a PTY file descriptor in non-blocking mode, the kernel can return: -- `EAGAIN` / `EWOULDBLOCK` (normal: PTY buffer full) - -If `EAGAIN` is treated as fatal (or if the queue is cleared on error), paste chunks get dropped. - -## Final Fix (Working) -The solution is end-to-end flow control + isolation. - -### Process isolation (per terminal) -Each PTY runs in its own subprocess (`apps/desktop/src/main/terminal-host/pty-subprocess.ts`). One terminal hitting backpressure can’t freeze the daemon or other terminals. - -### Binary framing (no JSON/NDJSON on hot paths) -Subprocess ↔ daemon communication uses a small length-prefixed binary framing protocol (`apps/desktop/src/main/terminal-host/pty-subprocess-ipc.ts`) to avoid JSON stringify/parse overhead on escape-heavy output. - -### Output batching + stdout backpressure -Subprocess batches PTY output (32ms cadence, 128KB max) and pauses PTY reads when `process.stdout` is backpressured. - -### Input backpressure (retry, don’t drop) -Subprocess writes to the PTY fd via async `fs.write()` (when fd is available) and treats `EAGAIN`/`EWOULDBLOCK` as expected backpressure: -- keeps the queued buffers -- retries with exponential backoff (2ms → 50ms) -- pauses upstream `stdin` when backlog exceeds a high watermark and resumes once drained - -### Daemon responsiveness (time-sliced emulator) -The daemon applies PTY output to the headless emulator in time-budgeted slices to avoid long single-tick stalls during heavy output bursts. - -### Renderer paste behavior -Renderer wraps clipboard pastes with bracketed paste sequences and chunks large payloads to reduce burstiness. - -## Debugging / Observability -Set these env vars and restart the app: -- `SUPERSET_PTY_SUBPROCESS_DEBUG=1` — subprocess batching + PTY input backpressure logs -- `SUPERSET_TERMINAL_EMULATOR_DEBUG=1` — daemon emulator budget/overrun logs - -Helpful process inspection: -```bash -ps aux | rg "terminal-host|pty-subprocess" -n -``` - -## Repro / Verification -1. Start the desktop app (`apps/desktop`). -2. Open a terminal, run `vi tmp.txt` and enter insert mode (`i`). -3. Paste ~3000+ lines. -4. Verify `vi` receives all lines (save to disk and check line count) and other terminals remain responsive. From da42b6ba10ec62f230756e89092e38d4a6d11235 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Fri, 2 Jan 2026 11:12:05 +0200 Subject: [PATCH 88/98] fix(desktop): resolve orphan PTY processes on workspace deletion MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Add escalation watchdog in handleKill: SIGTERM → SIGKILL → force exit node-pty's onExit callback doesn't fire reliably after pty.kill(SIGTERM) - Fix dispose() async bug: capture subprocess ref before nullifying - Add diagnostic logging throughout kill flow for debugging - Fix Terminal.tsx hook dependency warnings with targeted biome-ignore - Add TERMINAL_HOST_RUNBOOK.md for daemon debugging/testing --- apps/desktop/docs/TERMINAL_HOST_RUNBOOK.md | 138 ++++++++++++++++++ .../src/lib/trpc/routers/terminal/terminal.ts | 9 ++ .../src/main/lib/terminal-host/client.ts | 16 +- .../src/main/lib/terminal/daemon-manager.ts | 37 ++++- .../src/main/terminal-host/pty-subprocess.ts | 72 ++++++++- .../desktop/src/main/terminal-host/session.ts | 82 +++++++++-- .../src/main/terminal-host/terminal-host.ts | 114 +++++++++++++-- .../TabsContent/Terminal/Terminal.tsx | 22 ++- 8 files changed, 452 insertions(+), 38 deletions(-) create mode 100644 apps/desktop/docs/TERMINAL_HOST_RUNBOOK.md diff --git a/apps/desktop/docs/TERMINAL_HOST_RUNBOOK.md b/apps/desktop/docs/TERMINAL_HOST_RUNBOOK.md new file mode 100644 index 00000000000..e4bd90796d0 --- /dev/null +++ b/apps/desktop/docs/TERMINAL_HOST_RUNBOOK.md @@ -0,0 +1,138 @@ +# Terminal Host Daemon — Operations Runbook + +Quick reference for debugging and testing the terminal persistence daemon. + +--- + +## File Locations + +| Environment | Directory | Socket | PID | Logs | +|-------------|-----------|--------|-----|------| +| **Development** | `~/.superset-dev/` | `terminal-host.sock` | `terminal-host.pid` | `daemon.log` | +| **Production** | `~/.superset/` | `terminal-host.sock` | `terminal-host.pid` | None by default | + +--- + +## Common Commands + +```bash +# === STATUS === +# Check if daemon is running +cat ~/.superset-dev/terminal-host.pid && ps -p $(cat ~/.superset-dev/terminal-host.pid) + +# View daemon logs (dev only) +cat ~/.superset-dev/daemon.log +tail -f ~/.superset-dev/daemon.log # Live follow + +# === RESTART DAEMON === +# Kill daemon (required to pick up code changes) +kill -9 $(cat ~/.superset-dev/terminal-host.pid) +# Daemon auto-restarts when app connects + +# === FIND ORPHANS === +# Dev orphan subprocesses +ps aux | grep "pty-subprocess.*persistent-terminals" | grep -v grep + +# Production orphan subprocesses +ps aux | grep "Superset.app.*pty-subprocess" | grep -v grep + +# All terminal-related processes +ps aux | grep -E "terminal-host|pty-subprocess" | grep -v grep + +# === CLEANUP ORPHANS === +# Kill all dev subprocesses +pkill -9 -f "persistent-terminals.*pty-subprocess" + +# Kill all production subprocesses (careful!) +pkill -9 -f "Superset.app.*pty-subprocess" +``` + +--- + +## Testing Kill Flow + +1. **Kill existing daemon** (picks up code changes): + ```bash + kill -9 $(cat ~/.superset-dev/terminal-host.pid) + ``` + +2. **Clear logs** (optional): + ```bash + > ~/.superset-dev/daemon.log + ``` + +3. **Start dev server**, create workspace with terminals + +4. **Delete the workspace** + +5. **Check results**: + ```bash + # View kill flow in logs + cat ~/.superset-dev/daemon.log | grep -E "handleKill|onExit|EXIT frame|Force disposing" + + # Verify no orphans + ps aux | grep "pty-subprocess.*persistent-terminals" | grep -v grep + ``` + +### Expected Log Flow (Success) +``` +handleKill: calling pty.kill(SIGTERM) +handleKill: escalating to SIGKILL # After 2s if needed +onExit fired: exitCode=0, signal=9 +onExit: EXIT frame sent +Received EXIT frame +Subprocess exited with code 0 +``` + +### Failure Indicators +- `Force disposing stuck session after 5000ms` — onExit never fired, fallback kicked in +- Orphan `pty-subprocess` processes after workspace delete + +--- + +## Architecture + +``` +App (Renderer) + ↓ tRPC +Electron Main + ↓ Unix Socket +terminal-host daemon ← ~/.superset[-dev]/ + ↓ stdin/stdout IPC +pty-subprocess (per session) ← Owns the PTY + ↓ +shell (zsh/bash) +``` + +**Key insight**: Daemon persists across app restarts. Code changes require daemon restart. + +--- + +## Known Issues + +### node-pty `onExit` doesn't fire after `pty.kill(SIGTERM)` + +**Symptom**: Subprocess stays alive, session stuck until 5s timeout. + +**Solution** (implemented): Escalation watchdog in `handleKill()`: +- 0s: Send SIGTERM +- +2s: Escalate to SIGKILL if still alive +- +3s: Force exit if onExit still hasn't fired + +**Files**: `src/main/terminal-host/pty-subprocess.ts` + +--- + +## Adding Diagnostic Logging + +Daemon logs go to `~/.superset-dev/daemon.log`. To add logging: + +```typescript +// In pty-subprocess.ts (subprocess stderr → daemon.log) +console.error(`[pty-subprocess] your message`); + +// In session.ts or terminal-host.ts (daemon stdout → daemon.log) +console.log(`[Session ${id}] your message`); +``` + +Remember: **Kill daemon after code changes** to pick up new logging. diff --git a/apps/desktop/src/lib/trpc/routers/terminal/terminal.ts b/apps/desktop/src/lib/trpc/routers/terminal/terminal.ts index 3baf541f31d..ab2f441fcd7 100644 --- a/apps/desktop/src/lib/trpc/routers/terminal/terminal.ts +++ b/apps/desktop/src/lib/trpc/routers/terminal/terminal.ts @@ -108,6 +108,15 @@ export const createTerminalRouter = () => { } catch (error) { const message = error instanceof Error ? error.message : "Write failed"; + + // If session is gone, emit exit instead of error. + // This completes the subscription cleanly and prevents error toast floods + // when workspaces with terminals are deleted. + if (message.includes("not found or not alive")) { + terminalManager.emit(`exit:${input.paneId}`, 0, "SIGTERM"); + return; + } + terminalManager.emit(`error:${input.paneId}`, { error: message, code: "WRITE_FAILED", diff --git a/apps/desktop/src/main/lib/terminal-host/client.ts b/apps/desktop/src/main/lib/terminal-host/client.ts index 1096d7c2ebb..5e44172f35b 100644 --- a/apps/desktop/src/main/lib/terminal-host/client.ts +++ b/apps/desktop/src/main/lib/terminal-host/client.ts @@ -14,6 +14,7 @@ import { EventEmitter } from "node:events"; import { existsSync, mkdirSync, + openSync, readFileSync, unlinkSync, writeFileSync, @@ -587,10 +588,23 @@ export class TerminalHostClient extends EventEmitter { `[TerminalHostClient] Spawning daemon with execPath: ${process.execPath}`, ); + // Open log file for daemon output (helps debug daemon-side issues) + const logPath = join(SUPERSET_HOME_DIR, "daemon.log"); + let logFd: number; + try { + logFd = openSync(logPath, "a"); + } catch (error) { + console.warn( + `[TerminalHostClient] Failed to open daemon log file: ${error}`, + ); + // Fall back to ignoring output if we can't open log file + logFd = -1; + } + // Spawn daemon as detached process const child = spawn(process.execPath, [daemonScript], { detached: true, - stdio: "ignore", + stdio: logFd >= 0 ? ["ignore", logFd, logFd] : "ignore", env: { ...process.env, ELECTRON_RUN_AS_NODE: "1", diff --git a/apps/desktop/src/main/lib/terminal/daemon-manager.ts b/apps/desktop/src/main/lib/terminal/daemon-manager.ts index c591ea17b49..04f82bbae9f 100644 --- a/apps/desktop/src/main/lib/terminal/daemon-manager.ts +++ b/apps/desktop/src/main/lib/terminal/daemon-manager.ts @@ -326,12 +326,18 @@ export class DaemonTerminalManager extends EventEmitter { }): Promise { const { paneId, deleteHistory = false } = params; - await this.client.kill({ sessionId: paneId, deleteHistory }); - + // Emit exit event BEFORE killing so tRPC subscriptions complete cleanly. + // This prevents WRITE_FAILED errors when the daemon kills the session + // but React components are still mounted with active subscriptions. + // The daemon will also emit an exit event, but duplicate events are + // harmless since emit.complete() has already been called. const session = this.sessions.get(paneId); - if (session) { + if (session?.isAlive) { session.isAlive = false; + this.emit(`exit:${paneId}`, 0, "SIGTERM"); } + + await this.client.kill({ sessionId: paneId, deleteHistory }); } detach(params: { paneId: string }): void { @@ -412,23 +418,40 @@ export class DaemonTerminalManager extends EventEmitter { return { killed: 0, failed: 0 }; } + console.log( + `[DaemonTerminalManager] Killing ${paneIdsToKill.size} sessions for workspace ${workspaceId}`, + ); + let killed = 0; let failed = 0; for (const paneId of paneIdsToKill) { try { - await this.client.kill({ sessionId: paneId, deleteHistory: true }); - // Clean up local state if it exists + // Emit exit event BEFORE killing so tRPC subscriptions complete cleanly. + // This prevents WRITE_FAILED error toast floods when deleting workspaces. const session = this.sessions.get(paneId); - if (session) { + if (session?.isAlive) { session.isAlive = false; + this.emit(`exit:${paneId}`, 0, "SIGTERM"); } + + await this.client.kill({ sessionId: paneId, deleteHistory: true }); killed++; - } catch { + } catch (error) { + console.error( + `[DaemonTerminalManager] Failed to kill session ${paneId}:`, + error, + ); failed++; } } + if (failed > 0) { + console.warn( + `[DaemonTerminalManager] killByWorkspaceId: killed=${killed}, failed=${failed}`, + ); + } + return { killed, failed }; } diff --git a/apps/desktop/src/main/terminal-host/pty-subprocess.ts b/apps/desktop/src/main/terminal-host/pty-subprocess.ts index fc7bf5db4a6..1edc71f78cb 100644 --- a/apps/desktop/src/main/terminal-host/pty-subprocess.ts +++ b/apps/desktop/src/main/terminal-host/pty-subprocess.ts @@ -299,16 +299,24 @@ function handleSpawn(payload: Buffer): void { }); ptyProcess.onExit(({ exitCode, signal }) => { + console.error( + `[pty-subprocess] onExit fired: exitCode=${exitCode}, signal=${signal}`, + ); flushOutput(); const exitPayload = Buffer.allocUnsafe(8); exitPayload.writeInt32LE(exitCode ?? 0, 0); exitPayload.writeInt32LE(signal ?? 0, 4); send(PtySubprocessIpcType.Exit, exitPayload); + console.error("[pty-subprocess] onExit: EXIT frame sent"); ptyProcess = null; ptyFd = null; - setTimeout(() => process.exit(0), 100); + console.error("[pty-subprocess] onExit: scheduling process.exit(0)"); + setTimeout(() => { + console.error("[pty-subprocess] onExit: calling process.exit(0)"); + process.exit(0); + }, 100); }); const pidPayload = Buffer.allocUnsafe(4); @@ -343,13 +351,67 @@ function handleResize(payload: Buffer): void { } function handleKill(payload: Buffer): void { - if (!ptyProcess) return; + const signal = payload.length > 0 ? payload.toString("utf8") : "SIGTERM"; + console.error( + `[pty-subprocess] handleKill: ptyProcess=${!!ptyProcess}, pid=${ptyProcess?.pid}, signal=${signal}`, + ); + + if (!ptyProcess) { + console.error("[pty-subprocess] handleKill: no ptyProcess to kill"); + return; + } + + const pid = ptyProcess.pid; + + // Step 1: Send the requested signal (usually SIGTERM for graceful shutdown) try { - const signal = payload.length > 0 ? payload.toString("utf8") : undefined; + console.error( + `[pty-subprocess] handleKill: calling pty.kill(${signal}) on pid ${pid}`, + ); ptyProcess.kill(signal); - } catch { - // Ignore + console.error("[pty-subprocess] handleKill: pty.kill() returned"); + } catch (error) { + console.error( + `[pty-subprocess] handleKill: pty.kill() threw: ${error instanceof Error ? error.message : String(error)}`, + ); } + + // Step 2: Escalate to SIGKILL if still alive after 2 seconds + // node-pty's onExit callback may not fire reliably after pty.kill() + const escalationTimer = setTimeout(() => { + if (!ptyProcess) return; // Already exited via onExit + + console.error( + `[pty-subprocess] handleKill: escalating to SIGKILL for pid ${pid}`, + ); + try { + ptyProcess.kill("SIGKILL"); + } catch { + // Process may already be dead + } + + // Step 3: Force completion if onExit still hasn't fired after another 1 second + // This ensures the subprocess exits even if node-pty never emits onExit + const forceExitTimer = setTimeout(() => { + if (!ptyProcess) return; // Finally exited via onExit + + console.error( + `[pty-subprocess] handleKill: forcing exit, onExit never fired for pid ${pid}`, + ); + + // Synthesize Exit frame since onExit won't fire + const exitPayload = Buffer.allocUnsafe(8); + exitPayload.writeInt32LE(-1, 0); // Unknown exit code + exitPayload.writeInt32LE(9, 4); // SIGKILL signal number + send(PtySubprocessIpcType.Exit, exitPayload); + + ptyProcess = null; + ptyFd = null; + process.exit(0); + }, 1000); + forceExitTimer.unref(); + }, 2000); + escalationTimer.unref(); } function handleDispose(): void { diff --git a/apps/desktop/src/main/terminal-host/session.ts b/apps/desktop/src/main/terminal-host/session.ts index 8eec4ed148f..47113dae7b5 100644 --- a/apps/desktop/src/main/terminal-host/session.ts +++ b/apps/desktop/src/main/terminal-host/session.ts @@ -91,6 +91,7 @@ export class Session { private lastAttachedAt: Date; private exitCode: number | null = null; private disposed = false; + private terminatingAt: number | null = null; private subprocessDecoder: PtySubprocessFrameDecoder | null = null; private subprocessStdinQueue: Buffer[] = []; private subprocessStdinQueuedBytes = 0; @@ -294,6 +295,9 @@ export class Session { case PtySubprocessIpcType.Exit: { const exitCode = payload.length >= 4 ? payload.readInt32LE(0) : 0; const signal = payload.length >= 8 ? payload.readInt32LE(4) : 0; + console.log( + `[Session ${this.sessionId}] Received EXIT frame: exitCode=${exitCode}, signal=${signal}`, + ); this.exitCode = exitCode; this.broadcastEvent("exit", { @@ -483,8 +487,18 @@ export class Session { } private sendKillToSubprocess(signal?: string): boolean { + console.log( + `[Session ${this.sessionId}] sendKillToSubprocess(${signal}): subprocess.stdin=${!!this.subprocess?.stdin}, disposed=${this.disposed}`, + ); const payload = signal ? Buffer.from(signal, "utf8") : undefined; - return this.sendFrameToSubprocess(PtySubprocessIpcType.Kill, payload); + const result = this.sendFrameToSubprocess( + PtySubprocessIpcType.Kill, + payload, + ); + console.log( + `[Session ${this.sessionId}] sendKillToSubprocess(): sendFrameToSubprocess returned ${result}`, + ); + return result; } private sendDisposeToSubprocess(): boolean { @@ -664,6 +678,24 @@ export class Session { return this.subprocess !== null && this.exitCode === null; } + /** + * Check if session is in the process of terminating. + * A terminating session has received a kill signal but hasn't exited yet. + */ + get isTerminating(): boolean { + return this.terminatingAt !== null; + } + + /** + * Check if session can be attached to. + * A session is attachable if it's alive and not terminating. + * This prevents race conditions where createOrAttach is called + * immediately after kill but before the PTY has actually exited. + */ + get isAttachable(): boolean { + return this.isAlive && !this.isTerminating; + } + /** * Wait for PTY to be ready to accept writes. * Returns immediately if already ready, or waits for Spawned event. @@ -791,20 +823,45 @@ export class Session { } /** - * Kill the PTY process + * Kill the PTY process. + * Marks the session as terminating immediately (idempotent). + * The actual PTY termination is async - use isTerminating to check state. */ kill(signal: string = "SIGTERM"): void { + console.log( + `[Session ${this.sessionId}] kill(): terminatingAt=${this.terminatingAt}, subprocess=${!!this.subprocess}, subprocessReady=${this.subprocessReady}, ptyPid=${this.ptyPid}`, + ); + + // Idempotent: if already terminating, don't send another signal + if (this.terminatingAt !== null) { + console.log( + `[Session ${this.sessionId}] kill(): already terminating, skipping`, + ); + return; + } + + // Mark as terminating immediately to prevent race conditions + this.terminatingAt = Date.now(); + if (this.subprocess && this.subprocessReady) { - this.sendKillToSubprocess(signal); + const sent = this.sendKillToSubprocess(signal); + console.log( + `[Session ${this.sessionId}] kill(): sendKillToSubprocess(${signal}) returned ${sent}`, + ); return; } // If the subprocess isn't ready yet, fall back to killing the subprocess itself - // so session termination is reliable ( differentiation isn't meaningful pre-spawn). + // so session termination is reliable (differentiation isn't meaningful pre-spawn). + console.log( + `[Session ${this.sessionId}] kill(): subprocess not ready, using direct kill`, + ); try { this.subprocess?.kill(signal as NodeJS.Signals); - } catch { - // Ignore + } catch (error) { + console.log( + `[Session ${this.sessionId}] kill(): direct kill failed: ${error}`, + ); } } @@ -816,11 +873,18 @@ export class Session { this.disposed = true; if (this.subprocess) { + // Capture reference before nullifying - the timeout needs it + const subprocess = this.subprocess; this.sendDisposeToSubprocess(); - // Force kill after timeout - setTimeout(() => { - this.subprocess?.kill("SIGKILL"); + // Force kill after timeout if dispose frame didn't terminate it + const killTimer = setTimeout(() => { + try { + subprocess.kill("SIGKILL"); + } catch { + // Process may already be dead + } }, 1000); + killTimer.unref(); // Don't keep daemon alive for this timer this.subprocess = null; } this.subprocessReady = false; diff --git a/apps/desktop/src/main/terminal-host/terminal-host.ts b/apps/desktop/src/main/terminal-host/terminal-host.ts index 40d5e0f9494..1451af4e91a 100644 --- a/apps/desktop/src/main/terminal-host/terminal-host.ts +++ b/apps/desktop/src/main/terminal-host/terminal-host.ts @@ -27,8 +27,12 @@ import { createSession, type Session } from "./session"; // TerminalHost Class // ============================================================================= +/** Timeout for force-disposing sessions that don't exit after kill */ +const KILL_TIMEOUT_MS = 5000; + export class TerminalHost { private sessions: Map = new Map(); + private killTimers: Map = new Map(); /** * Create or attach to a terminal session @@ -42,6 +46,19 @@ export class TerminalHost { let session = this.sessions.get(sessionId); let isNew = false; + // If session is terminating (kill was called but PTY hasn't exited yet), + // force-dispose it and create a fresh session. This prevents race conditions + // where createOrAttach is called immediately after kill. + if (session?.isTerminating) { + console.log( + `[TerminalHost] Session ${sessionId} is terminating, force-disposing for fresh start`, + ); + session.dispose(); + this.sessions.delete(sessionId); + this.clearKillTimer(sessionId); + session = undefined; + } + // If session exists but is dead, dispose it and create a new one if (session && !session.isAlive) { session.dispose(); @@ -112,19 +129,21 @@ export class TerminalHost { } /** - * Write data to a terminal session + * Write data to a terminal session. + * Throws if session is not found or is terminating. */ write(request: WriteRequest): EmptyResponse { - const session = this.getSession(request.sessionId); + const session = this.getActiveSession(request.sessionId); session.write(request.data); return { success: true }; } /** - * Resize a terminal session + * Resize a terminal session. + * Throws if session is not found or is terminating. */ resize(request: ResizeRequest): EmptyResponse { - const session = this.getSession(request.sessionId); + const session = this.getActiveSession(request.sessionId); session.resize(request.cols, request.rows); return { success: true }; } @@ -146,14 +165,42 @@ export class TerminalHost { } /** - * Kill a terminal session + * Kill a terminal session. + * The session is marked as terminating immediately (non-attachable). + * A fail-safe timer ensures cleanup even if the PTY never exits. */ kill(request: KillRequest): EmptyResponse { - const session = this.sessions.get(request.sessionId); - if (session) { - session.kill(); - // Session will be removed on exit event + const { sessionId } = request; + const session = this.sessions.get(sessionId); + + console.log( + `[TerminalHost] kill(${sessionId}): found=${!!session}, isTerminating=${session?.isTerminating}, isAlive=${session?.isAlive}`, + ); + + if (!session) { + return { success: true }; } + + session.kill(); + console.log(`[TerminalHost] kill(${sessionId}): session.kill() called`); + + // Set up fail-safe timer to force-dispose if exit never fires. + // This prevents zombie sessions if the PTY process hangs. + if (!this.killTimers.has(sessionId)) { + const timer = setTimeout(() => { + const s = this.sessions.get(sessionId); + if (s?.isTerminating) { + console.warn( + `[TerminalHost] Force disposing stuck session ${sessionId} after ${KILL_TIMEOUT_MS}ms`, + ); + s.dispose(); + this.sessions.delete(sessionId); + } + this.killTimers.delete(sessionId); + }, KILL_TIMEOUT_MS); + this.killTimers.set(sessionId, timer); + } + return { success: true }; } @@ -169,14 +216,17 @@ export class TerminalHost { } /** - * List all sessions + * List all sessions. + * Note: isAlive reports isAttachable (alive AND not terminating) to prevent + * race conditions where killByWorkspaceId sees a session as alive while + * it's actually in the process of being killed. */ listSessions(): ListSessionsResponse { const sessions = Array.from(this.sessions.values()).map((session) => ({ sessionId: session.sessionId, workspaceId: session.workspaceId, paneId: session.paneId, - isAlive: session.isAlive, + isAlive: session.isAttachable, // Use isAttachable to prevent kill/attach races attachedClients: session.clientCount, })); @@ -184,10 +234,11 @@ export class TerminalHost { } /** - * Clear scrollback for a session + * Clear scrollback for a session. + * Throws if session is not found or is terminating. */ clearScrollback(request: ClearScrollbackRequest): EmptyResponse { - const session = this.getSession(request.sessionId); + const session = this.getActiveSession(request.sessionId); session.clearScrollback(); return { success: true }; } @@ -211,6 +262,13 @@ export class TerminalHost { * Clean up all sessions on shutdown */ dispose(): void { + // Clear all kill timers + for (const timer of this.killTimers.values()) { + clearTimeout(timer); + } + this.killTimers.clear(); + + // Dispose all sessions for (const session of this.sessions.values()) { session.dispose(); } @@ -232,6 +290,22 @@ export class TerminalHost { return session; } + /** + * Get an active (attachable) session by ID. + * Throws if session doesn't exist or is terminating. + * Use this for mutating operations (write, resize, clearScrollback). + */ + private getActiveSession(sessionId: string): Session { + const session = this.sessions.get(sessionId); + if (!session) { + throw new Error(`Session not found: ${sessionId}`); + } + if (!session.isAttachable) { + throw new Error(`Session not attachable: ${sessionId}`); + } + return session; + } + /** * Handle session exit */ @@ -240,11 +314,25 @@ export class TerminalHost { _exitCode: number, _signal?: number, ): void { + // Clear the kill timer since session exited normally + this.clearKillTimer(sessionId); + // Keep session around for a bit so clients can see exit status // Then clean up (reschedule if clients still attached) this.scheduleSessionCleanup(sessionId); } + /** + * Clear the kill timeout for a session + */ + private clearKillTimer(sessionId: string): void { + const timer = this.killTimers.get(sessionId); + if (timer) { + clearTimeout(timer); + this.killTimers.delete(sessionId); + } + } + /** * Schedule cleanup of a dead session * Reschedules if clients are still attached diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index faec782feab..1d7ddff7901 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -347,8 +347,10 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { } } } - }, []); + // biome-ignore lint/correctness/useExhaustiveDependencies: refs used intentionally to avoid recreating callback + }, [paneId, setConnectionError]); + // biome-ignore lint/correctness/useExhaustiveDependencies: refs (resizeRef, updateCwdRef, rendererRef) used intentionally to read latest values without recreating callback const maybeApplyInitialState = useCallback(() => { if (!didFirstRenderRef.current) return; const result = pendingInitialStateRef.current; @@ -534,6 +536,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { } }, [flushPendingEvents, paneId]); + // biome-ignore lint/correctness/useExhaustiveDependencies: createOrAttachRef used intentionally to read latest value without recreating callback const handleRetryConnection = useCallback(() => { setConnectionError(null); const xterm = xtermRef.current; @@ -566,7 +569,13 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { }, }, ); - }, [paneId, workspaceId, maybeApplyInitialState, flushPendingEvents]); + }, [ + paneId, + workspaceId, + maybeApplyInitialState, + flushPendingEvents, + setConnectionError, + ]); const handleStreamData = (event: TerminalStreamEvent) => { // Queue events until terminal is ready to prevent data loss @@ -645,6 +654,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { [isFocused], ); + // biome-ignore lint/correctness/useExhaustiveDependencies: refs (writeRef, resizeRef, detachRef, clearScrollbackRef, createOrAttachRef) used intentionally to read latest values without resubscribing useEffect(() => { const container = terminalRef.current; if (!container) return; @@ -917,7 +927,13 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { searchAddonRef.current = null; rendererRef.current = null; }; - }, [paneId, workspaceId, flushPendingEvents, maybeApplyInitialState]); + }, [ + paneId, + workspaceId, + flushPendingEvents, + maybeApplyInitialState, + setConnectionError, + ]); useEffect(() => { const xterm = xtermRef.current; From b03a09664f95b40e142913707212f34dd1efba3b Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Fri, 2 Jan 2026 11:21:47 +0200 Subject: [PATCH 89/98] chore(desktop): remove verbose diagnostic logging from kill flow Keep essential warnings (force exit, attach timeout, force dispose stuck session). Remove step-by-step debugging logs that are too noisy for production. --- .../src/main/terminal-host/pty-subprocess.ts | 25 +------- .../desktop/src/main/terminal-host/session.ts | 64 ++----------------- .../src/main/terminal-host/terminal-host.ts | 5 -- 3 files changed, 8 insertions(+), 86 deletions(-) diff --git a/apps/desktop/src/main/terminal-host/pty-subprocess.ts b/apps/desktop/src/main/terminal-host/pty-subprocess.ts index 1edc71f78cb..5d3321e952a 100644 --- a/apps/desktop/src/main/terminal-host/pty-subprocess.ts +++ b/apps/desktop/src/main/terminal-host/pty-subprocess.ts @@ -299,22 +299,16 @@ function handleSpawn(payload: Buffer): void { }); ptyProcess.onExit(({ exitCode, signal }) => { - console.error( - `[pty-subprocess] onExit fired: exitCode=${exitCode}, signal=${signal}`, - ); flushOutput(); const exitPayload = Buffer.allocUnsafe(8); exitPayload.writeInt32LE(exitCode ?? 0, 0); exitPayload.writeInt32LE(signal ?? 0, 4); send(PtySubprocessIpcType.Exit, exitPayload); - console.error("[pty-subprocess] onExit: EXIT frame sent"); ptyProcess = null; ptyFd = null; - console.error("[pty-subprocess] onExit: scheduling process.exit(0)"); setTimeout(() => { - console.error("[pty-subprocess] onExit: calling process.exit(0)"); process.exit(0); }, 100); }); @@ -352,12 +346,8 @@ function handleResize(payload: Buffer): void { function handleKill(payload: Buffer): void { const signal = payload.length > 0 ? payload.toString("utf8") : "SIGTERM"; - console.error( - `[pty-subprocess] handleKill: ptyProcess=${!!ptyProcess}, pid=${ptyProcess?.pid}, signal=${signal}`, - ); if (!ptyProcess) { - console.error("[pty-subprocess] handleKill: no ptyProcess to kill"); return; } @@ -365,15 +355,9 @@ function handleKill(payload: Buffer): void { // Step 1: Send the requested signal (usually SIGTERM for graceful shutdown) try { - console.error( - `[pty-subprocess] handleKill: calling pty.kill(${signal}) on pid ${pid}`, - ); ptyProcess.kill(signal); - console.error("[pty-subprocess] handleKill: pty.kill() returned"); - } catch (error) { - console.error( - `[pty-subprocess] handleKill: pty.kill() threw: ${error instanceof Error ? error.message : String(error)}`, - ); + } catch { + // Process may already be dead } // Step 2: Escalate to SIGKILL if still alive after 2 seconds @@ -381,9 +365,6 @@ function handleKill(payload: Buffer): void { const escalationTimer = setTimeout(() => { if (!ptyProcess) return; // Already exited via onExit - console.error( - `[pty-subprocess] handleKill: escalating to SIGKILL for pid ${pid}`, - ); try { ptyProcess.kill("SIGKILL"); } catch { @@ -396,7 +377,7 @@ function handleKill(payload: Buffer): void { if (!ptyProcess) return; // Finally exited via onExit console.error( - `[pty-subprocess] handleKill: forcing exit, onExit never fired for pid ${pid}`, + `[pty-subprocess] Force exit: onExit never fired for pid ${pid}`, ); // Synthesize Exit frame since onExit won't fire diff --git a/apps/desktop/src/main/terminal-host/session.ts b/apps/desktop/src/main/terminal-host/session.ts index 47113dae7b5..1202df489ea 100644 --- a/apps/desktop/src/main/terminal-host/session.ts +++ b/apps/desktop/src/main/terminal-host/session.ts @@ -258,9 +258,6 @@ export class Session { switch (type) { case PtySubprocessIpcType.Ready: this.subprocessReady = true; - console.log( - `[Session ${this.sessionId}] Subprocess ready, spawning PTY`, - ); if (this.pendingSpawn) { this.sendSpawnToSubprocess(this.pendingSpawn); this.pendingSpawn = null; @@ -269,9 +266,6 @@ export class Session { case PtySubprocessIpcType.Spawned: this.ptyPid = payload.length >= 4 ? payload.readUInt32LE(0) : null; - console.log( - `[Session ${this.sessionId}] PTY spawned with pid ${this.ptyPid}`, - ); // Resolve the ready promise so callers can await PTY readiness if (this.ptyReadyResolve) { this.ptyReadyResolve(); @@ -295,9 +289,6 @@ export class Session { case PtySubprocessIpcType.Exit: { const exitCode = payload.length >= 4 ? payload.readInt32LE(0) : 0; const signal = payload.length >= 8 ? payload.readInt32LE(4) : 0; - console.log( - `[Session ${this.sessionId}] Received EXIT frame: exitCode=${exitCode}, signal=${signal}`, - ); this.exitCode = exitCode; this.broadcastEvent("exit", { @@ -487,18 +478,8 @@ export class Session { } private sendKillToSubprocess(signal?: string): boolean { - console.log( - `[Session ${this.sessionId}] sendKillToSubprocess(${signal}): subprocess.stdin=${!!this.subprocess?.stdin}, disposed=${this.disposed}`, - ); const payload = signal ? Buffer.from(signal, "utf8") : undefined; - const result = this.sendFrameToSubprocess( - PtySubprocessIpcType.Kill, - payload, - ); - console.log( - `[Session ${this.sessionId}] sendKillToSubprocess(): sendFrameToSubprocess returned ${result}`, - ); - return result; + return this.sendFrameToSubprocess(PtySubprocessIpcType.Kill, payload); } private sendDisposeToSubprocess(): boolean { @@ -728,33 +709,13 @@ export class Session { // Use snapshot boundary flush for consistent state with continuous output. // This ensures we capture all data received BEFORE attach was called, // even if new data continues to arrive during the flush. - const queuedBefore = this.emulatorWriteQueuedBytes; - const queueItemsBefore = this.emulatorWriteQueue.length; - const flushStart = performance.now(); - const reachedBoundary = await this.flushToSnapshotBoundary( ATTACH_FLUSH_TIMEOUT_MS, ); - const flushTime = performance.now() - flushStart; - const queuedAfter = this.emulatorWriteQueuedBytes; - - // ALWAYS log attach for debugging - const modes = this.emulator.getModes(); - console.log( - `[Session ${this.sessionId}] ATTACH: ` + - `reachedBoundary=${reachedBoundary} ` + - `flushTime=${flushTime.toFixed(0)}ms ` + - `queueBefore=${queueItemsBefore} queueAfter=${this.emulatorWriteQueue.length} ` + - `altScreen=${modes.alternateScreen}`, - ); - if (!reachedBoundary) { console.warn( - `[Session ${this.sessionId}] ATTACH FLUSH TIMEOUT: ` + - `flushTime=${flushTime.toFixed(0)}ms ` + - `queueBefore=${queueItemsBefore} items (${queuedBefore} bytes) ` + - `queueAfter=${this.emulatorWriteQueue.length} items (${queuedAfter} bytes)`, + `[Session ${this.sessionId}] Attach flush timeout after ${ATTACH_FLUSH_TIMEOUT_MS}ms`, ); } @@ -828,15 +789,8 @@ export class Session { * The actual PTY termination is async - use isTerminating to check state. */ kill(signal: string = "SIGTERM"): void { - console.log( - `[Session ${this.sessionId}] kill(): terminatingAt=${this.terminatingAt}, subprocess=${!!this.subprocess}, subprocessReady=${this.subprocessReady}, ptyPid=${this.ptyPid}`, - ); - // Idempotent: if already terminating, don't send another signal if (this.terminatingAt !== null) { - console.log( - `[Session ${this.sessionId}] kill(): already terminating, skipping`, - ); return; } @@ -844,24 +798,16 @@ export class Session { this.terminatingAt = Date.now(); if (this.subprocess && this.subprocessReady) { - const sent = this.sendKillToSubprocess(signal); - console.log( - `[Session ${this.sessionId}] kill(): sendKillToSubprocess(${signal}) returned ${sent}`, - ); + this.sendKillToSubprocess(signal); return; } // If the subprocess isn't ready yet, fall back to killing the subprocess itself // so session termination is reliable (differentiation isn't meaningful pre-spawn). - console.log( - `[Session ${this.sessionId}] kill(): subprocess not ready, using direct kill`, - ); try { this.subprocess?.kill(signal as NodeJS.Signals); - } catch (error) { - console.log( - `[Session ${this.sessionId}] kill(): direct kill failed: ${error}`, - ); + } catch { + // Process may already be dead } } diff --git a/apps/desktop/src/main/terminal-host/terminal-host.ts b/apps/desktop/src/main/terminal-host/terminal-host.ts index 1451af4e91a..57d199c253c 100644 --- a/apps/desktop/src/main/terminal-host/terminal-host.ts +++ b/apps/desktop/src/main/terminal-host/terminal-host.ts @@ -173,16 +173,11 @@ export class TerminalHost { const { sessionId } = request; const session = this.sessions.get(sessionId); - console.log( - `[TerminalHost] kill(${sessionId}): found=${!!session}, isTerminating=${session?.isTerminating}, isAlive=${session?.isAlive}`, - ); - if (!session) { return { success: true }; } session.kill(); - console.log(`[TerminalHost] kill(${sessionId}): session.kill() called`); // Set up fail-safe timer to force-dispose if exit never fires. // This prevents zombie sessions if the PTY process hangs. From 7a535db8eb99e8411682aa2d2381146095be936e Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Fri, 2 Jan 2026 17:17:25 +0200 Subject: [PATCH 90/98] fix(desktop): keep terminals mounted to eliminate white screen on workspace switch When terminal persistence is enabled, render all tabs from all workspaces and use visibility:hidden for inactive ones. This eliminates the unmount/remount cycle that caused race conditions during TUI reattach. Changes: - TabsContent: query terminalPersistence setting, render all tabs when enabled - TerminalSettings: add memory warning copy - Terminal.tsx: remove debug logging, add comments clarifying SIGWINCH as fallback - Technical notes: document the approach and trade-offs --- ...02-terminal-persistence-technical-notes.md | 104 ++++++++++++++++- .../SettingsView/TerminalSettings.tsx | 9 +- .../TabsContent/Terminal/Terminal.tsx | 110 ++++++++---------- .../ContentView/TabsContent/index.tsx | 54 ++++++++- .../CONTINUITY_CLAUDE-tui-white-screen.md | 57 +++++++++ .../auto-handoff-2026-01-02T12-58-19.md | 31 +++++ .../auto-handoff-2026-01-02T14-14-50.md | 31 +++++ 7 files changed, 324 insertions(+), 72 deletions(-) create mode 100644 thoughts/ledgers/CONTINUITY_CLAUDE-tui-white-screen.md create mode 100644 thoughts/shared/handoffs/tui-white-screen/auto-handoff-2026-01-02T12-58-19.md create mode 100644 thoughts/shared/handoffs/tui-white-screen/auto-handoff-2026-01-02T14-14-50.md diff --git a/apps/desktop/docs/2026-01-02-terminal-persistence-technical-notes.md b/apps/desktop/docs/2026-01-02-terminal-persistence-technical-notes.md index 5acd30a22e4..9b7bf2ff3da 100644 --- a/apps/desktop/docs/2026-01-02-terminal-persistence-technical-notes.md +++ b/apps/desktop/docs/2026-01-02-terminal-persistence-technical-notes.md @@ -12,10 +12,12 @@ This document captures the technical decisions, debugging investigations, and so 1. [Architecture Overview](#architecture-overview) 2. [TUI Restoration: Why SIGWINCH Instead of Snapshots](#tui-restoration-why-sigwinch-instead-of-snapshots) -3. [Large Paste Reliability: Subprocess Isolation + Backpressure](#large-paste-reliability-subprocess-isolation--backpressure) -4. [Renderer Notes: WebGL vs Canvas on macOS](#renderer-notes-webgl-vs-canvas-on-macos) -5. [Design Options Considered](#design-options-considered) -6. [Reference Links](#reference-links) +3. [Keeping Terminals Mounted Across Workspace Switches](#keeping-terminals-mounted-across-workspace-switches) +4. [Large Paste Reliability: Subprocess Isolation + Backpressure](#large-paste-reliability-subprocess-isolation--backpressure) +5. [Renderer Notes: WebGL vs Canvas on macOS](#renderer-notes-webgl-vs-canvas-on-macos) +6. [Design Options Considered](#design-options-considered) +7. [Future Improvements](#future-improvements) +8. [Reference Links](#reference-links) --- @@ -113,6 +115,58 @@ if (isAltScreenReattach) { --- +## Keeping Terminals Mounted Across Workspace Switches + +### The Problem + +Even with SIGWINCH-based TUI restoration working correctly, switching between workspaces still caused intermittent white screen issues for TUI apps. Manual window resize would fix it, but the experience was jarring. + +**Root cause:** When switching workspaces, React unmounts the `Terminal` component entirely, destroying the xterm.js instance. On return, a new xterm instance must be created and reattached to the existing PTY session. Despite correct SIGWINCH timing, race conditions between xterm initialization and PTY output caused blank/white screens. + +### The Solution: Keep All Terminals Mounted + +Instead of unmounting Terminal components on workspace/tab switch: + +1. **Render all tabs from all workspaces** simultaneously in `TabsContent` +2. **Hide inactive tabs with CSS** (`visibility: hidden; pointer-events: none;`) +3. **Show only the active tab** for the active workspace + +**Implementation:** `TabsContent/index.tsx` renders `allTabs` with visibility toggling instead of conditional rendering. + +### Why `visibility: hidden` Instead of `display: none` + +Using `visibility: hidden` (not `display: none`) is critical: +- `display: none` removes the element from layout, giving it 0×0 dimensions +- xterm.js and FitAddon expect non-zero dimensions to function correctly +- `visibility: hidden` preserves the element's layout dimensions while hiding it visually + +### Why This Works + +- xterm.js instances persist across navigation—no recreation needed +- No state reconstruction, no reattach timing issues +- The terminal stays exactly as it was when hidden +- The complex SIGWINCH/snapshot restoration code becomes a fallback path only (used for app restart recovery) + +### Trade-offs + +| Aspect | Impact | Mitigation | +|--------|--------|------------| +| Memory | Each terminal holds scrollback buffer + xterm render state | See Future Improvements: LRU hibernation | +| CPU | Hidden terminals still process PTY output | See Future Improvements: buffer output | +| DOM nodes | Many elements even when hidden | `visibility: hidden` is cheap; browser optimizes | + +### When This Applies + +This optimization is **only enabled when Terminal Persistence is ON** in Settings. When persistence is disabled, the original behavior (unmount on switch) is used. + +### Fallback Path + +The SIGWINCH-based restoration logic remains in `Terminal.tsx` as a fallback for: +- **App restart recovery** — fresh xterm must reattach to daemon's PTY session +- **Edge cases** — any scenario where the Terminal component truly remounts + +--- + ## Large Paste Reliability: Subprocess Isolation + Backpressure ### The Problem @@ -228,6 +282,48 @@ Host each terminal in a persistent Electron view. For v1, we implemented a daemon with SIGWINCH-based TUI restoration. This balances correctness (TUI redraws itself) with implementation complexity. +**Update (v1.1):** We discovered that keeping xterm instances mounted (Option A) eliminates the reattach timing issues that caused white screen flashes during workspace/tab switches. When terminal persistence is enabled, we now render all tabs and toggle visibility instead of unmounting. The SIGWINCH restoration logic remains as a fallback for app restart recovery when a fresh xterm instance must reattach to an existing PTY session. + +--- + +## Future Improvements + +These are documented for future work. They are not blocking for the current implementation. + +### 1. Buffer PTY Output for Hidden Terminals + +Currently, hidden terminals continue processing PTY output through xterm.js. For users with many terminals producing continuous output, this wastes CPU cycles. + +**Proposed solution:** +- When a terminal becomes hidden, pause writes to xterm +- Buffer PTY events in memory (or discard if not in alt-screen mode) +- On show, flush buffered events to xterm + +### 2. LRU Terminal Hibernation + +For users with many workspaces (10+), keeping all terminals alive may use excessive memory. + +**Proposed solution:** +- Track terminal last-active timestamps +- When memory pressure is detected, hibernate oldest inactive terminals +- Hibernation = dispose xterm instance, keep PTY alive in daemon +- On reactivation, create new xterm and run normal restore flow + +### 3. Reduce Scrollback for Hidden Terminals + +Each terminal's scrollback buffer can be large (default 10,000 lines). + +**Proposed solution:** +- Reduce `scrollback` option for inactive terminals +- Restore full scrollback on activation (daemon has full history) + +### 4. Memory Usage Metrics + +Add observability to understand real-world memory usage patterns: +- Track number of terminals per user session +- Track memory per terminal (xterm buffers + DOM) +- Surface warnings if approaching problematic thresholds + --- ## Reference Links diff --git a/apps/desktop/src/renderer/screens/main/components/SettingsView/TerminalSettings.tsx b/apps/desktop/src/renderer/screens/main/components/SettingsView/TerminalSettings.tsx index c93d97fe9d1..4e4e6cafe78 100644 --- a/apps/desktop/src/renderer/screens/main/components/SettingsView/TerminalSettings.tsx +++ b/apps/desktop/src/renderer/screens/main/components/SettingsView/TerminalSettings.tsx @@ -55,8 +55,13 @@ export function TerminalSettings() { Terminal persistence

- Keep terminal sessions alive across app restarts. TUI apps like - Claude Code will resume exactly where you left off. + Keep terminal sessions alive across app restarts and workspace + switches. TUI apps like Claude Code will resume exactly where you + left off. +

+

+ May use more memory with many terminals open. Disable if you + notice performance issues.

Requires app restart to take effect. diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index 1d7ddff7901..cf2a334417b 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -292,24 +292,12 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const flushPendingEvents = useCallback(() => { const xterm = xtermRef.current; if (!xterm) return; - if (pendingEventsRef.current.length === 0) { - console.log( - `[Terminal][${paneId.slice(-8)}] FLUSH: no pending events time=${Date.now()}`, - ); - return; - } + if (pendingEventsRef.current.length === 0) return; const events = pendingEventsRef.current.splice( 0, pendingEventsRef.current.length, ); - const totalBytes = events.reduce( - (sum, e) => sum + (e.type === "data" ? e.data.length : 0), - 0, - ); - console.log( - `[Terminal][${paneId.slice(-8)}] FLUSHING ${events.length} events (${totalBytes} bytes) time=${Date.now()}`, - ); for (const event of events) { if (event.type === "data") { @@ -348,7 +336,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { } } // biome-ignore lint/correctness/useExhaustiveDependencies: refs used intentionally to avoid recreating callback - }, [paneId, setConnectionError]); + }, [setConnectionError]); // biome-ignore lint/correctness/useExhaustiveDependencies: refs (resizeRef, updateCwdRef, rendererRef) used intentionally to read latest values without recreating callback const maybeApplyInitialState = useCallback(() => { @@ -419,54 +407,56 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const isAltScreenReattach = !result.isNew && result.snapshot?.modes.alternateScreen; - // EXPERIMENTAL: For alt-screen (TUI) sessions, the serialized snapshot often - // renders incorrectly because styled spaces and positioning get lost. - // Instead of writing broken snapshot, enter alt-screen and trigger SIGWINCH - // so the TUI redraws itself via the live stream. + // For alt-screen (TUI) sessions, the serialized snapshot often renders + // incorrectly because styled spaces and positioning get lost. Instead of + // writing broken snapshot, enter alt-screen and trigger SIGWINCH so the + // TUI redraws itself via the live stream. + // NOTE: This is primarily a fallback path for app restart recovery. + // During normal workspace/tab switching with persistence enabled, + // terminals stay mounted and this code path is not triggered. if (isAltScreenReattach) { - console.log( - `[Terminal][${paneId.slice(-8)}] ALT-SCREEN REATTACH: skipping snapshot, triggering SIGWINCH redraw`, - ); - - // Enter alt-screen mode so TUI output goes to correct buffer - xterm.write("\x1b[?1049h"); - - // Apply rehydration sequences for other modes (bracketed paste, etc.) - if (result.snapshot?.rehydrateSequences) { - // Filter out alt-screen sequences since we already entered - const ESC = "\x1b"; - const filteredRehydrate = result.snapshot.rehydrateSequences - .split(ESC + "[?1049h") - .join("") - .split(ESC + "[?47h") - .join(""); - if (filteredRehydrate) { - xterm.write(filteredRehydrate); + // Enter alt-screen mode and WAIT for xterm to process it before proceeding. + // xterm.write() is async - if we trigger SIGWINCH before alt-screen is entered, + // the TUI receives SIGWINCH in normal mode, ignores it, then xterm switches + // buffers and we get a white screen. + xterm.write("\x1b[?1049h", () => { + // Apply rehydration sequences for other modes (bracketed paste, etc.) + if (result.snapshot?.rehydrateSequences) { + // Filter out alt-screen sequences since we already entered + const ESC = "\x1b"; + const filteredRehydrate = result.snapshot.rehydrateSequences + .split(ESC + "[?1049h") + .join("") + .split(ESC + "[?47h") + .join(""); + if (filteredRehydrate) { + xterm.write(filteredRehydrate); + } } - } - - // Enable streaming BEFORE resize so TUI output comes through - isStreamReadyRef.current = true; - flushPendingEvents(); - // Fit xterm to container and trigger SIGWINCH - requestAnimationFrame(() => { - if (xtermRef.current !== xterm) return; - fitAddon.fit(); + // NOW safe to enable streaming and flush pending events + isStreamReadyRef.current = true; + flushPendingEvents(); - const cols = xterm.cols; - const rows = xterm.rows; - if (cols > 0 && rows > 0) { - console.log( - `[Terminal][${paneId.slice(-8)}] ALT-SCREEN SIGWINCH: ${cols}x${rows} -> ${cols}x${rows - 1} -> ${cols}x${rows}`, - ); - // Resize down then up to guarantee SIGWINCH - resizeRef.current({ paneId, cols, rows: rows - 1 }); - setTimeout(() => { - if (xtermRef.current !== xterm) return; - resizeRef.current({ paneId, cols, rows }); - }, 100); - } + // Fit xterm to container and trigger SIGWINCH + requestAnimationFrame(() => { + if (xtermRef.current !== xterm) return; + + fitAddon.fit(); + const cols = xterm.cols; + const rows = xterm.rows; + + if (cols > 0 && rows > 0) { + // Resize down then up to guarantee SIGWINCH + resizeRef.current({ paneId, cols, rows: rows - 1 }); + setTimeout(() => { + if (xtermRef.current !== xterm) return; + resizeRef.current({ paneId, cols, rows }); + // Force xterm to repaint after SIGWINCH completes + xterm.refresh(0, rows - 1); + }, 100); + } + }); }); updateCwdRef.current(result.scrollback); @@ -580,10 +570,6 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const handleStreamData = (event: TerminalStreamEvent) => { // Queue events until terminal is ready to prevent data loss if (!xtermRef.current || !isStreamReadyRef.current) { - const dataLen = event.type === "data" ? event.data.length : 0; - console.log( - `[Terminal][${paneId.slice(-8)}] QUEUING event type=${event.type} len=${dataLen} totalQueued=${pendingEventsRef.current.length + 1} time=${Date.now()}`, - ); pendingEventsRef.current.push(event); return; } diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/index.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/index.tsx index fb3908f55f4..8e1331e6ee0 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/index.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/index.tsx @@ -6,19 +6,65 @@ import { TabView } from "./TabView"; export function TabsContent() { const { data: activeWorkspace } = trpc.workspaces.getActive.useQuery(); + const { data: terminalPersistence } = + trpc.settings.getTerminalPersistence.useQuery(); const activeWorkspaceId = activeWorkspace?.id; const allTabs = useTabsStore((s) => s.tabs); const panes = useTabsStore((s) => s.panes); const activeTabIds = useTabsStore((s) => s.activeTabIds); + const activeTabId = activeWorkspaceId + ? activeTabIds[activeWorkspaceId] + : null; + + // Get all tabs for current workspace (for fallback/empty check) + const currentWorkspaceTabs = useMemo(() => { + if (!activeWorkspaceId) return []; + return allTabs.filter((tab) => tab.workspaceId === activeWorkspaceId); + }, [activeWorkspaceId, allTabs]); + const tabToRender = useMemo(() => { - if (!activeWorkspaceId) return null; - const activeTabId = activeTabIds[activeWorkspaceId]; if (!activeTabId) return null; - return allTabs.find((tab) => tab.id === activeTabId) || null; - }, [activeWorkspaceId, activeTabIds, allTabs]); + }, [activeTabId, allTabs]); + + // When terminal persistence is enabled, keep all terminals mounted across + // workspace/tab switches. This prevents TUI white screen issues by avoiding + // the unmount/remount cycle that requires complex reattach/rehydration logic. + // Uses visibility:hidden (not display:none) to preserve xterm dimensions. + if (terminalPersistence) { + // Show empty view only if current workspace has no tabs + if (currentWorkspaceTabs.length === 0) { + return ; + } + + return ( +

+ {allTabs.map((tab) => { + // A tab is visible only if: + // 1. It belongs to the active workspace AND + // 2. It's the active tab for that workspace + const isVisible = + tab.workspaceId === activeWorkspaceId && tab.id === activeTabId; + + return ( +
+ +
+ ); + })} +
+ ); + } + // Original behavior when persistence disabled: only render active tab if (!tabToRender) { return ; } diff --git a/thoughts/ledgers/CONTINUITY_CLAUDE-tui-white-screen.md b/thoughts/ledgers/CONTINUITY_CLAUDE-tui-white-screen.md new file mode 100644 index 00000000000..f9ee095e214 --- /dev/null +++ b/thoughts/ledgers/CONTINUITY_CLAUDE-tui-white-screen.md @@ -0,0 +1,57 @@ +--- +created: 2026-01-02T21:00:00Z +last_updated: 2026-01-02T11:15:00Z +session_count: 3 +status: COMPLETED +--- + +# Session: TUI White Screen on Workspace Switch + +## Goal +Fix the remaining white screen issue when switching back to a workspace with an active TUI (vim, opencode, claude). Currently requires manual resize to fix. + +## Constraints +- Must not regress the original fix (gibberish text on tab switch) +- Must work with Canvas renderer (macOS default) +- Should minimize visual flash during reattach + +## Key Decisions +- Decision 1: Using SIGWINCH approach instead of snapshots for TUI restoration (snapshots don't capture styled spaces) +- Decision 2: Need to ensure alt-screen is fully entered before flushing pending events +- Decision 3: **FINAL** - Keep terminals mounted instead of unmount/remount cycle (Oracle insight: "The moment you create a *new* xterm on remount, you lose emulator state") + +## State +- Done: [x] Captured problem statement + prior fix summary +- Done: [x] Identified alt-screen reattach path in Terminal.tsx +- Done: [x] Analyzed timing of current reattach flow +- Done: [x] Identified 3 likely root causes (ranked by probability) +- Done: [x] Consulted Oracle - discovered fundamental issue with unmount/remount +- Done: [x] Implemented "keep terminals mounted" solution +- Done: [x] Added memory warning to settings +- Done: [x] Removed debug logging +- Done: [x] Updated technical documentation +- Done: [x] User verified: "omg everything feels buttery smooth now!" + +- Complete: [✓] **BUG RESOLVED** + +## Resolution Summary + +**Root Cause:** The SIGWINCH approach was fundamentally fragile. React unmounts Terminal components on workspace switch, destroying xterm.js instances. New xterm on remount loses all emulator state - race conditions were inevitable. + +**Solution:** Keep all terminal components mounted across workspace/tab switches. Use CSS `visibility: hidden` for inactive tabs. Gate behind `terminalPersistence` setting. + +**Files Modified:** +- `TabsContent/index.tsx` - Render all tabs, hide inactive with CSS +- `TerminalSettings.tsx` - Added memory warning +- `Terminal.tsx` - Removed debug logging, kept SIGWINCH as fallback for app restart +- `2026-01-02-terminal-persistence-technical-notes.md` - Documented approach + +## Open Questions (Answered) +- ~~Is xterm.write("\x1b[?1049h") async issue the primary cause?~~ **No - fundamental unmount issue** +- ~~Are container dimensions 0 during workspace switch?~~ **Moot - terminals stay mounted** +- ~~Does xterm.refresh() help after SIGWINCH?~~ **Moot - no more remount cycle** + +## Working Set +- Branch: `persistent-terminals` +- PR: #541 +- Status: Changes ready to commit diff --git a/thoughts/shared/handoffs/tui-white-screen/auto-handoff-2026-01-02T12-58-19.md b/thoughts/shared/handoffs/tui-white-screen/auto-handoff-2026-01-02T12-58-19.md new file mode 100644 index 00000000000..e7423bb6d51 --- /dev/null +++ b/thoughts/shared/handoffs/tui-white-screen/auto-handoff-2026-01-02T12-58-19.md @@ -0,0 +1,31 @@ +--- +type: auto-handoff +date: 2026-01-02T12:58:19.863Z +session_name: tui-white-screen +trigger: pre-compact (opencode) +--- + +# Auto-Handoff: [→] Implement diagnostic logging to confirm root cause + +This handoff was automatically created before context compaction. + +## In Progress + +[→] Implement diagnostic logging to confirm root cause + +## Recent Completed + +[x] Captured problem statement + prior fix summary +- Done: [x] Identified alt-screen reattach path in Terminal.tsx +- Done: [x] Analyzed timing of current reattach flow +- Done: [x] Identified 3 likely root causes (ranked by probability) + +## Resume Instructions + +1. Read this handoff to understand current state +2. Check the ledger for full context: thoughts/ledgers/CONTINUITY_CLAUDE-tui-white-screen.md +3. Continue from where you left off + +## Source Ledger + +/Users/andreasasprou/.superset/worktrees/superset/persistent-terminals/thoughts/ledgers/CONTINUITY_CLAUDE-tui-white-screen.md diff --git a/thoughts/shared/handoffs/tui-white-screen/auto-handoff-2026-01-02T14-14-50.md b/thoughts/shared/handoffs/tui-white-screen/auto-handoff-2026-01-02T14-14-50.md new file mode 100644 index 00000000000..e038ed0c66e --- /dev/null +++ b/thoughts/shared/handoffs/tui-white-screen/auto-handoff-2026-01-02T14-14-50.md @@ -0,0 +1,31 @@ +--- +type: auto-handoff +date: 2026-01-02T14:14:50.011Z +session_name: tui-white-screen +trigger: pre-compact (opencode) +--- + +# Auto-Handoff: [→] Implement diagnostic logging to confirm root cause + +This handoff was automatically created before context compaction. + +## In Progress + +[→] Implement diagnostic logging to confirm root cause + +## Recent Completed + +[x] Captured problem statement + prior fix summary +- Done: [x] Identified alt-screen reattach path in Terminal.tsx +- Done: [x] Analyzed timing of current reattach flow +- Done: [x] Identified 3 likely root causes (ranked by probability) + +## Resume Instructions + +1. Read this handoff to understand current state +2. Check the ledger for full context: thoughts/ledgers/CONTINUITY_CLAUDE-tui-white-screen.md +3. Continue from where you left off + +## Source Ledger + +/Users/andreasasprou/.superset/worktrees/superset/persistent-terminals/thoughts/ledgers/CONTINUITY_CLAUDE-tui-white-screen.md From 536d6ea01a41f56b14acc4d7b606ab0a61b73fd5 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Fri, 2 Jan 2026 17:52:40 +0200 Subject: [PATCH 91/98] perf(desktop): remove duplicate scrollback payload in daemon mode MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit In daemon mode, both scrollback and snapshot.snapshotAnsi contained identical ANSI content, doubling IPC payload size (~500KB → 1MB). Changes: - daemon-manager: set scrollback to empty string in daemon mode - Terminal.tsx: use initialAnsi variable preferring snapshot.snapshotAnsi - Terminal.tsx: use snapshot.cwd directly instead of parsing ANSI - Terminal.tsx: only run escape scanning when snapshot.modes unavailable - types.ts: add JSDoc clarifying daemon mode behavior ~50% reduction in IPC payload for terminal sessions. --- .../src/main/lib/terminal/daemon-manager.ts | 6 ++- apps/desktop/src/main/lib/terminal/types.ts | 5 +++ .../TabsContent/Terminal/Terminal.tsx | 39 ++++++++++++------- 3 files changed, 35 insertions(+), 15 deletions(-) diff --git a/apps/desktop/src/main/lib/terminal/daemon-manager.ts b/apps/desktop/src/main/lib/terminal/daemon-manager.ts index 04f82bbae9f..c67ee3644cf 100644 --- a/apps/desktop/src/main/lib/terminal/daemon-manager.ts +++ b/apps/desktop/src/main/lib/terminal/daemon-manager.ts @@ -236,8 +236,10 @@ export class DaemonTerminalManager extends EventEmitter { return { isNew: response.isNew, - // For backwards compatibility, provide scrollback from snapshot - scrollback: response.snapshot.snapshotAnsi, + // In daemon mode, snapshot.snapshotAnsi is the canonical content source. + // We set scrollback to empty to avoid duplicating the payload over IPC. + // The renderer should prefer snapshot.snapshotAnsi when available. + scrollback: "", wasRecovered: response.wasRecovered, snapshot: { snapshotAnsi: response.snapshot.snapshotAnsi, diff --git a/apps/desktop/src/main/lib/terminal/types.ts b/apps/desktop/src/main/lib/terminal/types.ts index 1c656a7534e..eebd65bc949 100644 --- a/apps/desktop/src/main/lib/terminal/types.ts +++ b/apps/desktop/src/main/lib/terminal/types.ts @@ -39,6 +39,11 @@ export type TerminalEvent = TerminalDataEvent | TerminalExitEvent; export interface SessionResult { isNew: boolean; + /** + * Initial terminal content (ANSI). + * In daemon mode, this is empty - prefer `snapshot.snapshotAnsi` when available. + * In non-daemon mode, this contains the recovered scrollback content. + */ scrollback: string; wasRecovered: boolean; /** Snapshot from daemon (if using daemon mode) */ diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index cf2a334417b..b47968b2926 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -353,33 +353,36 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { const restoreSequence = ++restoreSequenceRef.current; try { + // Canonical initial content: prefer snapshot (daemon mode) over scrollback (non-daemon) + // In daemon mode, scrollback is empty to avoid duplicating the payload over IPC. + const initialAnsi = result.snapshot?.snapshotAnsi ?? result.scrollback; + // Track alternate screen mode from snapshot for our own reference // (xterm.buffer.active.type is unreliable after HMR/recovery) isAlternateScreenRef.current = !!result.snapshot?.modes.alternateScreen; isBracketedPasteRef.current = !!result.snapshot?.modes.bracketedPaste; modeScanBufferRef.current = ""; - // Also parse scrollback for escape sequences in case snapshot.modes is incomplete - // This handles cases where the daemon didn't track the mode but the sequences are in history - if (result.scrollback) { + // Fallback: parse initialAnsi for escape sequences when snapshot.modes is unavailable. + // This handles non-daemon mode and edge cases where daemon didn't track the mode. + if (initialAnsi && result.snapshot?.modes === undefined) { // Use lastIndexOf to find the final state - handles multiple enter/exit cycles // (e.g., user opened vim, closed it, opened it again) const enterAltIndex = Math.max( - result.scrollback.lastIndexOf("\x1b[?1049h"), - result.scrollback.lastIndexOf("\x1b[?47h"), + initialAnsi.lastIndexOf("\x1b[?1049h"), + initialAnsi.lastIndexOf("\x1b[?47h"), ); const exitAltIndex = Math.max( - result.scrollback.lastIndexOf("\x1b[?1049l"), - result.scrollback.lastIndexOf("\x1b[?47l"), + initialAnsi.lastIndexOf("\x1b[?1049l"), + initialAnsi.lastIndexOf("\x1b[?47l"), ); if (enterAltIndex !== -1 || exitAltIndex !== -1) { isAlternateScreenRef.current = enterAltIndex > exitAltIndex; } // Bracketed paste mode can toggle during a session - use the last seen state. - const bracketEnableIndex = result.scrollback.lastIndexOf("\x1b[?2004h"); - const bracketDisableIndex = - result.scrollback.lastIndexOf("\x1b[?2004l"); + const bracketEnableIndex = initialAnsi.lastIndexOf("\x1b[?2004h"); + const bracketDisableIndex = initialAnsi.lastIndexOf("\x1b[?2004l"); if (bracketEnableIndex !== -1 || bracketDisableIndex !== -1) { isBracketedPasteRef.current = bracketEnableIndex > bracketDisableIndex; @@ -459,7 +462,12 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { }); }); - updateCwdRef.current(result.scrollback); + // Use snapshot.cwd if available, otherwise parse from content + if (result.snapshot?.cwd) { + updateCwdRef.current(result.snapshot.cwd); + } else { + updateCwdRef.current(initialAnsi); + } return; // Skip normal snapshot flow } @@ -468,7 +476,7 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { // Force a re-render after write completes to ensure correct display. // (Symptom: restored terminals show corrupted text until resized) // Use fitAddon.fit() and (when using WebGL) clear the glyph atlas to force a full repaint. - xterm.write(result.scrollback, () => { + xterm.write(initialAnsi, () => { const redraw = () => { requestAnimationFrame(() => { try { @@ -520,7 +528,12 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { isStreamReadyRef.current = true; flushPendingEvents(); }); - updateCwdRef.current(result.scrollback); + // Use snapshot.cwd if available, otherwise parse from content + if (result.snapshot?.cwd) { + updateCwdRef.current(result.snapshot.cwd); + } else { + updateCwdRef.current(initialAnsi); + } } catch (error) { console.error("[Terminal] Restoration failed:", error); } From f83e3e72747dd25dd862d0aec8a21c96f1c74f8a Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Fri, 2 Jan 2026 18:53:51 +0200 Subject: [PATCH 92/98] chore(desktop): remove unused code and fix style issues - Remove unused ptyPid property from Session - Remove unused flushEmulatorWrites method (superseded by flushEmulatorWritesUpTo) - Remove unused getSession method (superseded by getActiveSession) - Fix template literal style in Terminal.tsx - Fix export ordering in hooks/index.ts --- .../desktop/src/main/terminal-host/session.ts | 22 ------------------- .../src/main/terminal-host/terminal-host.ts | 15 ------------- .../TabsContent/Terminal/Terminal.tsx | 5 ++--- .../TabsContent/Terminal/hooks/index.ts | 2 +- 4 files changed, 3 insertions(+), 41 deletions(-) diff --git a/apps/desktop/src/main/terminal-host/session.ts b/apps/desktop/src/main/terminal-host/session.ts index 1202df489ea..9b7c95276c7 100644 --- a/apps/desktop/src/main/terminal-host/session.ts +++ b/apps/desktop/src/main/terminal-host/session.ts @@ -83,7 +83,6 @@ export class Session { private subprocess: ChildProcess | null = null; private subprocessReady = false; - private ptyPid: number | null = null; private emulator: HeadlessEmulator; private attachedClients: Map = new Map(); private clientSocketsWaitingForDrain: Set = new Set(); @@ -587,27 +586,6 @@ export class Session { for (const resolve of waiters) resolve(); } - private async flushEmulatorWrites(timeoutMs?: number): Promise { - if (this.emulatorWriteQueue.length === 0 && !this.emulatorWriteScheduled) { - return; - } - - const flushPromise = new Promise((resolve) => { - this.emulatorFlushWaiters.push(resolve); - this.scheduleEmulatorWrite(); - }); - - if (timeoutMs !== undefined) { - // Race against timeout to prevent indefinite hang with continuous output - await Promise.race([ - flushPromise, - new Promise((resolve) => setTimeout(resolve, timeoutMs)), - ]); - } else { - await flushPromise; - } - } - /** * Flush emulator writes up to current queue position (snapshot boundary). * Unlike flushEmulatorWrites, this captures a consistent point-in-time state diff --git a/apps/desktop/src/main/terminal-host/terminal-host.ts b/apps/desktop/src/main/terminal-host/terminal-host.ts index 57d199c253c..5fb7f49c667 100644 --- a/apps/desktop/src/main/terminal-host/terminal-host.ts +++ b/apps/desktop/src/main/terminal-host/terminal-host.ts @@ -270,21 +270,6 @@ export class TerminalHost { this.sessions.clear(); } - // =========================================================================== - // Private Methods - // =========================================================================== - - /** - * Get a session by ID, throw if not found - */ - private getSession(sessionId: string): Session { - const session = this.sessions.get(sessionId); - if (!session) { - throw new Error(`Session not found: ${sessionId}`); - } - return session; - } - /** * Get an active (attachable) session by ID. * Throws if session doesn't exist or is terminating. diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx index b47968b2926..2a78aa5740d 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/Terminal.tsx @@ -335,7 +335,6 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { } } } - // biome-ignore lint/correctness/useExhaustiveDependencies: refs used intentionally to avoid recreating callback }, [setConnectionError]); // biome-ignore lint/correctness/useExhaustiveDependencies: refs (resizeRef, updateCwdRef, rendererRef) used intentionally to read latest values without recreating callback @@ -428,9 +427,9 @@ export const Terminal = ({ tabId, workspaceId }: TerminalProps) => { // Filter out alt-screen sequences since we already entered const ESC = "\x1b"; const filteredRehydrate = result.snapshot.rehydrateSequences - .split(ESC + "[?1049h") + .split(`${ESC}[?1049h`) .join("") - .split(ESC + "[?47h") + .split(`${ESC}[?47h`) .join(""); if (filteredRehydrate) { xterm.write(filteredRehydrate); diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/hooks/index.ts b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/hooks/index.ts index 7b3a4dcbde0..dc089375c36 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/hooks/index.ts +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/Terminal/hooks/index.ts @@ -1,2 +1,2 @@ -export { useTerminalConnection } from "./useTerminalConnection"; export type { UseTerminalConnectionOptions } from "./useTerminalConnection"; +export { useTerminalConnection } from "./useTerminalConnection"; From df93762bcccb70a8c64f34a9f5b114f39f6df617 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Sat, 3 Jan 2026 10:29:37 +0200 Subject: [PATCH 93/98] feat(desktop): add 3-color workspace status indicators MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Implements workspace status indicators showing agent lifecycle states: - Amber (pulsing): Agent actively processing - Red (pulsing): Agent blocked, needs user input - Green (static): Agent completed, ready for review Key features: - Status aggregation: workspace shows highest-priority status across all panes - Click behavior: review → idle, permission → working, working unchanged - App restart: stale 'working' status cleared on startup - Migration: old needsAttention boolean migrated to status enum Dev/prod separation hardening: - Removed global OpenCode plugin write (was causing cross-talk) - Added startup cleanup for stale global plugins - Server ignores unknown event types (forward compatibility) - notify.sh no longer defaults to 'Stop' on parse failure - Added SUPERSET_ENV and SUPERSET_HOOK_VERSION to terminal environment - Server validates environment and logs mismatches --- apps/desktop/docs/EXTERNAL_FILES.md | 99 +++++++++++++ .../src/lib/trpc/routers/notifications.ts | 19 +-- .../main/lib/agent-setup/agent-wrappers.ts | 57 ++++++-- .../desktop/src/main/lib/agent-setup/index.ts | 4 + .../src/main/lib/agent-setup/notify-hook.ts | 19 ++- .../src/main/lib/notifications/server.test.ts | 41 ++++++ .../src/main/lib/notifications/server.ts | 134 ++++++++++++++++-- .../desktop/src/main/lib/terminal/env.test.ts | 12 ++ apps/desktop/src/main/lib/terminal/env.ts | 18 ++- apps/desktop/src/main/windows/main.ts | 11 +- .../TopBar/WorkspaceTabs/WorkspaceItem.tsx | 50 +++++-- .../WorkspaceListItem/WorkspaceListItem.tsx | 50 +++++-- .../TabsContent/GroupStrip/GroupStrip.tsx | 49 +++++-- .../Sidebar/TabsView/TabItem/index.tsx | 39 ++++- .../desktop/src/renderer/stores/tabs/store.ts | 85 ++++++++--- .../desktop/src/renderer/stores/tabs/types.ts | 14 +- .../stores/tabs/useAgentHookListener.ts | 37 +++-- apps/desktop/src/shared/constants.ts | 2 +- apps/desktop/src/shared/tabs-types.ts | 11 +- 19 files changed, 630 insertions(+), 121 deletions(-) create mode 100644 apps/desktop/docs/EXTERNAL_FILES.md create mode 100644 apps/desktop/src/main/lib/notifications/server.test.ts diff --git a/apps/desktop/docs/EXTERNAL_FILES.md b/apps/desktop/docs/EXTERNAL_FILES.md new file mode 100644 index 00000000000..9e3f5d0fca9 --- /dev/null +++ b/apps/desktop/docs/EXTERNAL_FILES.md @@ -0,0 +1,99 @@ +# External Files Written by Superset Desktop + +This document lists all files written by the Superset desktop app outside of user projects. +Understanding these files is critical for maintaining dev/prod separation and avoiding conflicts. + +## Environment-Specific Directories + +The app uses different home directories based on environment: +- **Development**: `~/.superset-dev/` +- **Production**: `~/.superset/` + +This separation prevents dev and prod from interfering with each other. + +## Files in `~/.superset[-dev]/` + +### `bin/` - Agent Wrapper Scripts + +| File | Purpose | +|------|---------| +| `claude` | Wrapper for Claude Code CLI that injects notification hooks | +| `codex` | Wrapper for Codex CLI that injects notification hooks | +| `opencode` | Wrapper for OpenCode CLI that sets `OPENCODE_CONFIG_DIR` | + +These wrappers are added to `PATH` via shell integration, allowing them to intercept +agent commands and inject Superset-specific configuration. + +### `hooks/` - Notification Hook Scripts + +| File | Purpose | +|------|---------| +| `notify.sh` | Shell script called by agents when they complete or need input | +| `claude-settings.json` | Claude Code settings file with hook configuration | +| `opencode/plugin/superset-notify.js` | OpenCode plugin for lifecycle events | + +### `zsh/` and `bash/` - Shell Integration + +| File | Purpose | +|------|---------| +| `init.zsh` | Zsh initialization script (sources .zshrc, sets up PATH) | +| `init.bash` | Bash initialization script (sources .bashrc, sets up PATH) | + +## Global Files (AVOID ADDING NEW ONES) + +**DO NOT write to global locations** like `~/.config/`, `~/Library/`, etc. +These cause dev/prod conflicts when both environments are running. + +### Known Issues with Global Files + +Previously, the OpenCode plugin was written to `~/.config/opencode/plugin/superset-notify.js`. +This caused severe issues: +1. Dev would overwrite prod's plugin with incompatible protocol +2. Prod terminals would send events that dev's server couldn't handle +3. Users received spam notifications for every agent message + +**Solution**: The global plugin is no longer written. On startup, any stale global plugin +with our marker is deleted to prevent conflicts from older versions. + +## Shell RC File Modifications + +The app modifies shell RC files to add the Superset bin directory to PATH: + +| Shell | RC File | Modification | +|-------|---------|--------------| +| Zsh | `~/.zshrc` | Prepends `~/.superset[-dev]/bin` to PATH | +| Bash | `~/.bashrc` | Prepends `~/.superset[-dev]/bin` to PATH | + +## Terminal Environment Variables + +Each terminal session receives these environment variables: + +| Variable | Purpose | +|----------|---------| +| `SUPERSET_PANE_ID` | Unique identifier for the terminal pane | +| `SUPERSET_TAB_ID` | Identifier for the containing tab | +| `SUPERSET_WORKSPACE_ID` | Identifier for the workspace | +| `SUPERSET_WORKSPACE_NAME` | Human-readable workspace name | +| `SUPERSET_WORKSPACE_PATH` | Filesystem path to the workspace | +| `SUPERSET_ROOT_PATH` | Root path of the project | +| `SUPERSET_PORT` | Port for the notification server | +| `SUPERSET_ENV` | Environment (`development` or `production`) | +| `SUPERSET_HOOK_VERSION` | Hook protocol version for compatibility | + +## Adding New External Files + +Before adding new files outside of `~/.superset[-dev]/`: + +1. **Consider if it's necessary** - Can you use the environment-specific directory instead? +2. **Check for conflicts** - Will dev and prod overwrite each other? +3. **Update this document** - Add the file to the appropriate section +4. **Add cleanup logic** - If migrating from global to local, clean up the old location + +## Debugging Cross-Environment Issues + +If you suspect dev/prod cross-talk: + +1. Check logs for "Environment mismatch" warnings +2. Verify `SUPERSET_ENV` and `SUPERSET_PORT` are set correctly in terminal +3. Delete stale global files: `rm -rf ~/.config/opencode/plugin/superset-notify.js` +4. Restart both dev and prod apps to regenerate hooks diff --git a/apps/desktop/src/lib/trpc/routers/notifications.ts b/apps/desktop/src/lib/trpc/routers/notifications.ts index eb539b8122a..f90d264b6f6 100644 --- a/apps/desktop/src/lib/trpc/routers/notifications.ts +++ b/apps/desktop/src/lib/trpc/routers/notifications.ts @@ -1,6 +1,6 @@ import { observable } from "@trpc/server/observable"; import { - type AgentCompleteEvent, + type AgentLifecycleEvent, type NotificationIds, notificationsEmitter, } from "main/lib/notifications/server"; @@ -9,8 +9,8 @@ import { publicProcedure, router } from ".."; type NotificationEvent = | { - type: typeof NOTIFICATION_EVENTS.AGENT_COMPLETE; - data?: AgentCompleteEvent; + type: typeof NOTIFICATION_EVENTS.AGENT_LIFECYCLE; + data?: AgentLifecycleEvent; } | { type: typeof NOTIFICATION_EVENTS.FOCUS_TAB; data?: NotificationIds }; @@ -18,21 +18,24 @@ export const createNotificationsRouter = () => { return router({ subscribe: publicProcedure.subscription(() => { return observable((emit) => { - const onComplete = (data: AgentCompleteEvent) => { - emit.next({ type: NOTIFICATION_EVENTS.AGENT_COMPLETE, data }); + const onLifecycle = (data: AgentLifecycleEvent) => { + emit.next({ type: NOTIFICATION_EVENTS.AGENT_LIFECYCLE, data }); }; const onFocusTab = (data: NotificationIds) => { emit.next({ type: NOTIFICATION_EVENTS.FOCUS_TAB, data }); }; - notificationsEmitter.on(NOTIFICATION_EVENTS.AGENT_COMPLETE, onComplete); + notificationsEmitter.on( + NOTIFICATION_EVENTS.AGENT_LIFECYCLE, + onLifecycle, + ); notificationsEmitter.on(NOTIFICATION_EVENTS.FOCUS_TAB, onFocusTab); return () => { notificationsEmitter.off( - NOTIFICATION_EVENTS.AGENT_COMPLETE, - onComplete, + NOTIFICATION_EVENTS.AGENT_LIFECYCLE, + onLifecycle, ); notificationsEmitter.off(NOTIFICATION_EVENTS.FOCUS_TAB, onFocusTab); }; diff --git a/apps/desktop/src/main/lib/agent-setup/agent-wrappers.ts b/apps/desktop/src/main/lib/agent-setup/agent-wrappers.ts index 0ced8cdacb6..349cdf2895c 100644 --- a/apps/desktop/src/main/lib/agent-setup/agent-wrappers.ts +++ b/apps/desktop/src/main/lib/agent-setup/agent-wrappers.ts @@ -12,7 +12,7 @@ import { export const WRAPPER_MARKER = "# Superset agent-wrapper v1"; export const CLAUDE_SETTINGS_FILE = "claude-settings.json"; export const OPENCODE_PLUGIN_FILE = "superset-notify.js"; -export const OPENCODE_PLUGIN_MARKER = "// Superset opencode plugin v3"; +export const OPENCODE_PLUGIN_MARKER = "// Superset opencode plugin v4"; const REAL_BINARY_RESOLVER = `find_real_binary() { local name="$1" @@ -72,6 +72,7 @@ export function getOpenCodeGlobalPluginPath(): string { export function getClaudeSettingsContent(notifyPath: string): string { const settings = { hooks: { + UserPromptSubmit: [{ hooks: [{ type: "command", command: notifyPath }] }], Stop: [{ hooks: [{ type: "command", command: notifyPath }] }], PermissionRequest: [ { matcher: "*", hooks: [{ type: "command", command: notifyPath }] }, @@ -144,7 +145,7 @@ export function getOpenCodePluginContent(notifyPath: string): string { " * Superset Notification Plugin for OpenCode", " *", " * This plugin sends desktop notifications when OpenCode sessions need attention.", - " * It hooks into session.idle, session.error, and permission.ask events.", + " * It hooks into session.status (busy/idle), session.error, and permission.ask events.", " *", " * IMPORTANT: Subagent/Background Task Filtering", " * --------------------------------------------", @@ -164,8 +165,8 @@ export function getOpenCodePluginContent(notifyPath: string): string { " * @see https://github.com/sst/opencode/blob/dev/packages/app/src/context/notification.tsx", " */", "export const SupersetNotifyPlugin = async ({ $, client }) => {", - " if (globalThis.__supersetOpencodeNotifyPluginV3) return {};", - " globalThis.__supersetOpencodeNotifyPluginV3 = true;", + " if (globalThis.__supersetOpencodeNotifyPluginV4) return {};", + " globalThis.__supersetOpencodeNotifyPluginV4 = true;", "", " // Only run inside a Superset terminal session", " if (!process?.env?.SUPERSET_TAB_ID) return {};", @@ -216,16 +217,29 @@ export function getOpenCodePluginContent(notifyPath: string): string { "", " return {", " event: async ({ event }) => {", - " // Handle session completion events", - ' if (event.type === "session.idle" || event.type === "session.error") {', + " // Handle session status changes (busy = working, idle = done)", + ' if (event.type === "session.status") {', " const sessionID = event.properties?.sessionID;", + " const status = event.properties?.status;", "", " // Skip notifications for child/subagent sessions", - " // This prevents notification spam when background agents complete", " if (await isChildSession(sessionID)) {", " return;", " }", "", + ' if (status?.type === "busy") {', + ' await notify("Start");', + ' } else if (status?.type === "idle") {', + ' await notify("Stop");', + " }", + " }", + "", + " // Handle session errors (also means session stopped)", + ' if (event.type === "session.error") {', + " const sessionID = event.properties?.sessionID;", + " if (await isChildSession(sessionID)) {", + " return;", + " }", ' await notify("Stop");', " }", " },", @@ -275,24 +289,43 @@ export function createCodexWrapper(): void { } /** - * Creates OpenCode plugin file with notification hooks + * Creates OpenCode plugin file with notification hooks. + * Only writes to environment-specific path - NOT the global path. + * Global path causes dev/prod conflicts when both are running. */ export function createOpenCodePlugin(): void { const pluginPath = getOpenCodePluginPath(); const notifyPath = getNotifyScriptPath(); const content = getOpenCodePluginContent(notifyPath); fs.writeFileSync(pluginPath, content, { mode: 0o644 }); + console.log("[agent-setup] Created OpenCode plugin"); +} + +/** + * Cleans up stale global OpenCode plugin that may have been written by older versions. + * Only removes if the file contains our marker to avoid deleting user-installed plugins. + * This prevents dev/prod cross-talk when both environments are running. + */ +export function cleanupGlobalOpenCodePlugin(): void { try { const globalPluginPath = getOpenCodeGlobalPluginPath(); - fs.mkdirSync(path.dirname(globalPluginPath), { recursive: true }); - fs.writeFileSync(globalPluginPath, content, { mode: 0o644 }); + if (!fs.existsSync(globalPluginPath)) return; + + const content = fs.readFileSync(globalPluginPath, "utf-8"); + // Check for any version of our marker (v1, v2, v3, v4, etc.) + if (content.includes("// Superset opencode plugin")) { + fs.unlinkSync(globalPluginPath); + console.log( + "[agent-setup] Removed stale global OpenCode plugin to prevent dev/prod conflicts", + ); + } } catch (error) { + // Ignore errors - this is best-effort cleanup console.warn( - "[agent-setup] Failed to write global OpenCode plugin:", + "[agent-setup] Failed to cleanup global OpenCode plugin:", error, ); } - console.log("[agent-setup] Created OpenCode plugin"); } /** diff --git a/apps/desktop/src/main/lib/agent-setup/index.ts b/apps/desktop/src/main/lib/agent-setup/index.ts index d0ac5cb3ea4..e2ca3b6c82a 100644 --- a/apps/desktop/src/main/lib/agent-setup/index.ts +++ b/apps/desktop/src/main/lib/agent-setup/index.ts @@ -1,5 +1,6 @@ import fs from "node:fs"; import { + cleanupGlobalOpenCodePlugin, createClaudeWrapper, createCodexWrapper, createOpenCodePlugin, @@ -34,6 +35,9 @@ export function setupAgentHooks(): void { fs.mkdirSync(BASH_DIR, { recursive: true }); fs.mkdirSync(OPENCODE_PLUGIN_DIR, { recursive: true }); + // Clean up stale global plugins that may cause dev/prod conflicts + cleanupGlobalOpenCodePlugin(); + // Create scripts createNotifyScript(); createClaudeWrapper(); diff --git a/apps/desktop/src/main/lib/agent-setup/notify-hook.ts b/apps/desktop/src/main/lib/agent-setup/notify-hook.ts index c583486a9a5..6940eca38f4 100644 --- a/apps/desktop/src/main/lib/agent-setup/notify-hook.ts +++ b/apps/desktop/src/main/lib/agent-setup/notify-hook.ts @@ -26,17 +26,26 @@ else fi # Extract event type - Claude uses "hook_event_name", Codex uses "type" -EVENT_TYPE=$(echo "$INPUT" | grep -o '"hook_event_name":"[^"]*"' | cut -d'"' -f4) +# Use flexible pattern to handle optional whitespace: "key": "value" or "key":"value" +EVENT_TYPE=$(echo "$INPUT" | grep -oE '"hook_event_name"[[:space:]]*:[[:space:]]*"[^"]*"' | grep -oE '"[^"]*"$' | tr -d '"') if [ -z "$EVENT_TYPE" ]; then # Check for Codex "type" field (e.g., "agent-turn-complete") - CODEX_TYPE=$(echo "$INPUT" | grep -o '"type":"[^"]*"' | cut -d'"' -f4) + CODEX_TYPE=$(echo "$INPUT" | grep -oE '"type"[[:space:]]*:[[:space:]]*"[^"]*"' | grep -oE '"[^"]*"$' | tr -d '"') if [ "$CODEX_TYPE" = "agent-turn-complete" ]; then EVENT_TYPE="Stop" fi fi -# Default to "Stop" if not found -[ -z "$EVENT_TYPE" ] && EVENT_TYPE="Stop" +# NOTE: We intentionally do NOT default to "Stop" if EVENT_TYPE is empty. +# Parse failures should not trigger completion notifications. +# The server will ignore requests with missing eventType (forward compatibility). + +# Map UserPromptSubmit to Start for simpler handling +[ "$EVENT_TYPE" = "UserPromptSubmit" ] && EVENT_TYPE="Start" + +# If no event type was found, skip the notification +# This prevents parse failures from causing false completion notifications +[ -z "$EVENT_TYPE" ] && exit 0 # Timeouts prevent blocking agent completion if notification server is unresponsive curl -sG "http://127.0.0.1:\${SUPERSET_PORT:-${PORTS.NOTIFICATIONS}}/hook/complete" \\ @@ -45,6 +54,8 @@ curl -sG "http://127.0.0.1:\${SUPERSET_PORT:-${PORTS.NOTIFICATIONS}}/hook/comple --data-urlencode "tabId=$SUPERSET_TAB_ID" \\ --data-urlencode "workspaceId=$SUPERSET_WORKSPACE_ID" \\ --data-urlencode "eventType=$EVENT_TYPE" \\ + --data-urlencode "env=$SUPERSET_ENV" \\ + --data-urlencode "version=$SUPERSET_HOOK_VERSION" \\ > /dev/null 2>&1 `; } diff --git a/apps/desktop/src/main/lib/notifications/server.test.ts b/apps/desktop/src/main/lib/notifications/server.test.ts new file mode 100644 index 00000000000..94e095508e9 --- /dev/null +++ b/apps/desktop/src/main/lib/notifications/server.test.ts @@ -0,0 +1,41 @@ +import { describe, expect, it } from "bun:test"; +import { mapEventType } from "./server"; + +describe("notifications/server", () => { + describe("mapEventType", () => { + it("should map 'Start' to 'Start'", () => { + expect(mapEventType("Start")).toBe("Start"); + }); + + it("should map 'UserPromptSubmit' to 'Start'", () => { + expect(mapEventType("UserPromptSubmit")).toBe("Start"); + }); + + it("should map 'Stop' to 'Stop'", () => { + expect(mapEventType("Stop")).toBe("Stop"); + }); + + it("should map 'agent-turn-complete' to 'Stop'", () => { + expect(mapEventType("agent-turn-complete")).toBe("Stop"); + }); + + it("should map 'PermissionRequest' to 'PermissionRequest'", () => { + expect(mapEventType("PermissionRequest")).toBe("PermissionRequest"); + }); + + it("should return null for unknown event types (forward compatibility)", () => { + expect(mapEventType("UnknownEvent")).toBeNull(); + expect(mapEventType("FutureEvent")).toBeNull(); + expect(mapEventType("SomeNewHook")).toBeNull(); + }); + + it("should return null for undefined eventType (not default to Stop)", () => { + // This is critical: missing eventType should NOT trigger a completion notification + expect(mapEventType(undefined)).toBeNull(); + }); + + it("should return null for empty string eventType", () => { + expect(mapEventType("")).toBeNull(); + }); + }); +}); diff --git a/apps/desktop/src/main/lib/notifications/server.ts b/apps/desktop/src/main/lib/notifications/server.ts index a27398d46f0..3c72e753a1f 100644 --- a/apps/desktop/src/main/lib/notifications/server.ts +++ b/apps/desktop/src/main/lib/notifications/server.ts @@ -1,6 +1,15 @@ import { EventEmitter } from "node:events"; import express from "express"; import { NOTIFICATION_EVENTS } from "shared/constants"; +import { env } from "shared/env.shared"; +import { appState } from "../app-state"; + +/** + * The environment this server is running in. + * Used to validate incoming hook requests and detect cross-environment issues. + */ +const SERVER_ENV = + env.NODE_ENV === "development" ? "development" : "production"; export interface NotificationIds { paneId?: string; @@ -8,8 +17,8 @@ export interface NotificationIds { workspaceId?: string; } -export interface AgentCompleteEvent extends NotificationIds { - eventType: "Stop" | "PermissionRequest"; +export interface AgentLifecycleEvent extends NotificationIds { + eventType: "Start" | "Stop" | "PermissionRequest"; } export const notificationsEmitter = new EventEmitter(); @@ -29,20 +38,127 @@ app.use((req, res, next) => { next(); }); -// Agent completion hook +/** + * Maps incoming event types to canonical lifecycle events. + * Handles variations from different agent CLIs. + * + * Returns null for unknown events - caller should ignore these gracefully + * to maintain forward compatibility with newer hook versions. + * + * Note: We no longer default missing eventType to "Stop" to prevent + * parse failures from being treated as completions. + * + * @internal Exported for testing + */ +export function mapEventType( + eventType: string | undefined, +): "Start" | "Stop" | "PermissionRequest" | null { + if (!eventType) { + return null; // Missing eventType should be ignored, not treated as Stop + } + if (eventType === "Start" || eventType === "UserPromptSubmit") { + return "Start"; + } + if (eventType === "PermissionRequest") { + return "PermissionRequest"; + } + if (eventType === "Stop" || eventType === "agent-turn-complete") { + return "Stop"; + } + return null; // Unknown events are ignored for forward compatibility +} + +/** + * Resolves paneId from tabId or workspaceId using synced tabs state. + * Falls back to focused pane in active tab. + */ +function resolvePaneId( + paneId: string | undefined, + tabId: string | undefined, + workspaceId: string | undefined, +): string | undefined { + if (paneId) return paneId; + + try { + const tabsState = appState.data.tabsState; + if (!tabsState) return undefined; + + // Try to resolve from tabId + if (tabId) { + const focusedPaneId = tabsState.focusedPaneIds?.[tabId]; + if (focusedPaneId) return focusedPaneId; + } + + // Try to resolve from workspaceId + if (workspaceId) { + const activeTabId = tabsState.activeTabIds?.[workspaceId]; + if (activeTabId) { + const focusedPaneId = tabsState.focusedPaneIds?.[activeTabId]; + if (focusedPaneId) return focusedPaneId; + } + } + } catch { + // App state not initialized yet, ignore + } + + return undefined; +} + +// Agent lifecycle hook app.get("/hook/complete", (req, res) => { - const { paneId, tabId, workspaceId, eventType } = req.query; + const { + paneId, + tabId, + workspaceId, + eventType, + env: clientEnv, + version, + } = req.query; + + // Environment validation: detect dev/prod cross-talk + // We still return success to not block the agent, but log a warning + if (clientEnv && clientEnv !== SERVER_ENV) { + console.warn( + `[notifications] Environment mismatch: received ${clientEnv} request on ${SERVER_ENV} server. ` + + `This may indicate a stale hook or misconfigured terminal. Ignoring request.`, + ); + return res.json({ success: true, ignored: true, reason: "env_mismatch" }); + } + + // Log version for debugging (helpful when troubleshooting hook issues) + if (version && version !== "2") { + console.log( + `[notifications] Received hook v${version} request (server expects v2)`, + ); + } + + const mappedEventType = mapEventType(eventType as string | undefined); + + // Unknown or missing eventType: return success but don't process + // This ensures forward compatibility and doesn't block the agent + if (!mappedEventType) { + if (eventType) { + console.log("[notifications] Ignoring unknown eventType:", eventType); + } + return res.json({ success: true, ignored: true }); + } + + const resolvedPaneId = resolvePaneId( + paneId as string | undefined, + tabId as string | undefined, + workspaceId as string | undefined, + ); - const event: AgentCompleteEvent = { - paneId: paneId as string | undefined, + const event: AgentLifecycleEvent = { + paneId: resolvedPaneId, tabId: tabId as string | undefined, workspaceId: workspaceId as string | undefined, - eventType: eventType === "PermissionRequest" ? "PermissionRequest" : "Stop", + eventType: mappedEventType, }; - notificationsEmitter.emit(NOTIFICATION_EVENTS.AGENT_COMPLETE, event); + notificationsEmitter.emit(NOTIFICATION_EVENTS.AGENT_LIFECYCLE, event); - res.json({ success: true, paneId, tabId }); + res.json({ success: true, paneId: resolvedPaneId, tabId }); }); // Health check diff --git a/apps/desktop/src/main/lib/terminal/env.test.ts b/apps/desktop/src/main/lib/terminal/env.test.ts index f8fb5b1e5fd..57946088e55 100644 --- a/apps/desktop/src/main/lib/terminal/env.test.ts +++ b/apps/desktop/src/main/lib/terminal/env.test.ts @@ -177,5 +177,17 @@ describe("env", () => { expect(result.SUPERSET_PORT).toBeDefined(); expect(typeof result.SUPERSET_PORT).toBe("string"); }); + + it("should include SUPERSET_ENV for dev/prod separation", () => { + const result = buildTerminalEnv(baseParams); + expect(result.SUPERSET_ENV).toBeDefined(); + expect(["development", "production"]).toContain(result.SUPERSET_ENV); + }); + + it("should include SUPERSET_HOOK_VERSION for protocol versioning", () => { + const result = buildTerminalEnv(baseParams); + expect(result.SUPERSET_HOOK_VERSION).toBeDefined(); + expect(result.SUPERSET_HOOK_VERSION).toBe("2"); + }); }); }); diff --git a/apps/desktop/src/main/lib/terminal/env.ts b/apps/desktop/src/main/lib/terminal/env.ts index d5931a908f1..d491f215d91 100644 --- a/apps/desktop/src/main/lib/terminal/env.ts +++ b/apps/desktop/src/main/lib/terminal/env.ts @@ -2,8 +2,16 @@ import { execSync } from "node:child_process"; import os from "node:os"; import defaultShell from "default-shell"; import { PORTS } from "shared/constants"; +import { env } from "shared/env.shared"; import { getShellEnv } from "../agent-setup/shell-wrappers"; +/** + * Current hook protocol version. + * Increment when making breaking changes to the hook protocol. + * The server logs this for debugging version mismatches. + */ +export const HOOK_PROTOCOL_VERSION = "2"; + export const FALLBACK_SHELL = os.platform() === "win32" ? "cmd.exe" : "/bin/sh"; export const SHELL_CRASH_THRESHOLD_MS = 1000; @@ -86,7 +94,7 @@ export function buildTerminalEnv(params: { const shellEnv = getShellEnv(shell); const locale = getLocale(baseEnv); - const env: Record = { + const terminalEnv: Record = { ...baseEnv, ...shellEnv, TERM_PROGRAM: "Superset", @@ -100,9 +108,13 @@ export function buildTerminalEnv(params: { SUPERSET_WORKSPACE_PATH: workspacePath || "", SUPERSET_ROOT_PATH: rootPath || "", SUPERSET_PORT: String(PORTS.NOTIFICATIONS), + // Environment identifier for dev/prod separation + SUPERSET_ENV: env.NODE_ENV === "development" ? "development" : "production", + // Hook protocol version for forward compatibility + SUPERSET_HOOK_VERSION: HOOK_PROTOCOL_VERSION, }; - delete env.GOOGLE_API_KEY; + delete terminalEnv.GOOGLE_API_KEY; - return env; + return terminalEnv; } diff --git a/apps/desktop/src/main/windows/main.ts b/apps/desktop/src/main/windows/main.ts index 966e84614c1..ba393a6208a 100644 --- a/apps/desktop/src/main/windows/main.ts +++ b/apps/desktop/src/main/windows/main.ts @@ -13,7 +13,7 @@ import { appState } from "../lib/app-state"; import { createApplicationMenu, registerMenuHotkeyUpdates } from "../lib/menu"; import { playNotificationSound } from "../lib/notification-sound"; import { - type AgentCompleteEvent, + type AgentLifecycleEvent, notificationsApp, notificationsEmitter, } from "../lib/notifications/server"; @@ -78,10 +78,13 @@ export async function MainWindow() { }, ); - // Handle agent completion notifications + // Handle agent lifecycle notifications (Stop = completion, PermissionRequest = needs input) notificationsEmitter.on( - NOTIFICATION_EVENTS.AGENT_COMPLETE, - (event: AgentCompleteEvent) => { + NOTIFICATION_EVENTS.AGENT_LIFECYCLE, + (event: AgentLifecycleEvent) => { + // Only notify on Stop (completion) and PermissionRequest - not on Start + if (event.eventType === "Start") return; + if (Notification.isSupported()) { const isPermissionRequest = event.eventType === "PermissionRequest"; diff --git a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx index 8b3dd67e6b2..f9597f90443 100644 --- a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx +++ b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx @@ -56,8 +56,8 @@ export function WorkspaceItem({ const closeSettings = useCloseSettings(); const tabs = useTabsStore((s) => s.tabs); const panes = useTabsStore((s) => s.panes); - const clearWorkspaceAttention = useTabsStore( - (s) => s.clearWorkspaceAttention, + const clearWorkspaceAttentionStatus = useTabsStore( + (s) => s.clearWorkspaceAttentionStatus, ); const rename = useWorkspaceRename(id, title); @@ -65,17 +65,30 @@ export function WorkspaceItem({ const { showDeleteDialog, setShowDeleteDialog, handleDeleteClick } = useWorkspaceDeleteHandler(); - // Check if any pane in tabs belonging to this workspace needs attention (agent notifications) + // Derive aggregate status from panes in this workspace + // Priority: permission (red) > working (amber) > review (green) const workspaceTabs = tabs.filter((t) => t.workspaceId === id); const workspacePaneIds = new Set( workspaceTabs.flatMap((t) => extractPaneIdsFromLayout(t.layout)), ); - const hasPaneAttention = Object.values(panes) - .filter((p) => p != null && workspacePaneIds.has(p.id)) - .some((p) => p.needsAttention); + const workspacePanes = Object.values(panes).filter( + (p) => p != null && workspacePaneIds.has(p.id), + ); + + const hasPermission = workspacePanes.some((p) => p.status === "permission"); + const hasWorking = workspacePanes.some((p) => p.status === "working"); + const hasReview = workspacePanes.some((p) => p.status === "review"); - // Show indicator if workspace is manually marked as unread OR has pane-level attention - const needsAttention = isUnread || hasPaneAttention; + // Aggregate status for the workspace (priority order) + const aggregateStatus = hasPermission + ? "permission" + : hasWorking + ? "working" + : hasReview + ? "review" + : isUnread + ? "review" // isUnread maps to review color + : null; const [{ isDragging }, drag] = useDrag( () => ({ @@ -128,7 +141,7 @@ export function WorkspaceItem({ if (!rename.isRenaming) { closeSettings(); setActive.mutate({ id }); - clearWorkspaceAttention(id); + clearWorkspaceAttentionStatus(id); } }} onDoubleClick={isBranchWorkspace ? undefined : rename.startRename} @@ -208,10 +221,23 @@ export function WorkspaceItem({ > {title} - {needsAttention && ( + {aggregateStatus && ( - - + {aggregateStatus === "permission" && ( + <> + + + + )} + {aggregateStatus === "working" && ( + <> + + + + )} + {aggregateStatus === "review" && ( + + )} )} diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx index 04afd81d085..e57f7528ac4 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx @@ -73,8 +73,8 @@ export function WorkspaceListItem({ const rename = useWorkspaceRename(id, name); const tabs = useTabsStore((s) => s.tabs); const panes = useTabsStore((s) => s.panes); - const clearWorkspaceAttention = useTabsStore( - (s) => s.clearWorkspaceAttention, + const clearWorkspaceAttentionStatus = useTabsStore( + (s) => s.clearWorkspaceAttentionStatus, ); const utils = trpc.useUtils(); const openInFinder = trpc.external.openInFinder.useMutation(); @@ -97,22 +97,35 @@ export function WorkspaceListItem({ }, ); - // Check if any pane in tabs belonging to this workspace needs attention (agent notifications) + // Derive aggregate status from panes in this workspace + // Priority: permission (red) > working (amber) > review (green) const workspaceTabs = tabs.filter((t) => t.workspaceId === id); const workspacePaneIds = new Set( workspaceTabs.flatMap((t) => extractPaneIdsFromLayout(t.layout)), ); - const hasPaneAttention = Object.values(panes) - .filter((p) => p != null && workspacePaneIds.has(p.id)) - .some((p) => p.needsAttention); + const workspacePanes = Object.values(panes).filter( + (p) => p != null && workspacePaneIds.has(p.id), + ); + + const hasPermission = workspacePanes.some((p) => p.status === "permission"); + const hasWorking = workspacePanes.some((p) => p.status === "working"); + const hasReview = workspacePanes.some((p) => p.status === "review"); - // Show indicator if workspace is manually marked as unread OR has pane-level attention - const needsAttention = isUnread || hasPaneAttention; + // Aggregate status for the workspace (priority order) + const aggregateStatus = hasPermission + ? "permission" + : hasWorking + ? "working" + : hasReview + ? "review" + : isUnread + ? "review" // isUnread maps to review color + : null; const handleClick = () => { if (!rename.isRenaming) { setActiveWorkspace.mutate({ id }); - clearWorkspaceAttention(id); + clearWorkspaceAttentionStatus(id); } }; @@ -214,10 +227,23 @@ export function WorkspaceListItem({ {pr && ( )} - {needsAttention && ( + {aggregateStatus && ( - - + {aggregateStatus === "permission" && ( + <> + + + + )} + {aggregateStatus === "working" && ( + <> + + + + )} + {aggregateStatus === "review" && ( + + )} )}
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx index 77790ae7b88..4159ed7bb7f 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx @@ -5,13 +5,13 @@ import { useMemo } from "react"; import { HiMiniPlus, HiMiniXMark } from "react-icons/hi2"; import { trpc } from "renderer/lib/trpc"; import { useTabsStore } from "renderer/stores/tabs/store"; -import type { Tab } from "renderer/stores/tabs/types"; +import type { PaneStatus, Tab } from "renderer/stores/tabs/types"; import { getTabDisplayName } from "renderer/stores/tabs/utils"; interface GroupItemProps { tab: Tab; isActive: boolean; - needsAttention: boolean; + status: PaneStatus | null; onSelect: () => void; onClose: () => void; } @@ -19,7 +19,7 @@ interface GroupItemProps { function GroupItem({ tab, isActive, - needsAttention, + status, onSelect, onClose, }: GroupItemProps) { @@ -42,10 +42,23 @@ function GroupItem({ {displayName} - {needsAttention && ( + {status && status !== "idle" && ( - - + {status === "permission" && ( + <> + + + + )} + {status === "working" && ( + <> + + + + )} + {status === "review" && ( + + )} )} @@ -104,12 +117,24 @@ export function GroupStrip() { ? activeTabIds[activeWorkspaceId] : null; - // Check which tabs have panes that need attention - const tabsWithAttention = useMemo(() => { - const result = new Set(); + // Compute aggregate status per tab (priority: permission > working > review) + const tabStatusMap = useMemo(() => { + const result = new Map(); for (const pane of Object.values(panes)) { - if (pane.needsAttention) { - result.add(pane.tabId); + if (!pane.status || pane.status === "idle") continue; + + const currentStatus = result.get(pane.tabId); + // Priority: permission > working > review + if (pane.status === "permission") { + result.set(pane.tabId, "permission"); + } else if (pane.status === "working" && currentStatus !== "permission") { + result.set(pane.tabId, "working"); + } else if ( + pane.status === "review" && + currentStatus !== "permission" && + currentStatus !== "working" + ) { + result.set(pane.tabId, "review"); } } return result; @@ -144,7 +169,7 @@ export function GroupStrip() { handleSelectGroup(tab.id)} onClose={() => handleCloseGroup(tab.id)} /> diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/TabsView/TabItem/index.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/TabsView/TabItem/index.tsx index 07a860bed16..774ee9a9061 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/TabsView/TabItem/index.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/TabsView/TabItem/index.tsx @@ -31,9 +31,15 @@ export function TabItem({ tab, index, isActive }: TabItemProps) { const setActiveTab = useTabsStore((s) => s.setActiveTab); const renameTab = useTabsStore((s) => s.renameTab); const panes = useTabsStore((s) => s.panes); - const needsAttention = useTabsStore((s) => - Object.values(s.panes).some((p) => p.tabId === tab.id && p.needsAttention), - ); + + // Derive aggregate status from panes in this tab (priority: permission > working > review) + const aggregateStatus = useTabsStore((s) => { + const tabPanes = Object.values(s.panes).filter((p) => p.tabId === tab.id); + if (tabPanes.some((p) => p.status === "permission")) return "permission"; + if (tabPanes.some((p) => p.status === "working")) return "working"; + if (tabPanes.some((p) => p.status === "review")) return "review"; + return null; + }); const paneCount = useMemo( () => Object.values(panes).filter((p) => p.tabId === tab.id).length, @@ -190,15 +196,34 @@ export function TabItem({ tab, index, isActive }: TabItemProps) {
{displayName} - {needsAttention && ( + {aggregateStatus && ( - - + {aggregateStatus === "permission" && ( + <> + + + + )} + {aggregateStatus === "working" && ( + <> + + + + )} + {aggregateStatus === "review" && ( + + )} - Agent completed + + {aggregateStatus === "permission" + ? "Needs input" + : aggregateStatus === "working" + ? "Agent working" + : "Ready for review"} + )}
diff --git a/apps/desktop/src/renderer/stores/tabs/store.ts b/apps/desktop/src/renderer/stores/tabs/store.ts index 828d0679dc1..ca4cf8c3b90 100644 --- a/apps/desktop/src/renderer/stores/tabs/store.ts +++ b/apps/desktop/src/renderer/stores/tabs/store.ts @@ -4,7 +4,12 @@ import { create } from "zustand"; import { devtools, persist } from "zustand/middleware"; import { trpcTabsStorage } from "../../lib/trpc-storage"; import { movePaneToNewTab, movePaneToTab } from "./actions/move-pane"; -import type { AddFileViewerPaneOptions, TabsState, TabsStore } from "./types"; +import type { + AddFileViewerPaneOptions, + PaneStatus, + TabsState, + TabsStore, +} from "./types"; import { type CreatePaneOptions, createFileViewerPane, @@ -199,14 +204,22 @@ export const useTabsStore = create()( ]; } - // Clear needsAttention for the focused pane in the tab being activated - const focusedPaneId = state.focusedPaneIds[tabId]; + // Clear attention status for panes in the selected tab + const tabPaneIds = extractPaneIdsFromLayout(tab.layout); const newPanes = { ...state.panes }; - if (focusedPaneId && newPanes[focusedPaneId]?.needsAttention) { - newPanes[focusedPaneId] = { - ...newPanes[focusedPaneId], - needsAttention: false, - }; + let hasChanges = false; + for (const paneId of tabPaneIds) { + const currentStatus = newPanes[paneId]?.status; + if (currentStatus === "review") { + // User acknowledged completion + newPanes[paneId] = { ...newPanes[paneId], status: "idle" }; + hasChanges = true; + } else if (currentStatus === "permission") { + // Assume permission granted, agent is now working + newPanes[paneId] = { ...newPanes[paneId], status: "working" }; + hasChanges = true; + } + // "working" status is NOT cleared by click - persists until Stop } set({ @@ -218,7 +231,7 @@ export const useTabsStore = create()( ...state.tabHistoryStacks, [workspaceId]: newHistoryStack, }, - panes: newPanes, + ...(hasChanges ? { panes: newPanes } : {}), }); }, @@ -506,20 +519,11 @@ export const useTabsStore = create()( const pane = state.panes[paneId]; if (!pane || pane.tabId !== tabId) return; - // Clear needsAttention for the pane being focused - const newPanes = pane.needsAttention - ? { - ...state.panes, - [paneId]: { ...pane, needsAttention: false }, - } - : state.panes; - set({ focusedPaneIds: { ...state.focusedPaneIds, [tabId]: paneId, }, - panes: newPanes, }); }, @@ -534,18 +538,18 @@ export const useTabsStore = create()( })); }, - setNeedsAttention: (paneId, needsAttention) => { + setPaneStatus: (paneId, status) => { set((state) => ({ panes: { ...state.panes, [paneId]: state.panes[paneId] - ? { ...state.panes[paneId], needsAttention } + ? { ...state.panes[paneId], status } : state.panes[paneId], }, })); }, - clearWorkspaceAttention: (workspaceId) => { + clearWorkspaceAttentionStatus: (workspaceId) => { const state = get(); const workspaceTabs = state.tabs.filter( (t) => t.workspaceId === workspaceId, @@ -561,10 +565,17 @@ export const useTabsStore = create()( const newPanes = { ...state.panes }; let hasChanges = false; for (const paneId of workspacePaneIds) { - if (newPanes[paneId]?.needsAttention) { - newPanes[paneId] = { ...newPanes[paneId], needsAttention: false }; + const currentStatus = newPanes[paneId]?.status; + if (currentStatus === "review") { + // User acknowledged completion + newPanes[paneId] = { ...newPanes[paneId], status: "idle" }; + hasChanges = true; + } else if (currentStatus === "permission") { + // Assume permission granted, Claude is now working + newPanes[paneId] = { ...newPanes[paneId], status: "working" }; hasChanges = true; } + // "working" status is NOT cleared by click - persists until Stop } if (hasChanges) { @@ -776,7 +787,35 @@ export const useTabsStore = create()( }), { name: "tabs-storage", + version: 2, storage: trpcTabsStorage, + migrate: (persistedState, version) => { + const state = persistedState as TabsState; + if (version < 2 && state.panes) { + // Migrate needsAttention → status + for (const pane of Object.values(state.panes)) { + // biome-ignore lint/suspicious/noExplicitAny: migration from old schema + const legacyPane = pane as any; + if (legacyPane.needsAttention === true) { + pane.status = "review"; + } + delete legacyPane.needsAttention; + } + } + return state; + }, + merge: (persistedState, currentState) => { + const persisted = persistedState as TabsState; + // Clear stale "working" status on startup - agent can't be working if app just started + if (persisted.panes) { + for (const pane of Object.values(persisted.panes)) { + if (pane.status === "working") { + pane.status = "idle"; + } + } + } + return { ...currentState, ...persisted }; + }, }, ), { name: "TabsStore" }, diff --git a/apps/desktop/src/renderer/stores/tabs/types.ts b/apps/desktop/src/renderer/stores/tabs/types.ts index 9638df6e072..3b7e28310cd 100644 --- a/apps/desktop/src/renderer/stores/tabs/types.ts +++ b/apps/desktop/src/renderer/stores/tabs/types.ts @@ -1,9 +1,15 @@ import type { MosaicBranch, MosaicNode } from "react-mosaic-component"; import type { ChangeCategory } from "shared/changes-types"; -import type { BaseTab, BaseTabsState, Pane, PaneType } from "shared/tabs-types"; +import type { + BaseTab, + BaseTabsState, + Pane, + PaneStatus, + PaneType, +} from "shared/tabs-types"; // Re-export shared types -export type { Pane, PaneType }; +export type { Pane, PaneStatus, PaneType }; /** * A Tab is a container that holds one or more Panes in a Mosaic layout. @@ -73,8 +79,8 @@ export interface TabsStore extends TabsState { removePane: (paneId: string) => void; setFocusedPane: (tabId: string, paneId: string) => void; markPaneAsUsed: (paneId: string) => void; - setNeedsAttention: (paneId: string, needsAttention: boolean) => void; - clearWorkspaceAttention: (workspaceId: string) => void; + setPaneStatus: (paneId: string, status: PaneStatus) => void; + clearWorkspaceAttentionStatus: (workspaceId: string) => void; updatePaneCwd: ( paneId: string, cwd: string | null, diff --git a/apps/desktop/src/renderer/stores/tabs/useAgentHookListener.ts b/apps/desktop/src/renderer/stores/tabs/useAgentHookListener.ts index 0b158830c49..033e152796d 100644 --- a/apps/desktop/src/renderer/stores/tabs/useAgentHookListener.ts +++ b/apps/desktop/src/renderer/stores/tabs/useAgentHookListener.ts @@ -8,7 +8,7 @@ import { resolveNotificationTarget } from "./utils/resolve-notification-target"; /** * Hook that listens for notification events via tRPC subscription. - * Handles agent completions and focus requests from native notifications. + * Handles agent lifecycle events (Start, Stop, PermissionRequest) and focus requests. */ export function useAgentHookListener() { const setActiveWorkspace = useSetActiveWorkspace(); @@ -28,17 +28,36 @@ export function useAgentHookListener() { const { paneId, workspaceId } = target; - if (event.type === NOTIFICATION_EVENTS.AGENT_COMPLETE) { + if (event.type === NOTIFICATION_EVENTS.AGENT_LIFECYCLE) { if (!paneId) return; - const activeTabId = state.activeTabIds[workspaceId]; - const focusedPaneId = activeTabId && state.focusedPaneIds[activeTabId]; - const isAlreadyActive = - activeWorkspaceRef.current?.id === workspaceId && - focusedPaneId === paneId; + const lifecycleEvent = event.data; + if (!lifecycleEvent) return; - if (!isAlreadyActive) { - state.setNeedsAttention(paneId, true); + const { eventType } = lifecycleEvent; + + if (eventType === "Start") { + // Agent started working - always set to working + state.setPaneStatus(paneId, "working"); + } else if (eventType === "PermissionRequest") { + // Agent needs permission - always set to permission (overrides working) + state.setPaneStatus(paneId, "permission"); + } else if (eventType === "Stop") { + // Agent completed - only mark as review if not currently active + const activeTabId = state.activeTabIds[workspaceId]; + const focusedPaneId = + activeTabId && state.focusedPaneIds[activeTabId]; + const isAlreadyActive = + activeWorkspaceRef.current?.id === workspaceId && + focusedPaneId === paneId; + + if (isAlreadyActive) { + // User is watching - go straight to idle + state.setPaneStatus(paneId, "idle"); + } else { + // User not watching - mark for review + state.setPaneStatus(paneId, "review"); + } } } else if (event.type === NOTIFICATION_EVENTS.FOCUS_TAB) { const appState = useAppStore.getState(); diff --git a/apps/desktop/src/shared/constants.ts b/apps/desktop/src/shared/constants.ts index 35c6207de41..4a9dca35899 100644 --- a/apps/desktop/src/shared/constants.ts +++ b/apps/desktop/src/shared/constants.ts @@ -40,7 +40,7 @@ export const CONFIG_TEMPLATE = `{ }`; export const NOTIFICATION_EVENTS = { - AGENT_COMPLETE: "agent-complete", + AGENT_LIFECYCLE: "agent-lifecycle", FOCUS_TAB: "focus-tab", } as const; diff --git a/apps/desktop/src/shared/tabs-types.ts b/apps/desktop/src/shared/tabs-types.ts index d8c921186eb..698f7f08dae 100644 --- a/apps/desktop/src/shared/tabs-types.ts +++ b/apps/desktop/src/shared/tabs-types.ts @@ -10,6 +10,15 @@ import type { ChangeCategory } from "./changes-types"; */ export type PaneType = "terminal" | "webview" | "file-viewer"; +/** + * Pane status for agent lifecycle indicators + * - idle: No indicator shown (default) + * - working: Agent actively processing (amber) + * - permission: Agent blocked, needs user action (red) + * - review: Agent completed, ready for review (green) + */ +export type PaneStatus = "idle" | "working" | "permission" | "review"; + /** * File viewer display modes */ @@ -53,7 +62,7 @@ export interface Pane { type: PaneType; name: string; isNew?: boolean; - needsAttention?: boolean; + status?: PaneStatus; initialCommands?: string[]; initialCwd?: string; url?: string; // For webview panes From 2dbb1cefddc8e9a2611b22260981ba567b2d085c Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Sat, 3 Jan 2026 16:46:53 +0200 Subject: [PATCH 94/98] fix(desktop): address code review - guard store mutations, persist status P0 Fixes: - Guard setPaneStatus against unknown paneId (prevents store corruption) - Guard markPaneAsUsed, updatePaneCwd, clearPaneInitialData (same pattern) P1 Fix: - Add status field to paneSchema in ui-state router (enables persistence) - Remove obsolete needsAttention field from schema P2 Fix: - Validate paneId exists in resolvePaneId before returning - Fall through to tabId/workspaceId resolution for stale paneIds --- .../src/lib/trpc/routers/ui-state/index.ts | 2 +- .../src/main/lib/notifications/server.ts | 20 +- .../desktop/src/renderer/stores/tabs/store.ts | 78 ++--- .../CONTINUITY_CLAUDE-working-indicator.md | 267 ++++++++++++++++++ .../auto-handoff-2026-01-02T18-31-55.md | 28 ++ .../auto-handoff-2026-01-03T08-03-16.md | 32 +++ .../auto-handoff-2026-01-03T14-43-14.md | 32 +++ .../auto-handoff-2026-01-03T14-43-51.md | 32 +++ 8 files changed, 453 insertions(+), 38 deletions(-) create mode 100644 thoughts/ledgers/CONTINUITY_CLAUDE-working-indicator.md create mode 100644 thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-02T18-31-55.md create mode 100644 thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-03T08-03-16.md create mode 100644 thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-03T14-43-14.md create mode 100644 thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-03T14-43-51.md diff --git a/apps/desktop/src/lib/trpc/routers/ui-state/index.ts b/apps/desktop/src/lib/trpc/routers/ui-state/index.ts index afbff9fc94b..03371e0e4bd 100644 --- a/apps/desktop/src/lib/trpc/routers/ui-state/index.ts +++ b/apps/desktop/src/lib/trpc/routers/ui-state/index.ts @@ -36,7 +36,7 @@ const paneSchema = z.object({ type: z.enum(["terminal", "webview", "file-viewer"]), name: z.string(), isNew: z.boolean().optional(), - needsAttention: z.boolean().optional(), + status: z.enum(["idle", "working", "permission", "review"]).optional(), initialCommands: z.array(z.string()).optional(), initialCwd: z.string().optional(), url: z.string().optional(), diff --git a/apps/desktop/src/main/lib/notifications/server.ts b/apps/desktop/src/main/lib/notifications/server.ts index 3c72e753a1f..5609227b7c4 100644 --- a/apps/desktop/src/main/lib/notifications/server.ts +++ b/apps/desktop/src/main/lib/notifications/server.ts @@ -71,22 +71,32 @@ export function mapEventType( /** * Resolves paneId from tabId or workspaceId using synced tabs state. * Falls back to focused pane in active tab. + * + * If a paneId is provided but doesn't exist in state (stale reference), + * we fall through to tabId/workspaceId resolution instead of returning + * an invalid paneId that would corrupt the store. */ function resolvePaneId( paneId: string | undefined, tabId: string | undefined, workspaceId: string | undefined, ): string | undefined { - if (paneId) return paneId; - try { const tabsState = appState.data.tabsState; if (!tabsState) return undefined; + // If paneId provided, validate it exists before returning + if (paneId && tabsState.panes?.[paneId]) { + return paneId; + } + // If paneId was provided but doesn't exist, fall through to resolution + // Try to resolve from tabId if (tabId) { const focusedPaneId = tabsState.focusedPaneIds?.[tabId]; - if (focusedPaneId) return focusedPaneId; + if (focusedPaneId && tabsState.panes?.[focusedPaneId]) { + return focusedPaneId; + } } // Try to resolve from workspaceId @@ -94,7 +104,9 @@ function resolvePaneId( const activeTabId = tabsState.activeTabIds?.[workspaceId]; if (activeTabId) { const focusedPaneId = tabsState.focusedPaneIds?.[activeTabId]; - if (focusedPaneId) return focusedPaneId; + if (focusedPaneId && tabsState.panes?.[focusedPaneId]) { + return focusedPaneId; + } } } } catch { diff --git a/apps/desktop/src/renderer/stores/tabs/store.ts b/apps/desktop/src/renderer/stores/tabs/store.ts index ca4cf8c3b90..bbe36a9b845 100644 --- a/apps/desktop/src/renderer/stores/tabs/store.ts +++ b/apps/desktop/src/renderer/stores/tabs/store.ts @@ -528,25 +528,29 @@ export const useTabsStore = create()( }, markPaneAsUsed: (paneId) => { - set((state) => ({ - panes: { - ...state.panes, - [paneId]: state.panes[paneId] - ? { ...state.panes[paneId], isNew: false } - : state.panes[paneId], - }, - })); + set((state) => { + // Guard: no-op for unknown panes to avoid corrupting panes map + if (!state.panes[paneId]) return state; + return { + panes: { + ...state.panes, + [paneId]: { ...state.panes[paneId], isNew: false }, + }, + }; + }); }, setPaneStatus: (paneId, status) => { - set((state) => ({ + const state = get(); + // Guard: no-op for unknown panes to avoid corrupting panes map with undefined + if (!state.panes[paneId]) return; + + set({ panes: { ...state.panes, - [paneId]: state.panes[paneId] - ? { ...state.panes[paneId], status } - : state.panes[paneId], + [paneId]: { ...state.panes[paneId], status }, }, - })); + }); }, clearWorkspaceAttentionStatus: (workspaceId) => { @@ -584,29 +588,37 @@ export const useTabsStore = create()( }, updatePaneCwd: (paneId, cwd, confirmed) => { - set((state) => ({ - panes: { - ...state.panes, - [paneId]: state.panes[paneId] - ? { ...state.panes[paneId], cwd, cwdConfirmed: confirmed } - : state.panes[paneId], - }, - })); + set((state) => { + // Guard: no-op for unknown panes to avoid corrupting panes map + if (!state.panes[paneId]) return state; + return { + panes: { + ...state.panes, + [paneId]: { + ...state.panes[paneId], + cwd, + cwdConfirmed: confirmed, + }, + }, + }; + }); }, clearPaneInitialData: (paneId) => { - set((state) => ({ - panes: { - ...state.panes, - [paneId]: state.panes[paneId] - ? { - ...state.panes[paneId], - initialCommands: undefined, - initialCwd: undefined, - } - : state.panes[paneId], - }, - })); + set((state) => { + // Guard: no-op for unknown panes to avoid corrupting panes map + if (!state.panes[paneId]) return state; + return { + panes: { + ...state.panes, + [paneId]: { + ...state.panes[paneId], + initialCommands: undefined, + initialCwd: undefined, + }, + }, + }; + }); }, // Split operations diff --git a/thoughts/ledgers/CONTINUITY_CLAUDE-working-indicator.md b/thoughts/ledgers/CONTINUITY_CLAUDE-working-indicator.md new file mode 100644 index 00000000000..a5816224f4f --- /dev/null +++ b/thoughts/ledgers/CONTINUITY_CLAUDE-working-indicator.md @@ -0,0 +1,267 @@ +--- +created: 2026-01-02T19:50:00Z +last_updated: 2026-01-02T19:50:00Z +session_count: 1 +status: IN_PROGRESS +--- + +# Session: Working Indicator Implementation + +## Goal +Add workspace status indicators showing agent lifecycle states: +- Amber (working) - Agent actively processing +- Red (permission) - Agent blocked, needs immediate action +- Green (review) - Agent completed, ready for review + +## Constraints +- Must support Claude Code, OpenCode, and Codex (partial) +- Big bang migration (no backwards compatibility) +- No feature flags + +## Key Decisions +- Decision 1: Use `PaneStatus` enum instead of `needsAttention` boolean +- Decision 2: OpenCode uses `session.status` event with `busy`/`idle` (not `tool.execute.before`) +- Decision 3: Claude Code uses `UserPromptSubmit` for Start event +- Decision 4: When clearing "permission" on click, set to "working" (not "idle") - assumes user granted permission +- Decision 5: Codex has partial support (review only, no working indicator) + +## State +- Done: [x] Phase 1a: Update shared/tabs-types.ts - Add PaneStatus type +- Done: [x] Phase 1b: Update shared/constants.ts - Rename AGENT_COMPLETE to AGENT_LIFECYCLE +- Done: [x] Phase 2: Update notifications/server.ts - Handle Start event, paneId resolution +- Done: [x] Phase 3a: Update agent-wrappers.ts - Add UserPromptSubmit hook +- Done: [x] Phase 3b: Update agent-wrappers.ts - Update OpenCode plugin for session.status +- Done: [x] Phase 3c: Update notify-hook.ts - Map UserPromptSubmit to Start +- Done: [x] Phase 4: Update trpc/routers/notifications.ts - Update event types +- Done: [x] Phase 5a: Update stores/tabs/types.ts - Update interface +- Done: [x] Phase 5b: Update stores/tabs/store.ts - Add actions, migration +- Done: [x] Phase 6: Update useAgentHookListener.ts - Handle all events +- Done: [x] Phase 7a: Update WorkspaceItem.tsx - 3-color indicator +- Done: [x] Phase 7b: Update WorkspaceListItem.tsx - 3-color indicator +- Done: [x] Phase 8: Run typecheck and fix issues (pre-existing errors only remain) +- Now: [→] Phase 9: Test implementation + +## Files to Modify +1. `apps/desktop/src/shared/tabs-types.ts` +2. `apps/desktop/src/shared/constants.ts` +3. `apps/desktop/src/main/lib/notifications/server.ts` +4. `apps/desktop/src/main/lib/agent-setup/agent-wrappers.ts` +5. `apps/desktop/src/main/lib/agent-setup/notify-hook.ts` +6. `apps/desktop/src/lib/trpc/routers/notifications.ts` +7. `apps/desktop/src/renderer/stores/tabs/types.ts` +8. `apps/desktop/src/renderer/stores/tabs/store.ts` +9. `apps/desktop/src/renderer/stores/tabs/useAgentHookListener.ts` +10. `WorkspaceItem.tsx` +11. `WorkspaceListItem.tsx` + +## Research Summary +- OpenCode `SessionStatus` types: `idle`, `busy`, `retry` +- Claude Code hooks: `UserPromptSubmit`, `Stop`, `PermissionRequest` +- No "permission granted" hook exists - use click-to-clear → working workaround + +## Working Set +- Branch: working-indicator (worktree) +- Status: Implementation in progress + +--- + +## QA Checklist + +### Prerequisites +- [ ] Desktop app builds without errors (`bun run dev` in apps/desktop) +- [ ] Notification server is running (check console for `[notifications] Listening on http://127.0.0.1:31416`) + +### 1. Claude Code - Working Indicator (Amber) +- [ ] Start Claude Code in a workspace terminal +- [ ] Send a prompt to Claude Code +- [ ] **Expected**: Amber pulsing dot appears on workspace tab immediately +- [ ] **Expected**: Amber pulsing dot appears in sidebar (if using sidebar navigation) +- [ ] **Expected**: Amber pulsing dot appears on group/tab in TabsView + +### 2. Claude Code - Review Indicator (Green) +- [ ] Wait for Claude Code to complete its response +- [ ] Switch to a DIFFERENT workspace before completion (so you're not watching) +- [ ] **Expected**: Green static dot appears on the original workspace +- [ ] **Expected**: Native notification appears: "Agent Complete — {workspace}" +- [ ] Click on workspace to acknowledge +- [ ] **Expected**: Green dot disappears (status → idle) + +### 3. Claude Code - Permission Indicator (Red) +- [ ] Trigger a permission request in Claude Code (e.g., file edit, bash command) +- [ ] **Expected**: Red pulsing dot appears immediately +- [ ] **Expected**: Native notification appears: "Input Needed — {workspace}" +- [ ] Click on workspace to acknowledge +- [ ] **Expected**: Red dot changes to Amber (assuming permission granted, agent continues) + +### 4. OpenCode - Working Indicator (Amber) +- [ ] Start OpenCode in a workspace terminal +- [ ] Send a prompt to OpenCode +- [ ] **Expected**: Amber pulsing dot appears when session.status = "busy" +- [ ] **Expected**: Indicator persists while OpenCode is processing + +### 5. OpenCode - Review Indicator (Green) +- [ ] Wait for OpenCode to complete (session.status = "idle") +- [ ] Switch away before completion +- [ ] **Expected**: Green static dot appears on workspace +- [ ] **Expected**: Native notification appears + +### 6. Click Behavior - Review Status +- [ ] Have a workspace in "review" state (green dot) +- [ ] Click on that workspace +- [ ] **Expected**: Green dot disappears (status → idle) + +### 7. Click Behavior - Permission Status +- [ ] Have a workspace in "permission" state (red dot) +- [ ] Click on that workspace +- [ ] **Expected**: Red dot changes to Amber (status → working, not idle) + +### 8. Click Behavior - Working Status +- [ ] Have a workspace in "working" state (amber dot) +- [ ] Click on that workspace +- [ ] **Expected**: Amber dot persists (working is NOT cleared by click) + +### 9. Already Active Workspace +- [ ] Stay on a workspace while Claude Code is running +- [ ] Let it complete while you're watching +- [ ] **Expected**: NO indicator appears (goes straight to idle, not review) +- [ ] **Expected**: NO notification appears (you're already watching) + +### 10. Multiple Panes - Priority +- [ ] Have multiple panes in one workspace +- [ ] Put one pane in "working" state, another in "permission" state +- [ ] **Expected**: Workspace shows RED dot (permission takes priority over working) +- [ ] Clear the permission pane +- [ ] **Expected**: Workspace shows AMBER dot (working is highest remaining) + +### 11. App Restart - Stale Working Cleanup +- [ ] Get a pane into "working" state +- [ ] Quit the desktop app +- [ ] Restart the app +- [ ] **Expected**: "working" status is cleared to "idle" on startup (stale cleanup) +- [ ] **Expected**: "review" and "permission" statuses persist + +### 12. Migration from Old Schema +- [ ] (If possible) Test with old persisted state that has `needsAttention: true` +- [ ] **Expected**: Migrates to `status: "review"` +- [ ] **Expected**: Old `needsAttention` field is removed + +### 13. UI Locations - All Indicators Work +- [ ] Top bar workspace tabs (WorkspaceItem.tsx) +- [ ] Sidebar workspace list (WorkspaceListItem.tsx) +- [ ] Group strip tabs (GroupStrip.tsx) +- [ ] Tab item in sidebar (TabItem/index.tsx) +- [ ] **Expected**: All locations show consistent 3-color indicator + +### 14. Tooltips +- [ ] Hover over indicator in TabItem +- [ ] **Expected**: Tooltip shows appropriate message: + - Red: "Needs input" + - Amber: "Agent working" + - Green: "Ready for review" + +### Notes/Issues Found +- +- +- + +--- + +## Dev/Prod Separation (Hardening) + +### Problem Discovered During Testing +When running both dev and prod versions simultaneously, agent hooks conflicted: +1. Global OpenCode plugin (`~/.config/opencode/plugin/superset-notify.js`) was shared +2. Dev overwrote it with new protocol (adds `Start` event) +3. Prod server didn't understand `Start`, treated it as `Stop` → notification spam + +### Implementation Summary + +#### P0: Critical Fixes +1. **Remove global plugin write** (`agent-wrappers.ts`) + - No longer writes to `~/.config/opencode/plugin/` + - Added `cleanupGlobalOpenCodePlugin()` to remove stale global plugins on startup + +2. **Server ignores unknown events** (`notifications/server.ts`) + - `mapEventType()` returns `null` for unknown event types + - Server returns `{ success: true, ignored: true }` for unknown events + - Ensures forward compatibility with future hook versions + +3. **Fix notify.sh default behavior** (`notify-hook.ts`) + - No longer defaults missing eventType to "Stop" + - Parse failures no longer trigger completion notifications + - Exits early if no valid event type found + +#### P1: Environment Validation +1. **Added `SUPERSET_ENV`** to terminal env vars (`terminal/env.ts`) + - Value: `"development"` or `"production"` + - Passed in notify.sh requests + +2. **Server validates environment** (`notifications/server.ts`) + - Checks if incoming request's `env` matches server's environment + - Logs warning and ignores mismatched requests + - Returns success to not block agents + +#### P2: Protocol Versioning +1. **Added `SUPERSET_HOOK_VERSION`** to terminal env vars + - Current version: `"2"` + - Passed in notify.sh requests + +2. **Server logs version** for debugging + - Helps troubleshoot version mismatches + +#### P3: Documentation +- Created `apps/desktop/docs/EXTERNAL_FILES.md` +- Documents all files written outside of user projects +- Explains dev/prod separation strategy + +#### P4: Testing +- Added tests in `terminal/env.test.ts` for new env vars +- Created `notifications/server.test.ts` for `mapEventType()` function + +### Files Modified for Dev/Prod Separation +1. `apps/desktop/src/main/lib/agent-setup/agent-wrappers.ts` +2. `apps/desktop/src/main/lib/agent-setup/notify-hook.ts` +3. `apps/desktop/src/main/lib/agent-setup/index.ts` +4. `apps/desktop/src/main/lib/notifications/server.ts` +5. `apps/desktop/src/main/lib/terminal/env.ts` +6. `apps/desktop/src/main/lib/terminal/env.test.ts` +7. `apps/desktop/src/main/lib/notifications/server.test.ts` (new) +8. `apps/desktop/docs/EXTERNAL_FILES.md` (new) + +--- + +## PR Description Template + +### Title +feat(desktop): Add workspace status indicators with dev/prod separation + +### Summary +This PR implements a 3-color workspace status indicator system and hardens the agent hook protocol for dev/prod separation. + +### Changes + +#### Workspace Status Indicators +- **Amber (pulsing)**: Agent actively processing +- **Red (pulsing)**: Agent blocked, needs user input +- **Green (static)**: Agent completed, ready for review + +Key features: +- Status aggregation: workspace shows highest-priority status across all panes +- Click behavior: review → idle, permission → working, working unchanged +- App restart: stale "working" status cleared on startup +- Migration: old `needsAttention` boolean migrated to `status: "review"` + +#### Dev/Prod Separation +- Removed global OpenCode plugin write (was causing cross-talk) +- Added startup cleanup for stale global plugins +- Server ignores unknown event types (forward compatibility) +- notify.sh no longer defaults to "Stop" on parse failure +- Added `SUPERSET_ENV` and `SUPERSET_HOOK_VERSION` to terminal environment +- Server validates environment and logs mismatches + +### Testing +- Run `bun test` in apps/desktop +- Manual QA checklist in ledger + +### Breaking Changes +None - backwards compatible with existing persisted state (migration handled) diff --git a/thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-02T18-31-55.md b/thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-02T18-31-55.md new file mode 100644 index 00000000000..9be59824f85 --- /dev/null +++ b/thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-02T18-31-55.md @@ -0,0 +1,28 @@ +--- +type: auto-handoff +date: 2026-01-02T18:31:55.668Z +session_name: working-indicator +trigger: pre-compact (opencode) +--- + +# Auto-Handoff: [→] Phase 1a: Update shared/tabs-types.ts - Add PaneStatus type + +This handoff was automatically created before context compaction. + +## In Progress + +[→] Phase 1a: Update shared/tabs-types.ts - Add PaneStatus type + +## Recent Completed + +None tracked + +## Resume Instructions + +1. Read this handoff to understand current state +2. Check the ledger for full context: thoughts/ledgers/CONTINUITY_CLAUDE-working-indicator.md +3. Continue from where you left off + +## Source Ledger + +/Users/andreasasprou/.superset/worktrees/superset/working-indicator/thoughts/ledgers/CONTINUITY_CLAUDE-working-indicator.md diff --git a/thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-03T08-03-16.md b/thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-03T08-03-16.md new file mode 100644 index 00000000000..7de2e0fcad0 --- /dev/null +++ b/thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-03T08-03-16.md @@ -0,0 +1,32 @@ +--- +type: auto-handoff +date: 2026-01-03T08:03:16.002Z +session_name: working-indicator +trigger: pre-compact (opencode) +--- + +# Auto-Handoff: [→] Phase 9: Test implementation + +This handoff was automatically created before context compaction. + +## In Progress + +[→] Phase 9: Test implementation + +## Recent Completed + +- Done: [x] Phase 5b: Update stores/tabs/store.ts - Add actions, migration +- Done: [x] Phase 6: Update useAgentHookListener.ts - Handle all events +- Done: [x] Phase 7a: Update WorkspaceItem.tsx - 3-color indicator +- Done: [x] Phase 7b: Update WorkspaceListItem.tsx - 3-color indicator +- Done: [x] Phase 8: Run typecheck and fix issues (pre-existing errors only remain) + +## Resume Instructions + +1. Read this handoff to understand current state +2. Check the ledger for full context: thoughts/ledgers/CONTINUITY_CLAUDE-working-indicator.md +3. Continue from where you left off + +## Source Ledger + +/Users/andreasasprou/.superset/worktrees/superset/working-indicator/thoughts/ledgers/CONTINUITY_CLAUDE-working-indicator.md diff --git a/thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-03T14-43-14.md b/thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-03T14-43-14.md new file mode 100644 index 00000000000..10f83492a79 --- /dev/null +++ b/thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-03T14-43-14.md @@ -0,0 +1,32 @@ +--- +type: auto-handoff +date: 2026-01-03T14:43:14.532Z +session_name: working-indicator +trigger: pre-compact (opencode) +--- + +# Auto-Handoff: [→] Phase 9: Test implementation + +This handoff was automatically created before context compaction. + +## In Progress + +[→] Phase 9: Test implementation + +## Recent Completed + +- Done: [x] Phase 5b: Update stores/tabs/store.ts - Add actions, migration +- Done: [x] Phase 6: Update useAgentHookListener.ts - Handle all events +- Done: [x] Phase 7a: Update WorkspaceItem.tsx - 3-color indicator +- Done: [x] Phase 7b: Update WorkspaceListItem.tsx - 3-color indicator +- Done: [x] Phase 8: Run typecheck and fix issues (pre-existing errors only remain) + +## Resume Instructions + +1. Read this handoff to understand current state +2. Check the ledger for full context: thoughts/ledgers/CONTINUITY_CLAUDE-working-indicator.md +3. Continue from where you left off + +## Source Ledger + +/Users/andreasasprou/.superset/worktrees/superset/working-indicator/thoughts/ledgers/CONTINUITY_CLAUDE-working-indicator.md diff --git a/thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-03T14-43-51.md b/thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-03T14-43-51.md new file mode 100644 index 00000000000..3a7f26b42ee --- /dev/null +++ b/thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-03T14-43-51.md @@ -0,0 +1,32 @@ +--- +type: auto-handoff +date: 2026-01-03T14:43:51.444Z +session_name: working-indicator +trigger: pre-compact (opencode) +--- + +# Auto-Handoff: [→] Phase 9: Test implementation + +This handoff was automatically created before context compaction. + +## In Progress + +[→] Phase 9: Test implementation + +## Recent Completed + +- Done: [x] Phase 5b: Update stores/tabs/store.ts - Add actions, migration +- Done: [x] Phase 6: Update useAgentHookListener.ts - Handle all events +- Done: [x] Phase 7a: Update WorkspaceItem.tsx - 3-color indicator +- Done: [x] Phase 7b: Update WorkspaceListItem.tsx - 3-color indicator +- Done: [x] Phase 8: Run typecheck and fix issues (pre-existing errors only remain) + +## Resume Instructions + +1. Read this handoff to understand current state +2. Check the ledger for full context: thoughts/ledgers/CONTINUITY_CLAUDE-working-indicator.md +3. Continue from where you left off + +## Source Ledger + +/Users/andreasasprou/.superset/worktrees/superset/working-indicator/thoughts/ledgers/CONTINUITY_CLAUDE-working-indicator.md From 545868935ae86254fc109c28c7824f290ed3191f Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Sat, 3 Jan 2026 18:31:20 +0200 Subject: [PATCH 95/98] fix(desktop): use HOOK_PROTOCOL_VERSION constant instead of hardcoded value Addresses code review feedback P2-A: single source of truth for protocol version. --- .../src/main/lib/notifications/server.ts | 5 ++-- .../CONTINUITY_CLAUDE-working-indicator.md | 30 +++++++++++++++++-- 2 files changed, 31 insertions(+), 4 deletions(-) diff --git a/apps/desktop/src/main/lib/notifications/server.ts b/apps/desktop/src/main/lib/notifications/server.ts index 5609227b7c4..0a453dfd612 100644 --- a/apps/desktop/src/main/lib/notifications/server.ts +++ b/apps/desktop/src/main/lib/notifications/server.ts @@ -3,6 +3,7 @@ import express from "express"; import { NOTIFICATION_EVENTS } from "shared/constants"; import { env } from "shared/env.shared"; import { appState } from "../app-state"; +import { HOOK_PROTOCOL_VERSION } from "../terminal/env"; /** * The environment this server is running in. @@ -138,9 +139,9 @@ app.get("/hook/complete", (req, res) => { } // Log version for debugging (helpful when troubleshooting hook issues) - if (version && version !== "2") { + if (version && version !== HOOK_PROTOCOL_VERSION) { console.log( - `[notifications] Received hook v${version} request (server expects v2)`, + `[notifications] Received hook v${version} request (server expects v${HOOK_PROTOCOL_VERSION})`, ); } diff --git a/thoughts/ledgers/CONTINUITY_CLAUDE-working-indicator.md b/thoughts/ledgers/CONTINUITY_CLAUDE-working-indicator.md index a5816224f4f..99db22eb142 100644 --- a/thoughts/ledgers/CONTINUITY_CLAUDE-working-indicator.md +++ b/thoughts/ledgers/CONTINUITY_CLAUDE-working-indicator.md @@ -1,7 +1,7 @@ --- created: 2026-01-02T19:50:00Z -last_updated: 2026-01-02T19:50:00Z -session_count: 1 +last_updated: 2026-01-03T15:58:00Z +session_count: 2 status: IN_PROGRESS --- @@ -265,3 +265,29 @@ Key features: ### Breaking Changes None - backwards compatible with existing persisted state (migration handled) + +--- + +## Code Review #2 (2026-01-03) + +### Feedback Analysis + +#### P2 Issues + +| Issue | Valid? | Action | +|-------|--------|--------| +| **P2-A**: `server.ts:141` hardcodes `"2"` instead of using `HOOK_PROTOCOL_VERSION` constant | ✅ VALID | Fix - import and use the constant | +| **P2-B**: `trpc-storage.ts` always returns `version: 0`, disabling Zustand persist versioning | ⚠️ VALID but PRE-EXISTING | This is NOT introduced by working-indicators. The adapter was already broken. Migration is idempotent so no corruption. Low priority. | + +#### Questions + +| Question | Response | +|----------|----------| +| **Q1**: With persistent terminals, can agent still be running after restart? Should use timeout/liveness? | Agent CAN still be running in daemon. However, status will auto-correct on next event (Start/Stop/Permission). Brief window of incorrect status is acceptable. Adding liveness check adds complexity for marginal benefit. **Decision: Document this limitation, don't add liveness check.** | +| **Q2**: `resolvePaneId` fallback - misattribute vs drop events? | **Misattribution is better than dropping.** If dropped, user sees NO indicator. If misattributed, at least SOME indicator shows on workspace. Worst case: wrong pane shows indicator, but user still gets alerted. **Decision: Keep current behavior, document trade-off.** | +| **Q3**: Should `thoughts/shared/handoffs/*` artifacts ship in repo? | ❌ **NO** - these are session artifacts. Should be in `.gitignore` or removed before merge. | + +### Action Items +- [x] P2-A: Use `HOOK_PROTOCOL_VERSION` constant in server.ts ✅ Fixed +- [ ] Q3: Remove or gitignore handoff artifacts before merge +- [ ] (Optional) P2-B: Fix trpc-storage version handling (separate PR - pre-existing issue) From 574432a9f3b04dd56dfc0e4f1f310e55a0fb644b Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Sat, 3 Jan 2026 18:47:08 +0200 Subject: [PATCH 96/98] chore: remove session handoff artifacts from repo These are temporary session artifacts that should not ship in the PR. --- .../auto-handoff-2026-01-02T12-58-19.md | 31 ------------------ .../auto-handoff-2026-01-02T14-14-50.md | 31 ------------------ .../auto-handoff-2026-01-02T18-31-55.md | 28 ---------------- .../auto-handoff-2026-01-03T08-03-16.md | 32 ------------------- .../auto-handoff-2026-01-03T14-43-14.md | 32 ------------------- .../auto-handoff-2026-01-03T14-43-51.md | 32 ------------------- 6 files changed, 186 deletions(-) delete mode 100644 thoughts/shared/handoffs/tui-white-screen/auto-handoff-2026-01-02T12-58-19.md delete mode 100644 thoughts/shared/handoffs/tui-white-screen/auto-handoff-2026-01-02T14-14-50.md delete mode 100644 thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-02T18-31-55.md delete mode 100644 thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-03T08-03-16.md delete mode 100644 thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-03T14-43-14.md delete mode 100644 thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-03T14-43-51.md diff --git a/thoughts/shared/handoffs/tui-white-screen/auto-handoff-2026-01-02T12-58-19.md b/thoughts/shared/handoffs/tui-white-screen/auto-handoff-2026-01-02T12-58-19.md deleted file mode 100644 index e7423bb6d51..00000000000 --- a/thoughts/shared/handoffs/tui-white-screen/auto-handoff-2026-01-02T12-58-19.md +++ /dev/null @@ -1,31 +0,0 @@ ---- -type: auto-handoff -date: 2026-01-02T12:58:19.863Z -session_name: tui-white-screen -trigger: pre-compact (opencode) ---- - -# Auto-Handoff: [→] Implement diagnostic logging to confirm root cause - -This handoff was automatically created before context compaction. - -## In Progress - -[→] Implement diagnostic logging to confirm root cause - -## Recent Completed - -[x] Captured problem statement + prior fix summary -- Done: [x] Identified alt-screen reattach path in Terminal.tsx -- Done: [x] Analyzed timing of current reattach flow -- Done: [x] Identified 3 likely root causes (ranked by probability) - -## Resume Instructions - -1. Read this handoff to understand current state -2. Check the ledger for full context: thoughts/ledgers/CONTINUITY_CLAUDE-tui-white-screen.md -3. Continue from where you left off - -## Source Ledger - -/Users/andreasasprou/.superset/worktrees/superset/persistent-terminals/thoughts/ledgers/CONTINUITY_CLAUDE-tui-white-screen.md diff --git a/thoughts/shared/handoffs/tui-white-screen/auto-handoff-2026-01-02T14-14-50.md b/thoughts/shared/handoffs/tui-white-screen/auto-handoff-2026-01-02T14-14-50.md deleted file mode 100644 index e038ed0c66e..00000000000 --- a/thoughts/shared/handoffs/tui-white-screen/auto-handoff-2026-01-02T14-14-50.md +++ /dev/null @@ -1,31 +0,0 @@ ---- -type: auto-handoff -date: 2026-01-02T14:14:50.011Z -session_name: tui-white-screen -trigger: pre-compact (opencode) ---- - -# Auto-Handoff: [→] Implement diagnostic logging to confirm root cause - -This handoff was automatically created before context compaction. - -## In Progress - -[→] Implement diagnostic logging to confirm root cause - -## Recent Completed - -[x] Captured problem statement + prior fix summary -- Done: [x] Identified alt-screen reattach path in Terminal.tsx -- Done: [x] Analyzed timing of current reattach flow -- Done: [x] Identified 3 likely root causes (ranked by probability) - -## Resume Instructions - -1. Read this handoff to understand current state -2. Check the ledger for full context: thoughts/ledgers/CONTINUITY_CLAUDE-tui-white-screen.md -3. Continue from where you left off - -## Source Ledger - -/Users/andreasasprou/.superset/worktrees/superset/persistent-terminals/thoughts/ledgers/CONTINUITY_CLAUDE-tui-white-screen.md diff --git a/thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-02T18-31-55.md b/thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-02T18-31-55.md deleted file mode 100644 index 9be59824f85..00000000000 --- a/thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-02T18-31-55.md +++ /dev/null @@ -1,28 +0,0 @@ ---- -type: auto-handoff -date: 2026-01-02T18:31:55.668Z -session_name: working-indicator -trigger: pre-compact (opencode) ---- - -# Auto-Handoff: [→] Phase 1a: Update shared/tabs-types.ts - Add PaneStatus type - -This handoff was automatically created before context compaction. - -## In Progress - -[→] Phase 1a: Update shared/tabs-types.ts - Add PaneStatus type - -## Recent Completed - -None tracked - -## Resume Instructions - -1. Read this handoff to understand current state -2. Check the ledger for full context: thoughts/ledgers/CONTINUITY_CLAUDE-working-indicator.md -3. Continue from where you left off - -## Source Ledger - -/Users/andreasasprou/.superset/worktrees/superset/working-indicator/thoughts/ledgers/CONTINUITY_CLAUDE-working-indicator.md diff --git a/thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-03T08-03-16.md b/thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-03T08-03-16.md deleted file mode 100644 index 7de2e0fcad0..00000000000 --- a/thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-03T08-03-16.md +++ /dev/null @@ -1,32 +0,0 @@ ---- -type: auto-handoff -date: 2026-01-03T08:03:16.002Z -session_name: working-indicator -trigger: pre-compact (opencode) ---- - -# Auto-Handoff: [→] Phase 9: Test implementation - -This handoff was automatically created before context compaction. - -## In Progress - -[→] Phase 9: Test implementation - -## Recent Completed - -- Done: [x] Phase 5b: Update stores/tabs/store.ts - Add actions, migration -- Done: [x] Phase 6: Update useAgentHookListener.ts - Handle all events -- Done: [x] Phase 7a: Update WorkspaceItem.tsx - 3-color indicator -- Done: [x] Phase 7b: Update WorkspaceListItem.tsx - 3-color indicator -- Done: [x] Phase 8: Run typecheck and fix issues (pre-existing errors only remain) - -## Resume Instructions - -1. Read this handoff to understand current state -2. Check the ledger for full context: thoughts/ledgers/CONTINUITY_CLAUDE-working-indicator.md -3. Continue from where you left off - -## Source Ledger - -/Users/andreasasprou/.superset/worktrees/superset/working-indicator/thoughts/ledgers/CONTINUITY_CLAUDE-working-indicator.md diff --git a/thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-03T14-43-14.md b/thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-03T14-43-14.md deleted file mode 100644 index 10f83492a79..00000000000 --- a/thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-03T14-43-14.md +++ /dev/null @@ -1,32 +0,0 @@ ---- -type: auto-handoff -date: 2026-01-03T14:43:14.532Z -session_name: working-indicator -trigger: pre-compact (opencode) ---- - -# Auto-Handoff: [→] Phase 9: Test implementation - -This handoff was automatically created before context compaction. - -## In Progress - -[→] Phase 9: Test implementation - -## Recent Completed - -- Done: [x] Phase 5b: Update stores/tabs/store.ts - Add actions, migration -- Done: [x] Phase 6: Update useAgentHookListener.ts - Handle all events -- Done: [x] Phase 7a: Update WorkspaceItem.tsx - 3-color indicator -- Done: [x] Phase 7b: Update WorkspaceListItem.tsx - 3-color indicator -- Done: [x] Phase 8: Run typecheck and fix issues (pre-existing errors only remain) - -## Resume Instructions - -1. Read this handoff to understand current state -2. Check the ledger for full context: thoughts/ledgers/CONTINUITY_CLAUDE-working-indicator.md -3. Continue from where you left off - -## Source Ledger - -/Users/andreasasprou/.superset/worktrees/superset/working-indicator/thoughts/ledgers/CONTINUITY_CLAUDE-working-indicator.md diff --git a/thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-03T14-43-51.md b/thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-03T14-43-51.md deleted file mode 100644 index 3a7f26b42ee..00000000000 --- a/thoughts/shared/handoffs/working-indicator/auto-handoff-2026-01-03T14-43-51.md +++ /dev/null @@ -1,32 +0,0 @@ ---- -type: auto-handoff -date: 2026-01-03T14:43:51.444Z -session_name: working-indicator -trigger: pre-compact (opencode) ---- - -# Auto-Handoff: [→] Phase 9: Test implementation - -This handoff was automatically created before context compaction. - -## In Progress - -[→] Phase 9: Test implementation - -## Recent Completed - -- Done: [x] Phase 5b: Update stores/tabs/store.ts - Add actions, migration -- Done: [x] Phase 6: Update useAgentHookListener.ts - Handle all events -- Done: [x] Phase 7a: Update WorkspaceItem.tsx - 3-color indicator -- Done: [x] Phase 7b: Update WorkspaceListItem.tsx - 3-color indicator -- Done: [x] Phase 8: Run typecheck and fix issues (pre-existing errors only remain) - -## Resume Instructions - -1. Read this handoff to understand current state -2. Check the ledger for full context: thoughts/ledgers/CONTINUITY_CLAUDE-working-indicator.md -3. Continue from where you left off - -## Source Ledger - -/Users/andreasasprou/.superset/worktrees/superset/working-indicator/thoughts/ledgers/CONTINUITY_CLAUDE-working-indicator.md From 20c8561778b8e4abba9cee403d35a0982fd7e572 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Sat, 3 Jan 2026 19:15:14 +0200 Subject: [PATCH 97/98] refactor(desktop): extract StatusIndicator shared component - Create StatusIndicator component with lookup-based config - Export getStatusTooltip() for consumers needing tooltips - Update 4 consumers: WorkspaceItem, WorkspaceListItem, TabItem, GroupStrip - Remove ~67 lines of duplicated JSX across components - Follows AGENTS.md: lookup objects over conditionals --- .../StatusIndicator/StatusIndicator.tsx | 68 +++++++++++++++++++ .../main/components/StatusIndicator/index.ts | 5 ++ .../TopBar/WorkspaceTabs/WorkspaceItem.tsx | 19 +----- .../WorkspaceListItem/WorkspaceListItem.tsx | 21 +----- .../TabsContent/GroupStrip/GroupStrip.tsx | 21 +----- .../Sidebar/TabsView/TabItem/index.tsx | 31 +++------ .../desktop/src/renderer/stores/tabs/store.ts | 7 +- 7 files changed, 89 insertions(+), 83 deletions(-) create mode 100644 apps/desktop/src/renderer/screens/main/components/StatusIndicator/StatusIndicator.tsx create mode 100644 apps/desktop/src/renderer/screens/main/components/StatusIndicator/index.ts diff --git a/apps/desktop/src/renderer/screens/main/components/StatusIndicator/StatusIndicator.tsx b/apps/desktop/src/renderer/screens/main/components/StatusIndicator/StatusIndicator.tsx new file mode 100644 index 00000000000..e446e30469e --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/StatusIndicator/StatusIndicator.tsx @@ -0,0 +1,68 @@ +import { cn } from "@superset/ui/utils"; +import type { PaneStatus } from "shared/tabs-types"; + +/** Lookup object for status indicator styling - avoids if/else chains */ +const STATUS_CONFIG = { + permission: { + pingColor: "bg-red-400", + dotColor: "bg-red-500", + pulse: true, + tooltip: "Needs input", + }, + working: { + pingColor: "bg-amber-400", + dotColor: "bg-amber-500", + pulse: true, + tooltip: "Agent working", + }, + review: { + pingColor: "", + dotColor: "bg-green-500", + pulse: false, + tooltip: "Ready for review", + }, +} as const satisfies Record< + Exclude, + { pingColor: string; dotColor: string; pulse: boolean; tooltip: string } +>; + +export type ActivePaneStatus = keyof typeof STATUS_CONFIG; + +interface StatusIndicatorProps { + status: ActivePaneStatus; + className?: string; +} + +/** + * Visual indicator for pane/workspace status. + * - Red pulsing: needs user input (permission) + * - Amber pulsing: agent working + * - Green static: ready for review + */ +export function StatusIndicator({ status, className }: StatusIndicatorProps) { + const config = STATUS_CONFIG[status]; + + return ( + + {config.pulse && ( + + )} + + + ); +} + +/** Get tooltip text for a status - for consumers that wrap with Tooltip */ +export function getStatusTooltip(status: ActivePaneStatus): string { + return STATUS_CONFIG[status].tooltip; +} diff --git a/apps/desktop/src/renderer/screens/main/components/StatusIndicator/index.ts b/apps/desktop/src/renderer/screens/main/components/StatusIndicator/index.ts new file mode 100644 index 00000000000..7d280f3ae9e --- /dev/null +++ b/apps/desktop/src/renderer/screens/main/components/StatusIndicator/index.ts @@ -0,0 +1,5 @@ +export { + StatusIndicator, + getStatusTooltip, + type ActivePaneStatus, +} from "./StatusIndicator"; diff --git a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx index f9597f90443..4070bdfd28a 100644 --- a/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx +++ b/apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/WorkspaceItem.tsx @@ -10,6 +10,7 @@ import { useSetActiveWorkspace, useWorkspaceDeleteHandler, } from "renderer/react-query/workspaces"; +import { StatusIndicator } from "renderer/screens/main/components/StatusIndicator"; import { useCloseSettings } from "renderer/stores/app-state"; import { useTabsStore } from "renderer/stores/tabs/store"; import { extractPaneIdsFromLayout } from "renderer/stores/tabs/utils"; @@ -222,23 +223,7 @@ export function WorkspaceItem({ {title} {aggregateStatus && ( - - {aggregateStatus === "permission" && ( - <> - - - - )} - {aggregateStatus === "working" && ( - <> - - - - )} - {aggregateStatus === "review" && ( - - )} - + )} )} diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx index e57f7528ac4..6ab9d7b8af3 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/WorkspaceListItem.tsx @@ -24,6 +24,7 @@ import { useSetActiveWorkspace, useWorkspaceDeleteHandler, } from "renderer/react-query/workspaces"; +import { StatusIndicator } from "renderer/screens/main/components/StatusIndicator"; import { BranchSwitcher } from "renderer/screens/main/components/TopBar/WorkspaceTabs/BranchSwitcher"; import { DeleteWorkspaceDialog } from "renderer/screens/main/components/TopBar/WorkspaceTabs/DeleteWorkspaceDialog"; import { useWorkspaceRename } from "renderer/screens/main/components/TopBar/WorkspaceTabs/useWorkspaceRename"; @@ -227,25 +228,7 @@ export function WorkspaceListItem({ {pr && ( )} - {aggregateStatus && ( - - {aggregateStatus === "permission" && ( - <> - - - - )} - {aggregateStatus === "working" && ( - <> - - - - )} - {aggregateStatus === "review" && ( - - )} - - )} + {aggregateStatus && }
{name !== branch && !isBranchWorkspace && (
diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx index 4159ed7bb7f..ac1655e02c3 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/ContentView/TabsContent/GroupStrip/GroupStrip.tsx @@ -4,6 +4,7 @@ import { cn } from "@superset/ui/utils"; import { useMemo } from "react"; import { HiMiniPlus, HiMiniXMark } from "react-icons/hi2"; import { trpc } from "renderer/lib/trpc"; +import { StatusIndicator } from "renderer/screens/main/components/StatusIndicator"; import { useTabsStore } from "renderer/stores/tabs/store"; import type { PaneStatus, Tab } from "renderer/stores/tabs/types"; import { getTabDisplayName } from "renderer/stores/tabs/utils"; @@ -42,25 +43,7 @@ function GroupItem({ {displayName} - {status && status !== "idle" && ( - - {status === "permission" && ( - <> - - - - )} - {status === "working" && ( - <> - - - - )} - {status === "review" && ( - - )} - - )} + {status && status !== "idle" && } diff --git a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/TabsView/TabItem/index.tsx b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/TabsView/TabItem/index.tsx index 774ee9a9061..d74454f7c80 100644 --- a/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/TabsView/TabItem/index.tsx +++ b/apps/desktop/src/renderer/screens/main/components/WorkspaceView/Sidebar/TabsView/TabItem/index.tsx @@ -5,6 +5,10 @@ import { useEffect, useMemo, useRef, useState } from "react"; import { useDrag, useDrop } from "react-dnd"; import { HiMiniCommandLine, HiMiniXMark } from "react-icons/hi2"; import { trpc } from "renderer/lib/trpc"; +import { + getStatusTooltip, + StatusIndicator, +} from "renderer/screens/main/components/StatusIndicator"; import { useTabsStore } from "renderer/stores/tabs/store"; import type { Tab } from "renderer/stores/tabs/types"; import { getTabDisplayName } from "renderer/stores/tabs/utils"; @@ -199,30 +203,13 @@ export function TabItem({ tab, index, isActive }: TabItemProps) { {aggregateStatus && ( - - {aggregateStatus === "permission" && ( - <> - - - - )} - {aggregateStatus === "working" && ( - <> - - - - )} - {aggregateStatus === "review" && ( - - )} - + - {aggregateStatus === "permission" - ? "Needs input" - : aggregateStatus === "working" - ? "Agent working" - : "Ready for review"} + {getStatusTooltip(aggregateStatus)} )} diff --git a/apps/desktop/src/renderer/stores/tabs/store.ts b/apps/desktop/src/renderer/stores/tabs/store.ts index bbe36a9b845..a3a6b14b70b 100644 --- a/apps/desktop/src/renderer/stores/tabs/store.ts +++ b/apps/desktop/src/renderer/stores/tabs/store.ts @@ -4,12 +4,7 @@ import { create } from "zustand"; import { devtools, persist } from "zustand/middleware"; import { trpcTabsStorage } from "../../lib/trpc-storage"; import { movePaneToNewTab, movePaneToTab } from "./actions/move-pane"; -import type { - AddFileViewerPaneOptions, - PaneStatus, - TabsState, - TabsStore, -} from "./types"; +import type { AddFileViewerPaneOptions, TabsState, TabsStore } from "./types"; import { type CreatePaneOptions, createFileViewerPane, From 127625ea45905f14c46c933e7caf3d93f53637e5 Mon Sep 17 00:00:00 2001 From: Andreas Asprou Date: Sat, 3 Jan 2026 20:39:49 +0200 Subject: [PATCH 98/98] fix(desktop): add missing ptyPid property to Session class --- apps/desktop/src/main/terminal-host/session.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/apps/desktop/src/main/terminal-host/session.ts b/apps/desktop/src/main/terminal-host/session.ts index 9b7c95276c7..bcbdec973e7 100644 --- a/apps/desktop/src/main/terminal-host/session.ts +++ b/apps/desktop/src/main/terminal-host/session.ts @@ -99,6 +99,7 @@ export class Session { // Promise that resolves when PTY is ready to accept writes private ptyReadyPromise: Promise; private ptyReadyResolve: (() => void) | null = null; + private ptyPid: number | null = null; private emulatorWriteQueue: string[] = []; private emulatorWriteQueuedBytes = 0;