Fix 5 bugs: project deletion in browser mode, hardcoded model string, dead code, server state overwrite, stale query caches

cursoragent · cursoragent · commit 8816ba5f810b · 2026-02-22T01:27:02.000Z
- Fix project deletion in browser mode by removing isElectron guard around
  api.projects.remove() call (Sidebar.tsx)
- Replace hardcoded 'gpt-5-codex' with DEFAULT_MODEL / 'gpt-5.3-codex' in
  wsServer.ts and core reducer.ts
- Remove unused bindTerminalEvents method and its imports from coreRuntime.ts
- Preserve client-local terminal UI state (terminalOpen, terminalHeight,
  activeTerminalId, terminalGroups, activeTerminalGroupId) during
  SET_SERVER_STATE merges in store.ts
- Invalidate git and checkpoint diff query caches when turn completions are
  detected in server state updates (__root.tsx)
diff --git a/apps/server/src/coreRuntime.ts b/apps/server/src/coreRuntime.ts
@@ -1,11 +1,15 @@
 import path from "node:path";
 import crypto from "node:crypto";
-import type { ProviderEvent, ProviderSession, TerminalEvent } from "@t3tools/contracts";
-import { EffectFanout, OrchestrationEngine, QueueProjector, type AppViewState } from "@t3tools/core";
+import type { ProviderEvent, ProviderSession } from "@t3tools/contracts";
+import {
+  EffectFanout,
+  OrchestrationEngine,
+  QueueProjector,
+  type AppViewState,
+} from "@t3tools/core";
 import { createSqliteStores } from "@t3tools/infra-sqlite";
 
 import type { ProviderManager } from "./providerManager";
-import type { TerminalManager } from "./terminalManager";
 
 function nowIso(): string {
   return new Date().toISOString();
@@ -21,7 +25,11 @@ export class CoreRuntime {
     const dbPath = path.join(dbDir, "event-store.sqlite");
     this.stores = createSqliteStores(dbPath);
     this.projector = new QueueProjector(this.stores.projectionStore, this.fanout);
-    this.engine = new OrchestrationEngine(this.stores.eventStore, this.stores.projectionStore, this.projector);
+    this.engine = new OrchestrationEngine(
+      this.stores.eventStore,
+      this.stores.projectionStore,
+      this.projector,
+    );
   }
 
   async start(cwd: string, projectName: string): Promise<void> {
@@ -57,22 +65,6 @@ export class CoreRuntime {
     });
   }
 
