perf: reduce re-renders, fix mobile keyboard handling, add chunk load recovery, and improve PATH management (#1028)

* fix: exclude file content from reverted prompt text Revert and fork now restore only the user's original prompt, not server-injected file content Uses existing isSyntheticPart helper for type-safe filtering * fix: keep scrollbar visible when hovering over thumb * fix: prevent ESC abort from triggering when terminal is focused * fix: pass directory to permission/question reply calls so approvals actually resolve * fix: default model selection not responding after Base UI migration * fix: prevent modal content from shifting and clipping footer buttons * fix: improve session switching performance and add sub-agent export with prompt collapse Defer viewport anchor saving to eliminate ~800ms UI freeze when switching sessions Add export dialog to include sub-agent tasks recursively in markdown export Add collapse chevron button for expanded user prompts in sticky header * fix: resolve sidebar scroll and TDZ crash in session sidebar * perf: reduce CPU overhead and re-renders across chat, layout, and settings * fix: position collapse button at top of message and prevent ESC abort in terminal * fix: position collapse button at top and add padding only when expanded * refactor: extract shared PATH utilities and mobile keyboard hook * refactor: import shared path-utils in electron, use module-level style constants - Electron now imports pathLooksUserConfigured/mergePathValues from shared path-utils.js instead of inline duplication - ToolPart collapsedCustomStyle moved from useMemo([]) to module const * fix: resolve remaining merge conflicts and type errors - Remove duplicate variable declarations in SessionNodeItem - Remove orphaned export callback body from conflict resolution - Fix HelpDialog description -> descriptionKey (i18n rename) * fix: resolve type-check and lint errors in session-actions.test.ts - Added missing bun:test type declarations (beforeEach, mock, mock.module) - Removed unused State import - Replaced 'as any' casts with proper OpencodeClient and ChildStoreManager types - Added eslint-disable for unused _ parameter in mock function * fix PR 1028 export and PATH edge cases * fix startup retry exhaustion state * remove opencode package lock change * fix sub-session rename cancellation --------- Co-authored-by: Bohdan Triapitsyn <artmore@protonmail.com>
2026-04-26 16:24:07 +03:00
parent 632e6cc97b
commit 4523e9c486
87 changed files with 1918 additions and 703 deletions
@@ -0,0 +1,241 @@
+import { describe, expect, test, beforeEach, mock } from "bun:test"
+import type { PermissionRequest } from "@/types/permission"
+
+// Mock SDK client that records permission.reply / question.reply calls
+const replyCalls: Array<{ method: string; params: Record<string, unknown> }> = []
+
+const mockScopedClient = {
+  permission: {
+    reply: mock((params: Record<string, unknown>) => {
+      replyCalls.push({ method: "permission.reply", params })
+      return Promise.resolve({ data: true })
+    }),
+  },
+  question: {
+    reply: mock((params: Record<string, unknown>) => {
+      replyCalls.push({ method: "question.reply", params })
+      return Promise.resolve({ data: true })
+    }),
+    reject: mock((params: Record<string, unknown>) => {
+      replyCalls.push({ method: "question.reject", params })
+      return Promise.resolve({ data: true })
+    }),
+  },
+}
+
+const mockSdk = {
+  permission: {
+    reply: mock((params: Record<string, unknown>) => {
+      replyCalls.push({ method: "permission.reply", params })
+      return Promise.resolve({ data: true })
+    }),
+  },
+  question: {
+    reply: mock((params: Record<string, unknown>) => {
+      replyCalls.push({ method: "question.reply", params })
+      return Promise.resolve({ data: true })
+    }),
+    reject: mock((params: Record<string, unknown>) => {
+      replyCalls.push({ method: "question.reject", params })
+      return Promise.resolve({ data: true })
+    }),
+  },
+}
+
+// Mock opencodeClient singleton
+mock.module("@/lib/opencode/client", () => ({
+  opencodeClient: {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getScopedSdkClient: (_: string) => mockScopedClient,
+    getDirectory: () => "/test/project",
+  },
+}))
+
+// Mock useConfigStore
+mock.module("@/stores/useConfigStore", () => ({
+  useConfigStore: {
+    getState: () => ({
+      isConnected: true,
+      hasEverConnected: true,
+    }),
+  },
+}))
+
+// Mock useSessionUIStore
+mock.module("./session-ui-store", () => ({
+  useSessionUIStore: {
+    getState: () => ({
+      getDirectoryForSession: (sessionId: string) => {
+        if (sessionId === "session-a") return "/test/project"
+        if (sessionId === "session-b") return "/other/project"
+        return null
+      },
+    }),
+  },
+}))
+
+// Mock useInputStore (imported but not used in permission functions)
+mock.module("./input-store", () => ({
+  useInputStore: {},
+}))
+
+// Mock useGlobalSessionsStore (imported but not used in permission functions)
+mock.module("@/stores/useGlobalSessionsStore", () => ({
+  useGlobalSessionsStore: {},
+}))
+
+// Mock sync-refs (imported but not used in permission functions)
+mock.module("./sync-refs", () => ({
+  registerSessionDirectory: () => {},
+}))
+
+import { create, type StoreApi } from "zustand"
+import { INITIAL_STATE } from "./types"
+import type { DirectoryStore } from "./child-store"
+import type { OpencodeClient } from "@opencode-ai/sdk/v2/client"
+
+function createStore(permissions: Record<string, PermissionRequest[]>): StoreApi<DirectoryStore> {
+  return create<DirectoryStore>()((set) => ({
+    ...INITIAL_STATE,
+    permission: permissions,
+    patch: (partial) => set(partial),
+    replace: (next) => set(next),
+  }))
+}
+
+function createChildStores(entries: Array<[string, StoreApi<DirectoryStore>]>) {
+  return {
+    children: new Map(entries),
+    ensureChild: (dir: string) => {
+      const store = new Map(entries).get(dir)
+      if (!store) throw new Error(`No store for ${dir}`)
+      return store
+    },
+  } as unknown as import("./child-store").ChildStoreManager
+}
+
+describe("respondToPermission passes directory", () => {
+  beforeEach(() => {
+    replyCalls.length = 0
+  })
+
+  test("passes directory from child store when permission is found", async () => {
+    const permission: PermissionRequest = {
+      id: "perm-1",
+      sessionID: "session-a",
+      permission: "bash",
+      patterns: [],
+      metadata: {},
+      always: [],
+    }
+
+    const store = createStore({ "session-a": [permission] })
+    const childStores = createChildStores([["/test/project", store]])
+
+    const { setActionRefs, respondToPermission } = await import("./session-actions")
+    setActionRefs(mockSdk as unknown as OpencodeClient, childStores, () => "/test/project")
+
+    await respondToPermission("session-a", "perm-1", "once")
+
+    expect(replyCalls.length).toBe(1)
+    expect(replyCalls[0].params.requestID).toBe("perm-1")
+    expect(replyCalls[0].params.reply).toBe("once")
+    expect(replyCalls[0].params.directory).toBe("/test/project")
+  })
+
+  test("passes directory from session mapping when permission not in store", async () => {
+    const childStores = createChildStores([])
+
+    const { setActionRefs, respondToPermission } = await import("./session-actions")
+    setActionRefs(mockSdk as unknown as OpencodeClient, childStores, () => "/test/project")
+
+    await respondToPermission("session-b", "perm-2", "always")
+
+    expect(replyCalls.length).toBe(1)
+    expect(replyCalls[0].params.requestID).toBe("perm-2")
+    expect(replyCalls[0].params.reply).toBe("always")
+    expect(replyCalls[0].params.directory).toBe("/other/project")
+  })
+
+  test("passes directory from current directory as last resort", async () => {
+    const childStores = createChildStores([])
+
+    const { setActionRefs, respondToPermission } = await import("./session-actions")
+    setActionRefs(mockSdk as unknown as OpencodeClient, childStores, () => "/fallback/dir")
+
+    await respondToPermission("unknown-session", "perm-3", "reject")
+
+    expect(replyCalls.length).toBe(1)
+    expect(replyCalls[0].params.requestID).toBe("perm-3")
+    expect(replyCalls[0].params.reply).toBe("reject")
+    expect(replyCalls[0].params.directory).toBe("/fallback/dir")
+  })
+})
+
+describe("dismissPermission passes directory", () => {
+  beforeEach(() => {
+    replyCalls.length = 0
+  })
+
+  test("passes directory and reply=reject", async () => {
+    const permission: PermissionRequest = {
+      id: "perm-10",
+      sessionID: "session-a",
+      permission: "edit",
+      patterns: [],
+      metadata: {},
+      always: [],
+    }
+
+    const store = createStore({ "session-a": [permission] })
+    const childStores = createChildStores([["/test/project", store]])
+
+    const { setActionRefs, dismissPermission } = await import("./session-actions")
+    setActionRefs(mockSdk as unknown as OpencodeClient, childStores, () => "/test/project")
+
+    await dismissPermission("session-a", "perm-10")
+
+    expect(replyCalls.length).toBe(1)
+    expect(replyCalls[0].params.requestID).toBe("perm-10")
+    expect(replyCalls[0].params.reply).toBe("reject")
+    expect(replyCalls[0].params.directory).toBe("/test/project")
+  })
+})
+
+describe("respondToQuestion passes directory", () => {
+  beforeEach(() => {
+    replyCalls.length = 0
+  })
+
+  test("passes directory to question.reply", async () => {
+    const childStores = createChildStores([])
+
+    const { setActionRefs, respondToQuestion } = await import("./session-actions")
+    setActionRefs(mockSdk as unknown as OpencodeClient, childStores, () => "/test/project")
+
+    await respondToQuestion("session-a", "q-1", [["answer1"]])
+
+    expect(replyCalls.length).toBe(1)
+    expect(replyCalls[0].params.requestID).toBe("q-1")
+    expect(replyCalls[0].params.directory).toBe("/test/project")
+  })
+})
+
+describe("rejectQuestion passes directory", () => {
+  beforeEach(() => {
+    replyCalls.length = 0
+  })
+
+  test("passes directory to question.reject", async () => {
+    const childStores = createChildStores([])
+
+    const { setActionRefs, rejectQuestion } = await import("./session-actions")
+    setActionRefs(mockSdk as unknown as OpencodeClient, childStores, () => "/test/project")
+
+    await rejectQuestion("session-a", "q-2")
+
+    expect(replyCalls.length).toBe(1)
+    expect(replyCalls[0].params.requestID).toBe("q-2")
+    expect(replyCalls[0].params.directory).toBe("/test/project")
+  })
+})
@@ -12,6 +12,7 @@ import { opencodeClient } from "@/lib/opencode/client"
 import { useGlobalSessionsStore } from "@/stores/useGlobalSessionsStore"
 import { useConfigStore } from "@/stores/useConfigStore"
 import { registerSessionDirectory } from "./sync-refs"
+import { isSyntheticPart } from "@/lib/messages/synthetic"

 // Reference set by SyncProvider — allows actions to access SDK and stores
 let _sdk: OpencodeClient | null = null
@@ -443,9 +444,13 @@ export async function respondToPermission(
  response: "once" | "always" | "reject",
 ): Promise<void> {
  await waitForConnectionOrThrow()
+  const directory = resolveDirectoryForBlockingRequest("permission", sessionId, requestId)
+    || getSessionDirectory(sessionId)
+    || dir()
  const result = await getRequestReplyClient("permission", sessionId, requestId).permission.reply({
    requestID: requestId,
    reply: response,
+    ...(directory ? { directory } : {}),
  })
  if (!result.data) {
    throw new Error("Permission reply failed")
@@ -457,9 +462,13 @@ export async function dismissPermission(
  requestId: string,
 ): Promise<void> {
  await waitForConnectionOrThrow()
+  const directory = resolveDirectoryForBlockingRequest("permission", sessionId, requestId)
+    || getSessionDirectory(sessionId)
+    || dir()
  const result = await getRequestReplyClient("permission", sessionId, requestId).permission.reply({
    requestID: requestId,
    reply: "reject",
+    ...(directory ? { directory } : {}),
  })
  if (!result.data) {
    throw new Error("Permission dismissal failed")
@@ -476,9 +485,13 @@ export async function respondToQuestion(
  answers: string[] | string[][],
 ): Promise<void> {
  await waitForConnectionOrThrow()
+  const directory = resolveDirectoryForBlockingRequest("question", sessionId, requestId)
+    || getSessionDirectory(sessionId)
+    || dir()
  const result = await getRequestReplyClient("question", sessionId, requestId).question.reply({
    requestID: requestId,
    answers: answers as Array<Array<string>>,
+    ...(directory ? { directory } : {}),
  })
  if (!result.data) {
    throw new Error("Question reply failed")
@@ -490,8 +503,12 @@ export async function rejectQuestion(
  requestId: string,
 ): Promise<void> {
  await waitForConnectionOrThrow()
+  const directory = resolveDirectoryForBlockingRequest("question", sessionId, requestId)
+    || getSessionDirectory(sessionId)
+    || dir()
  const result = await getRequestReplyClient("question", sessionId, requestId).question.reject({
    requestID: requestId,
+    ...(directory ? { directory } : {}),
  })
  if (!result.data) {
    throw new Error("Question rejection failed")
@@ -525,13 +542,14 @@ export async function revertToMessage(sessionId: string, messageId: string): Pro
    }
  }

-  // Extract message text for prompt restoration
+  // Extract message text for prompt restoration (only non-synthetic text parts —
+  // the server adds file content as synthetic text parts that should not be restored)
  const messages = state.message[sessionId] ?? []
  const targetMsg = messages.find((m) => m.id === messageId)
  let messageText = ""
  if (targetMsg && targetMsg.role === "user") {
    const parts = state.part[messageId] ?? []
-    const textParts = parts.filter((p) => p.type === "text")
+    const textParts = parts.filter((p) => p.type === "text" && !isSyntheticPart(p))
    messageText = textParts
      .map((p: Record<string, unknown>) => (p as { text?: string }).text || (p as { content?: string }).content || "")
      .join("\n")
@@ -646,10 +664,11 @@ export async function forkFromMessage(sessionId: string, messageId: string): Pro
  const store = dirStore()
  const state = store.getState()

-  // Extract message text for input restoration
+  // Extract message text for input restoration (only non-synthetic text parts —
+  // the server adds file content as synthetic text parts that should not be restored)
  const parts = state.part[messageId] ?? []
  let messageText = ""
-  const textParts = parts.filter((p) => p.type === "text")
+  const textParts = parts.filter((p) => p.type === "text" && !isSyntheticPart(p))
  messageText = textParts
    .map((p: Part) => ((p as Record<string, unknown>).text as string) || ((p as Record<string, unknown>).content as string) || "")
    .join("\n")
@@ -358,6 +358,10 @@ export const useSessionUIStore = create<SessionUIState>()((set, get) => ({
    }

    const previousSessionId = get().currentSessionId
+
+    // Set currentSessionId immediately so the skeleton renders without delay.
+    set({ currentSessionId: id })
+
    const directoryState = useDirectoryStore.getState()

    const sessionDir = resolveSessionDirectory(
@@ -376,20 +380,21 @@ export const useSessionUIStore = create<SessionUIState>()((set, get) => ({
      console.warn("Failed to set OpenCode directory for session switch:", e)
    }

-    // Save viewport anchor for previous session
+    // Defer viewport anchor save for previous session — not needed for the
+    // skeleton to render and reads messages which can be expensive.
    if (previousSessionId && previousSessionId !== id) {
-      const memState = useViewportStore.getState().sessionMemoryState.get(previousSessionId)
-      if (!memState?.isStreaming) {
-        const prevMessages = getSyncMessages(previousSessionId)
-        if (prevMessages.length > 0) {
-          useViewportStore.getState().updateViewportAnchor(previousSessionId, prevMessages.length - 1)
+      const prevId = previousSessionId
+      setTimeout(() => {
+        const memState = useViewportStore.getState().sessionMemoryState.get(prevId)
+        if (!memState?.isStreaming) {
+          const prevMessages = getSyncMessages(prevId)
+          if (prevMessages.length > 0) {
+            useViewportStore.getState().updateViewportAnchor(prevId, prevMessages.length - 1)
+          }
        }
-      }
+      }, 0)
    }

-    set({ currentSessionId: id })
-
-    // Mark session viewed in notification store + update active session ref
    // Mark session viewed in notification store + update active session ref
    if (id) {
      markSessionViewed(id)
@@ -169,12 +169,18 @@ export function getSessionWorktreeRepairActions(
 export type MutationBlockingReason =
  | { reason: 'attention'; attentionReason: NonNullable<SessionWorktreeAttachment['attentionReason']> }
  | { reason: 'missing' }
-  | { reason: 'invalid' };
+  | { reason: 'invalid' }
+  | { reason: 'dirty'; dirtyFiles?: number };

 export function getMutationBlockingReasons(
-  attachment: SessionWorktreeAttachment | null | undefined
+  attachment: SessionWorktreeAttachment | null | undefined,
+  gitStatus?: { isClean?: boolean; files?: Array<{ path: string }> }
 ): MutationBlockingReason[] {
  const reasons: MutationBlockingReason[] = [];
+  if (gitStatus && gitStatus.isClean === false) {
+    const dirtyFiles = gitStatus.files?.length;
+    reasons.push(dirtyFiles != null ? { reason: 'dirty', dirtyFiles } : { reason: 'dirty' });
+  }
  if (!attachment) return reasons;
  if (attachment.worktreeStatus === 'missing') {
    reasons.push({ reason: 'missing' });