2 Commits

Author	SHA1	Message	Date
Haile	44edf94f3a	Refactor provider/session architecture to be DB-driven, modular, and sessionId-first across backend and frontend (#715) ... * refactor: remove unused exports * refactor: remove unused fields from project and session objects * refactor: rename session_names table and related code to sessions for clarity and consistency * refactor(database): move db into typescript - Implemented githubTokensDb for managing GitHub tokens with CRUD operations. - Created otificationPreferencesDb to handle user notification preferences. - Added projectsDb for project path management and related operations. - Introduced pushSubscriptionsDb for managing browser push subscriptions. - Developed scanStateDb to track the last scanned timestamp. - Established sessionsDb for session management with CRUD functionalities. - Created userDb for user management, including authentication and onboarding. - Implemented apidKeysDb for storing and managing VAPID keys. feat(database): define schema for new database tables - Added SQL schema definitions for users, API keys, user credentials, notification preferences, VAPID keys, push subscriptions, projects, sessions, scan state, and app configuration. - Included necessary indexes for performance optimization. refactor(shared): enhance type definitions and utility functions - Updated shared types and interfaces for improved clarity and consistency. - Added new types for credential management and provider-specific operations. - Refined utility functions for better error handling and message normalization. * feat: added session indexer logic * perf(projects): lazy-load TaskMaster metadata per selected project Why: - /api/projects is a hot path (initial load, sidebar refresh, websocket sync). - Scanning .taskmaster for every project on each call added avoidable fs I/O and payload size. - TaskMaster metadata is only needed after selecting a specific project. - Moving it to a project-scoped endpoint makes loading cost match user intent. - The UI now hydrates TaskMaster state on selection and keeps it across refresh events. - This prevents status flicker/regression while still removing global scan overhead. - Selection fetches are sequence-guarded to block stale async responses on fast switching. - isManuallyAdded was removed from responses to keep the public project contract minimal. - Project dumps now use incrementing snapshot files to preserve history for debugging. What changed: - Added GET /api/projects/:projectName/taskmaster and getProjectTaskMaster(). - Removed TaskMaster detection from bulk getProjects(). - Added api.projectTaskmaster(...) plus selection-time hydration in frontend contexts. - Merged cached taskmaster values into refreshed project lists for continuity. - Removed isManuallyAdded from manual project payloads. * refactor: update import paths for database modules and remove legacy db.js and schema.js files * refactor(projects): identify projects by DB projectId instead of folder-derived name GET /api/projects used to scan ~/.claude/projects/ on every request, derive each project's identity from the encoded folder name, and re-parse JSONL files to build session lists. Using the folder-derived name as the project identifier leaked the Claude CLI's on-disk encoding into every API route, forced every downstream endpoint to re-resolve a real path via JSONL 'cwd' inspection, and made the project list endpoint O(projects x sessions) on disk I/O. This change switches the entire API surface to identify projects by the stable primary key from the 'projects' table and drives the listing straight from the DB: - Add projectsDb.getProjectPathById as the canonical projectId -> path resolver so routes no longer need to touch the filesystem to figure out where a project lives. - Rewrite getProjects so it reads the project list from the 'projects' table and the per-project session list from the 'sessions' table (one SELECT per project). No filesystem scanning happens for this endpoint anymore, which removes the dependency on ~/.claude/projects existing, on Cursor's MD5-hashed chat folders being discoverable, and on Codex's JSONL history being on disk. Per the migration spec each session now exposes 'summary' sourced from sessions.custom_name, 'messageCount' = 0 (message counting is not implemented), and sessionMeta.hasMore is pinned to false since this endpoint doesn't drive session pagination. - Introduce id-based wrappers (getSessionsById, renameProjectById, deleteSessionById, deleteProjectById, getProjectTaskMasterById) so every caller can pass projectId and resolve the real path through the DB. renameProjectById also writes to projects.custom_project_name so the DB-driven getProjects response reflects renames immediately; it keeps project-config.json in sync for any legacy reader that still consults the JSON file. - Migrate every /api/projects/:projectName route in server/index.js, server/routes/taskmaster.js, and server/routes/messages.js to :projectId, and change server/routes/git.js so the 'project' query/body parameter carries a projectId that is resolved through the DB before any git command runs. TaskMaster WebSocket broadcasts emit 'projectId' for the same reason so the frontend can match notifications against its current selection without another lookup. - Delete helpers that existed only to feed the old getProjects path (getCursorSessions, getGeminiCliSessions, getProjectTaskMaster) along with their unused imports (better-sqlite3's Database, applyCustomSessionNames). The legacy folder-name helpers (getSessions, renameProject, deleteSession, deleteProject, extractProjectDirectory) are kept as internal implementation details of the id-based wrappers and of destructive cleanup / conversation search, but they are no longer re-exported. - searchConversations still walks JSONL to produce match snippets (that data doesn't live in the DB), but it now includes the resolved projectId in each result so the sidebar can cross-reference hits with its already loaded project list without a second round-trip. Frontend migration: - Project.name is replaced by Project.projectId in src/types/app.ts, and ProjectSession.__projectName becomes __projectId so session tagging and sidebar state keys stay aligned with the backend identifier. Settings continues to use SettingsProject.name for legacy consumers, but it is populated from projectId by normalizeProjectForSettings. - All places that previously indexed per-project state by project.name (sidebar expanded/starred/loading/deletingProjects sets, additionalSessions map, projectHasMoreOverrides, starredProjects localStorage, command history and draft-input localStorage, TaskMaster caches) now key on projectId so state survives display-name edits and is consistent across the app. - src/utils/api.js renames every endpoint parameter to projectId, the unified messages endpoint takes projectId in its query string, and useSessionStore forwards projectId on fetchFromServer / fetchMore / refreshFromServer. Git panel, file tree, code editor, PRD editor, plugins context, MCP server flows and TaskMaster hooks are all updated to pass projectId. - DEFAULT_PROJECT_FOR_EMPTY_SHELL is updated to carry a 'default' projectId sentinel so the empty-shell placeholder still satisfies the Project contract. Bug fix bundled in: - sessionsDb.setName no longer bumps updated_at when a row already exists. Renaming is a label change, not activity, so there is no reason for it to reset 'last activity' in the sidebar. It also no longer relies on SQLite's CURRENT_TIMESTAMP, which stores a naive 'YYYY-MM-DD HH:MM:SS' value that JavaScript parses as local time and caused renamed sessions to appear shifted backwards by the client's UTC offset. When an INSERT actually happens it now writes ISO-8601 UTC with a 'Z' suffix. - buildSessionsByProviderFromDb normalizes any legacy naive timestamps in the sessions table to ISO-8601 UTC on the way out so rows written before this change also render correctly on the client. Other cleanup: - Removed the filesystem-first project-discovery comment block at the top of server/projects.js and replaced it with a short note that describes the new DB-driven flow and lists the few remaining filesystem-dependent helpers (message reads, search, destructive delete, manual project registration). - server/modules/providers/index.ts is added as a small barrel so the providers module exposes a stable public surface. Made-with: Cursor * refactor(projects): reorganize project-related logic into dedicated modules * refactor(projects): rename getProjects with getProjectsWithSessions * refactor: update import path for getProjectsWithSessions to include file extension * refactor: use updated session watcher In addition, for projects_updated websocket response, send the sessionId instead * refactor(websocket): move websocket logic to its own module * refactor(sessions-watcher): remove redundant logging after session sync completion * refactor(index.js): reorganize code structure * refactor(index.js): fix import order * refactor: remove unnecessary GitHub cloning logic from create-workspace endpoint * refactor: modularize project services, and wizard create/clone flow Restructure project creation, listing, GitHub clone progress, and TaskMaster details behind a dedicated TypeScript module under server/modules/projects/, and align the client wizard with a single path-based flow. Server / routing - Remove server/routes/projects.js and mount server/modules/projects/ projects.routes.ts at /api/projects (still behind authenticateToken). - Drop duplicate handlers from server/index.js for GET /api/projects and GET /api/projects/:projectId/taskmaster; those live on the new router. - Import WORKSPACES_ROOT and validateWorkspacePath from shared utils in index.js instead of the deleted projects route module. Projects router (projects.routes.ts) - GET /: list projects with sessions (existing snapshot behavior). - POST /create-project: validate body, reject legacy workspaceType and mixed clone fields, delegate to createProject service, return distinct success copy when an archived path is reactivated. - GET /clone-progress: Server-Sent Events for clone progress/complete/error; requires authenticated user id for token resolution; wires startCloneProject. - GET /:projectId/taskmaster: delegates to getProjectTaskMaster. Services (new) - project-management.service.ts: path validation, workspace directory creation, persistence via projectsDb.createProjectPath, mapping to API project shape; surfaces AppError for validation, conflict, and not-found cases; optional dependency injection for tests. - project-clone.service.ts: validates workspace, resolves GitHub auth (stored token or inline token), runs git clone with progress callbacks, registers project via createProject on success; sanitizes errors and supports cancellation; injectable dependencies for tests. - projects-has-taskmaster.service.ts: moves TaskMaster detection and normalization out of server/projects.js; resolve-by-id and public getProjectTaskMaster with structured AppError responses. Persistence and shared types - projectsDb.createProjectPath now returns CreateProjectPathResult (created | reactivated_archived | active_conflict) using INSERT … ON CONFLICT with selective update when the row is archived; normalizes display name from path or custom name; repository row typing moves to shared ProjectRepositoryRow. - getProjectPaths() returns only non-archived rows (isArchived = 0). - shared/types.ts: ProjectRepositoryRow, CreateProjectPathResult/outcome, WorkspacePathValidationResult. - shared/utils.ts: WORKSPACES_ROOT, forbidden path lists, validateWorkspacePath, asyncHandler for Express async routes. Legacy cleanup - server/projects.js: remove detectTaskMasterFolder, normalizeTaskMasterInfo, and getProjectTaskMasterById (logic lives in the new service). - server/routes/agent.js: register external API project paths with projectsDb.createProjectPath instead of addProjectManually try/catch; treat active_conflict as an existing registration and continue. Tests - Add Node test suites for project-management, project-clone, and projects-has-taskmaster services; update projects.service test import for renamed projects-with-sessions-fetch.service.ts. Rename - projects.service.ts → projects-with-sessions-fetch.service.ts; re-export from modules/projects/index.ts. Client (project creation wizard) - Remove StepTypeSelection and workspaceType from form state and types; wizard is two steps (configure path/GitHub auth, then review). - createWorkspaceRequest → createProjectRequest; clone vs create-only inferred from githubUrl (pathUtils / isCloneWorkflow). - Adjust step indices, WizardProgress, StepConfiguration/Review, WorkspacePathField, and src/utils/api.js as needed for the new API. Docs - Minor websocket README touch-up. Net: ~1.6k insertions / ~0.9k deletions across 29 files; behavior is centralized in typed services with explicit HTTP errors and test seams. * refactor: remove loading sessions logic from sidebar * refactor: move project rename to module * refactor: move project deletion to module * refactor: move project star state from localStorage to backend * refactor: implement optimistic UI for project star state management * feat: optimistic update for session watcher * fix(projects-state): stop websocket message reprocessing loop The websocket projects effect in useProjectsState could re-handle the same latestMessage after local state writes triggered re-renders. Under bursty websocket traffic, this created an update feedback cycle that surfaced as 'Maximum update depth exceeded', often from Sidebar. What changed: - Added lastHandledMessageRef so each latestMessage object is handled once. - Added an early return guard when the current message was already handled. - Made projects updates idempotent by comparing previous and merged payloads before calling setProjects. Result: - Breaks the effect -> state update -> effect re-entry cycle. - Reduces redundant renders during rapid projects_updated traffic while preserving normal project/session synchronization. * refactor: optimize project auto-expand logic * refactor: move projects provider specific logic into respective session providers * refactor: move rename and delete sessions to modules * refactor: move fetching messages to module * fix: remove unused var Co-authored-by: Copilot Autofix powered by AI <223894421+github-code-quality[bot]@users.noreply.github.com> * Potential fix for pull request finding 'Useless assignment to local variable' Co-authored-by: Copilot Autofix powered by AI <223894421+github-code-quality[bot]@users.noreply.github.com> * refactor(projects/sidebar): remove temp snapshot side-effects and simplify session metadata UX Why this change was needed: - Project listing had an implicit side effect: every fetch wrote a debug snapshot under `.tmp/project-dumps`. That added unnecessary disk I/O to a hot path, introduced hidden runtime behavior, and created maintenance overhead for code that was not part of product functionality. - Keeping snapshot-specific exports/tests around made the projects module API broader than needed and coupled tests to temporary/debug behavior instead of user-visible behavior. - Codex sessions could remain stuck with a placeholder name (`Untitled Codex Session`) even after a real title became available from newer sync data, which degraded session discoverability in the UI. - Sidebar session rows showed duplicated provider branding and long-form relative times, which added visual noise and reduced scan speed when many sessions are listed. What changed: - Removed temporary projects snapshot dumping from `projects-with-sessions-fetch.service.ts`: - deleted snapshot types/helpers and file-write flow - removed the write call from `getProjectsWithSessions` - Removed snapshot-related surface area from `projects/index.ts`. - Removed the snapshot-focused test `projects.service.test.ts` that only validated removed debug behavior. - Updated `codex-session-synchronizer.provider.ts` to upgrade session names when an existing session still has the placeholder title but a real parsed name is now available. - Updated `SidebarSessionItem.tsx`: - removed duplicate provider logo rendering in each session row - moved age indicator to the right side - made age indicator fade on hover to prioritize action controls - switched to compact relative time format (`<1m`, `Xm`, `Xhr`, `Xd`) for faster list scanning Outcome: - Lower overhead and fewer hidden side effects in project fetches. - Cleaner module boundaries in projects. - Better Codex session naming consistency after sync. - Cleaner sidebar density and clearer hover/action behavior. * refactor: implement pagination for project sessions loading * refactor: move search to module * fix: search performance * refactor: add handling for internal Codex metadata in conversation search * fix(migrations,projects,clone): normalize legacy schema before writes and harden conflict detection Why - Legacy installs can have a sessions table shape that predates provider/custom_name columns. Running migrateLegacySessionNames first caused its INSERT OR REPLACE INTO sessions (...) to target columns that may not exist and fail during startup migration. - Some upgraded databases had projects.project_id as plain TEXT instead of a real PRIMARY KEY. That breaks assumptions used by id-based lookups and can allow invalid/duplicate identity semantics over time. - projectsDb.createProjectPath inferred outcomes from ow.isArchived, but the upsert path always returns the post-update row with isArchived=0, so archived-reactivation and fresh-create could be misclassified. - git clone accepted user-controlled URLs directly in argv position, so inputs beginning with - could be interpreted as options instead of a repository argument. What - Added ebuildProjectsTableWithPrimaryKeySchema in migrations: detect table shape via getTableInfo('projects'), verify project_id has pk=1, and rebuild when missing. - Rebuild flow now creates a canonical projects__new table (project_id TEXT PRIMARY KEY), copies rows with transformation, backfills empty ids via SQLITE_UUID_SQL, deduplicates conflicting ids/paths, then swaps tables inside a transaction. - Replaced the prior ddColumnToTableIfNotExists(...) + UPDATE project_id sequence with PK-aware detection/rebuild logic so legacy DBs converge to the required schema. - Reordered migration sequence to run ebuildSessionsTableWithProjectSchema before migrateLegacySessionNames, ensuring sessions is normalized before legacy session_names merge writes execute. - Updated projectsDb.createProjectPath to generate an ttemptedId before insert, pass it into the prepared statement, and classify outcomes by comparing returned ow.project_id to ttemptedId (created vs eactivated_archived), with no-row remaining ctive_conflict. - Hardened clone execution by inserting -- before clone URL in git argv and rejecting normalized GitHub URLs that start with - in startCloneProject. Tests - Added integration coverage for projectsDb.createProjectPath branches: fresh insert, archived reactivation, and active conflict. - Added clone service test for option-prefixed githubUrl rejection (INVALID_GITHUB_URL). * refactor(session-synchronizer): update last scanned timestamp based on synchronization results * refactor: improve session limit and offset validation in provider routes * refactor: normalize project paths across database and service modules * refactor(database): make session id the primary key in sessions table * fix(codex): preserve reasoning entries as thinking blocks Codex history normalization was downgrading reasoning into plain assistant text because of branch ordering, not because the raw data was missing. Why this mattered: - Codex reasoning JSONL entries are intentionally mapped to history items with type thinking, but they also carry message.role assistant. - normalizeHistoryEntry evaluated the assistant-role branch before the thinking branch. - As a result, reasoning content matched the assistant-text path first and was emitted as kind text instead of kind thinking. - This collapses semantic intent, so UI and downstream features that rely on thinking blocks (separate rendering, filtering, and interpretation of model thought process vs final answer) receive the wrong message kind. What changed: - Prioritized thinking detection (raw.type === thinking or raw.isReasoning) before role-based assistant normalization. - Kept a non-empty content guard for thinking payloads to avoid emitting empty artifacts. Impact: - Reasoning entries from persisted Codex JSONL now remain thinking blocks end-to-end. - Regular assistant text normalization behavior remains unchanged. * refactor: remove dead code * refactor: directly use getProjectPathById from projectsDb * refactor: add gemini jsonl session support	2026-04-30 08:19:26 +02:00
Haile	a77f213dd5	fix: numerous bugs (#528) ... * fix(shell): copy terminal selections from xterm buffer The shell was delegating Cmd/Ctrl+C to document.execCommand('copy'), which copied the rendered DOM selection instead of xterm's logical buffer text. Wrapped values like login URLs could pick up row whitespace or line breaks and break when pasted. Route keyboard copy through terminal.getSelection() and the shared clipboard helper. Also intercept native copy events on the terminal container so mouse selection and browser copy actions use the same normalized terminal text. Remove the copy listener during teardown to avoid leaking handlers across terminal reinitialization. * fix(shell): restore terminal focus when switching to the shell tab Pass shell activity state from MainContent through StandaloneShell and use it inside Shell to explicitly focus the xterm instance once the terminal is both initialized and connected. Previously, switching to the Shell tab left focus on the tab button because isActive was being ignored and the terminal never called focus() after the tab activation lifecycle completed. As a result, users had to click inside the terminal before keyboard input would be accepted. This change wires isActive through the shell stack, removes the unused prop handling in Shell, and adds a focus effect that runs when the shell becomes active and ready. The effect uses both requestAnimationFrame and a zero-delay timeout so focus is applied reliably after rendering and connection state updates settle. This restores immediate typing when opening the shell tab and also improves the reconnect path by re-focusing the terminal after the shell connection is ready. * fix(shell): remove fallback command for codex and claude session resumes The `|| claude` and `|| codex` fallback commands were causing errors as they are not valid commands. * fix: use fallback while resuming codex and claude sessions for linux and windows * feat(git): add revert latest local commit action in git panel Add a complete revert-local-commit flow so users can undo the most recent local commit directly from the Git header, placed before the refresh icon. Backend - add POST /api/git/revert-local-commit endpoint in server/routes/git.js - validate project input and repository state before executing git operations - revert latest commit with `git reset --soft HEAD~1` to keep changes staged - handle initial-commit edge case by deleting HEAD ref when no parent exists - return clear success and error responses for UI consumption Frontend - add useRevertLocalCommit hook to encapsulate API call and loading state - wire hook into GitPanel and refresh git data after successful revert - add new toolbar action in GitPanelHeader before refresh icon - route action through existing confirmation modal flow - disable action while request is in flight and show activity indicator Shared UI and typing updates - extend ConfirmActionType with `revertLocalCommit` - add confirmation title, label, and style mappings for new action - render RotateCcw icon for revert action in ConfirmActionModal Result - users can safely undo the latest local commit from the UI - reverted commit changes remain staged for immediate recommit/edit workflows * fix: run cursor with --trust if workspace trust prompt is detected, and retry once * fix(git): handle repositories without commits across status and remote flows Improve git route behavior for repositories initialized with `git init` but with no commits yet. Previously, several routes called `git rev-parse --abbrev-ref HEAD`, which fails before the first commit and caused noisy console errors plus a broken Git panel state. What changed - add `getGitErrorDetails` helper to normalize git process failure text - add `isMissingHeadRevisionError` helper to detect no-HEAD/no-revision cases - add `getCurrentBranchName` helper: - uses `git symbolic-ref --short HEAD` first (works before first commit) - falls back to `git rev-parse --abbrev-ref HEAD` for detached HEAD and edge cases - add `repositoryHasCommits` helper using `git rev-parse --verify HEAD` Status route improvements - replace inline branch/HEAD error handling with shared helpers - keep returning valid branch + `hasCommits: false` for fresh repositories Remote status improvements - avoid hard failure when repository has no commits - return a safe, non-error payload with: - `hasUpstream: false` - `ahead: 0`, `behind: 0` - detected remote name when remotes exist - message: "Repository has no commits yet" - preserve existing upstream detection behavior for repositories with commits Consistency updates - switch fetch/pull/push/publish branch lookup to shared `getCurrentBranchName` to ensure the same branch-resolution behavior everywhere Result - `git init` repositories no longer trigger `rev-parse HEAD` ambiguity failures - Git panel remains usable before the first commit - backend branch detection is centralized and consistent across git operations * fix(git): resolve file paths against repo root for paths with spaces Fix path resolution for git file operations when project directories include spaces or when API calls are issued from subdirectories inside a repository. Problem - operations like commit/discard/diff could receive file paths that were valid from repo root but were executed from a nested cwd - this produced pathspec errors like: - warning: could not open directory '4/4/' - fatal: pathspec '4/hello_world.ts' did not match any files Root cause - file arguments were passed directly to git commands using the project cwd - inconsistent path forms (repo-root-relative vs cwd-relative) were not normalized Changes - remove unsafe fallback decode in `getActualProjectPath`; fail explicitly when the real project path cannot be resolved - add repository/file-path helpers: - `getRepositoryRootPath` - `normalizeRepositoryRelativeFilePath` - `parseStatusFilePaths` - `buildFilePathCandidates` - `resolveRepositoryFilePath` - update file-based git endpoints to resolve paths before executing commands: - GET `/diff` - GET `/file-with-diff` - POST `/commit` - POST `/generate-commit-message` - POST `/discard` - POST `/delete-untracked` - stage/restore/reset operations now use `--` before pathspecs for safer argument separation Behavioral impact - git operations now work reliably for repositories under directories containing spaces - file operations are consistent even when project cwd is a subdirectory of repo root - endpoint responses continue to preserve existing payload shapes Verification - syntax check: `node --check server/routes/git.js` - typecheck: `npm run typecheck` - reproduced failing scenario in a temp path with spaces; confirmed root-resolved path staging succeeds where subdir-cwd pathspec previously failed * fix(git-ui): prevent large commit diffs from freezing the history tab Harden commit diff loading/rendering so opening a very large commit no longer hangs the browser tab. Problem - commit history diff viewer rendered every diff line as a React node - very large commits could create thousands of nodes and lock the UI thread - backend always returned full commit patch payloads, amplifying frontend pressure Backend safeguards - add `COMMIT_DIFF_CHARACTER_LIMIT` (500,000 chars) in git routes - update GET `/api/git/commit-diff` to truncate oversized diff payloads - include `isTruncated` flag in response for observability/future UI handling - append truncation marker text when server-side limit is applied Frontend safeguards - update `GitDiffViewer` to use bounded preview rendering: - character cap: 200,000 - line cap: 1,500 - move diff preprocessing into `useMemo` for stable, one-pass preview computation - show a clear "Large diff preview" notice when truncation is active Impact - commit diff expansion remains responsive even for high-change commits - UI still shows useful diff content while avoiding tab lockups - changes apply to shared diff viewer usage and improve resilience broadly Validation - `node --check server/routes/git.js` - `npm run typecheck` - `npx eslint src/components/git-panel/view/shared/GitDiffViewer.tsx` * fix(cursor-chat): stabilize first-run UX and clean cursor message rendering Fix three Cursor chat regressions observed on first message runs: 1. Full-screen UI refresh/flicker after first response. 2. Internal wrapper tags rendered in user messages. 3. Duplicate assistant message on response finalization. Root causes - Project refresh from chat completion used the global loading path, toggling app-level loading UI. - Cursor history conversion rendered raw internal wrapper payloads as user-visible message text. - Cursor response handling could finalize through overlapping stream/ result paths, and stdout chunk parsing could split JSON lines. Changes - Added non-blocking project refresh plumbing for chat/session flows. - Introduced fetch options in useProjectsState (showLoadingState flag). - Added refreshProjectsSilently() to update metadata without global loading UI. - Wired window.refreshProjects to refreshProjectsSilently in AppContent. - Added Cursor user-message sanitization during history conversion. - Added extractCursorUserQuery() to keep only <user_query> payload. - Added sanitizeCursorUserMessageText() to strip internal wrappers: <user_info>, <agent_skills>, <available_skills>, <environment_context>, <environment_info>. - Applied sanitization only for role === 'user' in convertCursorSessionMessages(). - Hardened Cursor backend stream parsing and finalization. - Added line-buffered stdout parser for chunk-split JSON payloads. - Flushed trailing unterminated stdout line on process close. - Removed redundant content_block_stop emission on Cursor result. - Added frontend duplicate guard in cursor-result handling. - Skips a second assistant bubble when final result text equals already-rendered streamed content. Code comments - Added focused comments describing silent refresh behavior, tag stripping rationale, duplicate guard behavior, and line buffering. Validation - ESLint passes for touched files. - Production build succeeds. Files - server/cursor-cli.js - src/components/app/AppContent.tsx - src/components/chat/hooks/useChatRealtimeHandlers.ts - src/components/chat/utils/messageTransforms.ts - src/hooks/useProjectsState.ts --------- Co-authored-by: Haileyesus <something@gmail.com> Co-authored-by: Simos Mikelatos <simosmik@gmail.com>	2026-03-11 00:16:11 +01:00