-  bindTerminalEvents(terminalManager: TerminalManager): void {
-    terminalManager.on("event", (event: TerminalEvent) => {
-      if (event.type !== "activity" && event.type !== "error" && event.type !== "exited") return;
-      void this.dispatch({
-        id: crypto.randomUUID(),
-        type: "thread.setTerminalActivity",
-        issuedAt: event.createdAt,
-        payload: {
-          threadId: event.threadId,
-          terminalId: event.terminalId,
-          running: event.type === "activity" ? event.hasRunningSubprocess : false,
-        },
-      });
-    });
-  }
-
   async bindProviderSession(threadId: string, session: ProviderSession): Promise<void> {
     await this.dispatch({
       id: crypto.randomUUID(),
diff --git a/apps/server/src/wsServer.ts b/apps/server/src/wsServer.ts
@@ -7,6 +7,7 @@ import crypto from "node:crypto";
 import type { Duplex } from "node:stream";
 
 import {
+  DEFAULT_MODEL,
   EDITORS,
   WS_CHANNELS,
   WS_METHODS,
@@ -304,7 +305,8 @@ export function createServer(options: ServerOptions) {
     switch (request.method) {
       case WS_METHODS.providersStartSession: {
         const session = await providerManager.startSession(request.params as never);
-        const uiThreadId = typeof paramsObj.uiThreadId === "string" ? paramsObj.uiThreadId : undefined;
+        const uiThreadId =
+          typeof paramsObj.uiThreadId === "string" ? paramsObj.uiThreadId : undefined;
         if (uiThreadId) {
           await coreRuntime.bindProviderSession(uiThreadId, session);
         }
@@ -313,8 +315,11 @@ export function createServer(options: ServerOptions) {
 
       case WS_METHODS.providersSendTurn: {
         const sessionId = typeof paramsObj.sessionId === "string" ? paramsObj.sessionId : undefined;
-        const uiThreadId = typeof paramsObj.uiThreadId === "string" ? paramsObj.uiThreadId : undefined;
-        const targetThread = uiThreadId ? state.threads.find((thread) => thread.id === uiThreadId) : findThreadBySessionId(sessionId);
+        const uiThreadId =
+          typeof paramsObj.uiThreadId === "string" ? paramsObj.uiThreadId : undefined;
+        const targetThread = uiThreadId
+          ? state.threads.find((thread) => thread.id === uiThreadId)
+          : findThreadBySessionId(sessionId);
         const inputText = typeof paramsObj.input === "string" ? paramsObj.input : undefined;
         if (targetThread && inputText && inputText.trim().length > 0) {
           await coreRuntime.dispatch({
@@ -363,52 +368,49 @@ export function createServer(options: ServerOptions) {
       case WS_METHODS.projectsList:
         return projectRegistry.list();
 
-      case WS_METHODS.projectsAdd:
-        {
-          const result = projectRegistry.add(request.params as never);
+      case WS_METHODS.projectsAdd: {
+        const result = projectRegistry.add(request.params as never);
+        await coreRuntime.dispatch({
+          id: crypto.randomUUID(),
+          type: "project.add",
+          issuedAt: requestNow,
+          payload: {
+            id: result.project.id,
+            name: result.project.name,
+            cwd: result.project.cwd,
+            model: DEFAULT_MODEL,
+            scripts: result.project.scripts,
+          },
+        });
+        return result;
+      }
+
+      case WS_METHODS.projectsRemove: {
+        const projectId = typeof paramsObj.id === "string" ? paramsObj.id : undefined;
+        if (projectId) {
           await coreRuntime.dispatch({
             id: crypto.randomUUID(),
-            type: "project.add",
+            type: "project.remove",
             issuedAt: requestNow,
-            payload: {
-              id: result.project.id,
-              name: result.project.name,
-              cwd: result.project.cwd,
-              model: "gpt-5-codex",
-              scripts: result.project.scripts,
-            },
+            payload: { id: projectId },
           });
-          return result;
         }
-
-      case WS_METHODS.projectsRemove:
-        {
-          const projectId = typeof paramsObj.id === "string" ? paramsObj.id : undefined;
-          if (projectId) {
-            await coreRuntime.dispatch({
-              id: crypto.randomUUID(),
-              type: "project.remove",
-              issuedAt: requestNow,
-              payload: { id: projectId },
-            });
-          }
         projectRegistry.remove(request.params as never);
         return undefined;
-        }
+      }
 
       case WS_METHODS.projectsSearchEntries:
         return searchWorkspaceEntries(request.params as never);
-      case WS_METHODS.projectsUpdateScripts:
-        {
-          const result = projectRegistry.updateScripts(request.params as never);
-          await coreRuntime.dispatch({
-            id: crypto.randomUUID(),
-            type: "project.updateScripts",
-            issuedAt: requestNow,
-            payload: { id: result.project.id, scripts: result.project.scripts },
-          });
-          return result;
-        }
+      case WS_METHODS.projectsUpdateScripts: {
+        const result = projectRegistry.updateScripts(request.params as never);
+        await coreRuntime.dispatch({
+          id: crypto.randomUUID(),
+          type: "project.updateScripts",
+          issuedAt: requestNow,
+          payload: { id: result.project.id, scripts: result.project.scripts },
+        });
+        return result;
+      }
 
       case WS_METHODS.shellOpenInEditor: {
         const params = request.params as {
diff --git a/apps/web/src/components/Sidebar.tsx b/apps/web/src/components/Sidebar.tsx
@@ -379,22 +379,18 @@ export default function Sidebar() {
       );
       if (!confirmed) return;
 
-      if (isElectron) {
-        try {
-          await api.projects.remove({ id: projectId });
-        } catch (error) {
-          const message =
-            error instanceof Error ? error.message : "Unknown error deleting project.";
-          console.error("Failed to remove project", { projectId, error });
-          toastManager.add({
-            type: "error",
-            title: `Failed to delete "${project.name}"`,
-            description: message,
-          });
-          return;
-        }
+      try {
+        await api.projects.remove({ id: projectId });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error deleting project.";
+        console.error("Failed to remove project", { projectId, error });
+        toastManager.add({
+          type: "error",
+          title: `Failed to delete "${project.name}"`,
+          description: message,
+        });
+        return;
       }
-
     },
     [api, dispatch, state.projects, state.threads],
   );
diff --git a/apps/web/src/routes/__root.tsx b/apps/web/src/routes/__root.tsx
@@ -4,14 +4,16 @@ import {
   type ErrorComponentProps,
   useParams,
 } from "@tanstack/react-router";
-import { useEffect } from "react";
-import { QueryClient } from "@tanstack/react-query";
+import { useEffect, useRef } from "react";
+import { QueryClient, useQueryClient } from "@tanstack/react-query";
 
 import { APP_DISPLAY_NAME } from "../branding";
 import { Button } from "../components/ui/button";
 import { AnchoredToastProvider, ToastProvider } from "../components/ui/toast";
 import { isElectron } from "../env";
 import { useNativeApi } from "../hooks/useNativeApi";
+import { invalidateGitQueries } from "../lib/gitReactQuery";
+import { providerQueryKeys } from "../lib/providerReactQuery";
 import { type AppState, useStore } from "../store";
 import { onServerStateUpdate, onServerWelcome } from "../wsNativeApi";
 
@@ -123,10 +125,12 @@ function errorDetails(error: unknown): string {
 function EventRouter() {
   const api = useNativeApi();
   const { dispatch } = useStore();
+  const queryClient = useQueryClient();
   const activeThreadId = useParams({
     strict: false,
     select: (params) => params.threadId,
   });
+  const prevTurnCompletionsRef = useRef<Map<string, string | undefined>>(new Map());
 
   useEffect(() => {
     if (!api) return;
@@ -142,9 +146,28 @@ function EventRouter() {
 
   useEffect(() => {
     return onServerStateUpdate((snapshot) => {
-      dispatch({ type: "SET_SERVER_STATE", state: snapshot as AppState });
+      const serverState = snapshot as AppState;
+      dispatch({ type: "SET_SERVER_STATE", state: serverState });
+
+      let hasNewTurnCompletion = false;
+      for (const thread of serverState.threads) {
+        const prev = prevTurnCompletionsRef.current.get(thread.id);
+        if (thread.latestTurnCompletedAt && thread.latestTurnCompletedAt !== prev) {
+          hasNewTurnCompletion = true;
+        }
+      }
+      const nextMap = new Map<string, string | undefined>();
+      for (const thread of serverState.threads) {
+        nextMap.set(thread.id, thread.latestTurnCompletedAt);
+      }
+      prevTurnCompletionsRef.current = nextMap;
+
+      if (hasNewTurnCompletion) {
+        void invalidateGitQueries(queryClient);
+        void queryClient.invalidateQueries({ queryKey: providerQueryKeys.all });
+      }
     });
-  }, [dispatch]);
+  }, [dispatch, queryClient]);
 
   useEffect(() => {
     if (!activeThreadId) return;
diff --git a/apps/web/src/store.ts b/apps/web/src/store.ts
@@ -127,7 +127,6 @@ function normalizeRunningTerminalIds(
     .filter((id) => id.length > 0 && validTerminalIdSet.has(id));
 }
 
-
 function normalizeTerminalGroupIds(terminalIds: string[]): string[] {
   return [...new Set(terminalIds.map((id) => id.trim()).filter((id) => id.length > 0))];
 }
@@ -297,11 +296,26 @@ function closeThreadTerminal(thread: Thread, terminalId: string): Thread {
 
 export function reducer(state: AppState, action: Action): AppState {
   switch (action.type) {
-    case "SET_SERVER_STATE":
+    case "SET_SERVER_STATE": {
+      const previousThreadById = new Map(
+        state.threads.map((thread) => [thread.id, thread] as const),
+      );
       return {
         ...action.state,
-        threads: action.state.threads.map((thread) => normalizeThreadTerminals(thread)),
+        threads: action.state.threads.map((thread) => {
+          const prev = previousThreadById.get(thread.id);
+          if (!prev) return normalizeThreadTerminals(thread);
+          return normalizeThreadTerminals({
+            ...thread,
+            terminalOpen: prev.terminalOpen,
+            terminalHeight: prev.terminalHeight,
+            activeTerminalId: prev.activeTerminalId,
+            terminalGroups: prev.terminalGroups,
+            activeTerminalGroupId: prev.activeTerminalGroupId,
+          });
+        }),
       };
+    }
 
     case "ADD_PROJECT":
       if (state.projects.some((project) => project.cwd === action.project.cwd)) {
@@ -447,10 +461,7 @@ export function reducer(state: AppState, action: Action): AppState {
         threads: updateThread(state.threads, action.threadId, (thread) => {
           const normalizedThread = normalizeThreadTerminals(thread);
           const isNewTerminal = !normalizedThread.terminalIds.includes(action.terminalId);
-          if (
-            isNewTerminal &&
-            normalizedThread.terminalIds.length >= MAX_THREAD_TERMINAL_COUNT
-          ) {
+          if (isNewTerminal && normalizedThread.terminalIds.length >= MAX_THREAD_TERMINAL_COUNT) {
             return normalizedThread;
           }
           const terminalIds = normalizedThread.terminalIds.includes(action.terminalId)
@@ -520,10 +531,7 @@ export function reducer(state: AppState, action: Action): AppState {
         threads: updateThread(state.threads, action.threadId, (thread) => {
           const normalizedThread = normalizeThreadTerminals(thread);
           const isNewTerminal = !normalizedThread.terminalIds.includes(action.terminalId);
-          if (
-            isNewTerminal &&
-            normalizedThread.terminalIds.length >= MAX_THREAD_TERMINAL_COUNT
-          ) {
+          if (isNewTerminal && normalizedThread.terminalIds.length >= MAX_THREAD_TERMINAL_COUNT) {
             return normalizedThread;
           }
           const terminalIds = normalizedThread.terminalIds.includes(action.terminalId)
diff --git a/packages/core/src/projections/reducer.ts b/packages/core/src/projections/reducer.ts
