feat(settings): add environments settings (#1361)

* feat(settings): add environments settings

* fix(settings): harden environments handling

Author: zerob13

docs/specs/settings-environments/plan.md

@@ -0,0 +1,67 @@
+# Settings Environments Plan
+
+## Data Model
+
+- Add `new_environments` with:
+  - `path TEXT PRIMARY KEY`
+  - `session_count INTEGER NOT NULL`
+  - `last_used_at INTEGER NOT NULL`
+- Add index `idx_new_environments_last_used` on `last_used_at DESC`.
+- Add schema migration `v17` to create the table.
+- Add schema migration `v18` to rebuild environment history from:
+  - non-draft `new_sessions.project_dir`
+  - ACP `workdir` rows when the linked session has no `project_dir`
+
+## Synchronization Strategy
+
+- Keep `new_environments` as a derived table managed in application code.
+- `NewSessionManager` recomputes all affected paths after session create, update, and delete.
+- ACP session persistence updates also recompute affected environment paths when `workdir` changes.
+- `LegacyChatImportService` performs a full rebuild after import because it writes session rows directly.
+- `SQLitePresenter.clearNewAgentData()` clears `new_environments` together with session-domain tables.
+
+## Presenter / IPC
+
+- Extend `IProjectPresenter` with:
+  - `getEnvironments()`
+  - `openDirectory(path)`
+- Extend `IConfigPresenter` with:
+  - `getDefaultProjectPath()`
+  - `setDefaultProjectPath(path | null)`
+- Add `CONFIG_EVENTS.DEFAULT_PROJECT_PATH_CHANGED` so renderers can react to default directory updates.
+
+## Renderer
+
+- Add `EnvironmentsSettings.vue` under settings routes.
+- Reuse current settings card layout and controls.
+- Use a switch to control temp directory visibility.
+- Use the project store to:
+  - fetch environment history
+  - manage the default project path
+  - open directories
+- Extend the project store with:
+  - `environments`
+  - `defaultProjectPath`
+  - selection-source tracking so default selection does not override manual selection
+  - synthetic project injection for missing default/manual paths
+
+## Sorting and Grouping
+
+- Sort by:
+  - default directory first
+  - then `lastUsedAt DESC`
+- Render as one main list, with temp environments appended in a collapsed section.
+- Treat app-managed workspace roots, including legacy app-data `workspaces` paths, as temp entries.
+
+## Test Strategy
+
+- Main process:
+  - migration `v18` backfill and idempotency
+  - `NewEnvironmentsTable` single-path recompute, ACP `workdir` fallback, draft filtering, delete-on-empty, full rebuild
+  - `ProjectPresenter` environment mapping and directory open behavior
+  - `NewSessionManager` environment sync calls
+  - `LegacyChatImportService` rebuild trigger and `workdir` import fallback
+- Renderer:
+  - settings page rendering, temp switch collapse, open/default/clear actions
+  - project store default selection and synthetic project behavior
+  - new thread page consumes the preselected project path

docs/specs/settings-environments/spec.md

@@ -0,0 +1,50 @@
+# Settings Environments
+
+## Summary
+
+Add a new settings page, `Environments / 目录环境`, to show project directories that have actually been used by sessions. Users can review basic metadata, open a directory, and set or clear a default directory for new chats.
+
+## User Stories
+
+- As a user, I want to see which project directories my sessions have used so I can reopen them quickly.
+- As a user, I want to set one default directory for new chats without overriding a directory I select manually later.
+- As a user, I want temporary workspace directories separated from regular directories so the primary list stays clean.
+
+## Acceptance Criteria
+
+- Settings navigation includes `settings-environments` after `Display` and before provider settings.
+- The page shows:
+  - a single merged environments list
+  - a temp environments section collapsed by default and controlled by a switch
+- Environment entries come from directories used by non-draft sessions, using `new_sessions.project_dir` first and falling back to ACP `workdir` history when `project_dir` is missing.
+- Each entry shows:
+  - directory name
+  - full path
+  - session count
+  - last used time based on `new_sessions.updated_at`
+  - badges for default, temp, missing, and synthetic default states when applicable
+- Users can:
+  - open a directory with one click
+  - set a directory as default directly on the item
+  - clear the current default directory directly on the default item
+- Temp directories are determined by whether the path is under `app.getPath('temp')` or an app-managed workspace root under app data / legacy user data.
+- Default directory only preselects the project on the new thread page. Manual user selection remains higher priority.
+- If the default directory is not present in recent projects, the new thread page still surfaces it through a synthetic project entry.
+
+## Non-Goals
+
+- Git status, rename, delete, or add-environment actions
+- Tracking directories that were only opened in a picker without being used by a session
+- Trigger-based SQLite maintenance
+
+## Constraints
+
+- Follow existing settings visual language instead of reproducing the reference screenshot.
+- Use i18n for all user-facing strings.
+- Use a derived SQLite table for environment history to avoid scanning `new_sessions` on every page load.
+
+## Migration Notes
+
+- Introduce `new_environments` as a derived table.
+- Backfill it once from existing session history in schema migration `v18`, including ACP `workdir` fallback when `project_dir` is absent.
+- Keep it synchronized in application code when sessions change.

src/main/events.ts

@@ -42,7 +42,8 @@ export const CONFIG_EVENTS = {
   FONT_SIZE_CHANGED: 'config:font-size-changed', // 字体大小变更事件
   DEFAULT_SYSTEM_PROMPT_CHANGED: 'config:default-system-prompt-changed', // Default system prompt changed event
   CUSTOM_PROMPTS_CHANGED: 'config:custom-prompts-changed', // 自定义提示词变更事件
-  NOWLEDGE_MEM_CONFIG_UPDATED: 'config:nowledge-mem-config-updated' // Nowledge-mem configuration updated event
+  NOWLEDGE_MEM_CONFIG_UPDATED: 'config:nowledge-mem-config-updated', // Nowledge-mem configuration updated event
+  DEFAULT_PROJECT_PATH_CHANGED: 'config:default-project-path-changed'
 }
 
 // Provider DB（聚合 JSON）相关事件

src/main/presenter/configPresenter/index.ts

@@ -98,6 +98,7 @@ interface IAppSettings {
   hooksNotifications?: HooksNotificationsSettings // Hooks & notifications settings
   defaultModel?: { providerId: string; modelId: string } // Default model for new conversations
   defaultVisionModel?: { providerId: string; modelId: string } // Default vision model for image tools
+  defaultProjectPath?: string | null
   [key: string]: unknown // Allow arbitrary keys, using unknown type instead of any
 }
 
@@ -1867,6 +1868,19 @@ export class ConfigPresenter implements IConfigPresenter {
   setDefaultVisionModel(model: { providerId: string; modelId: string } | undefined): void {
     this.setSetting('defaultVisionModel', model)
   }
+
+  getDefaultProjectPath(): string | null {
+    const path = this.getSetting<string | null>('defaultProjectPath')
+    return path?.trim() ? path.trim() : null
+  }
+
+  setDefaultProjectPath(projectPath: string | null): void {
+    const normalized = projectPath?.trim() ? projectPath.trim() : null
+    this.setSetting('defaultProjectPath', normalized)
+    eventBus.sendToRenderer(CONFIG_EVENTS.DEFAULT_PROJECT_PATH_CHANGED, SendTarget.ALL_WINDOWS, {
+      path: normalized
+    })
+  }
 }
 
 export { defaultShortcutKey } from './shortcutKeySettings'

src/main/presenter/index.ts

@@ -285,10 +285,12 @@ export class Presenter implements IPresenter {
         (
           this.sqlitePresenter as unknown as import('./sqlitePresenter').SQLitePresenter
         ).newSessionsTable?.getActiveSkills(conversationId) ?? [],
-      setPersistedNewSessionSkills: (conversationId, skills) =>
-        (
-          this.sqlitePresenter as unknown as import('./sqlitePresenter').SQLitePresenter
-        ).newSessionsTable?.updateActiveSkills(conversationId, skills),
+      setPersistedNewSessionSkills: (conversationId, skills) => {
+        const sqlitePresenter = this
+          .sqlitePresenter as unknown as import('./sqlitePresenter').SQLitePresenter
+        sqlitePresenter.newSessionsTable?.updateActiveSkills(conversationId, skills)
+        sqlitePresenter.newEnvironmentsTable?.syncForSession(conversationId)
+      },
       repairImportedLegacySessionSkills: async (conversationId) => {
         const newAgentPresenter = this.newAgentPresenter as INewAgentPresenter & {
           repairImportedLegacySessionSkills?: (sessionId: string) => Promise<string[]>

src/main/presenter/newAgentPresenter/legacyImportService.ts

@@ -368,7 +368,7 @@ export class LegacyChatImportService {
           this.pickString(conversation, ['active_skills']) ?? ''
         )
 
-        let projectDir = this.pickString(conversation, ['agent_workspace_path']) ?? null
+        let projectDir = this.pickString(conversation, ['agent_workspace_path', 'workdir']) ?? null
         if (!projectDir && agentId !== 'deepchat') {
           const workdirMap = this.parseJsonRecord(
             this.pickString(conversation, ['acp_workdir_map']) ?? ''
@@ -535,6 +535,15 @@ export class LegacyChatImportService {
         }
       }
     })
+    try {
+      // newEnvironmentsTable.rebuildFromSessions only refreshes derived environment metadata.
+      this.sqlitePresenter.newEnvironmentsTable.rebuildFromSessions()
+    } catch (error) {
+      console.error('[LegacyChatImport] Failed to rebuild environments after import:', {
+        error,
+        message: error instanceof Error ? error.message : String(error)
+      })
+    }
 
     return {
       importedSessions,

src/main/presenter/newAgentPresenter/sessionManager.ts

@@ -22,6 +22,7 @@ export class NewSessionManager {
       isDraft: options?.isDraft,
       disabledAgentTools: options?.disabledAgentTools
     })
+    this.sqlitePresenter.newEnvironmentsTable.syncPath(projectDir)
     return id
   }
 
@@ -58,6 +59,13 @@ export class NewSessionManager {
     id: string,
     fields: Partial<Pick<SessionRecord, 'title' | 'projectDir' | 'isPinned' | 'isDraft'>>
   ): void {
+    const current = this.sqlitePresenter.newSessionsTable.get(id)
+    if (!current) {
+      return
+    }
+
+    const affectedPaths = new Set(this.sqlitePresenter.newEnvironmentsTable.listPathsForSession(id))
+
     const dbFields: {
       title?: string
       project_dir?: string | null
@@ -69,10 +77,22 @@ export class NewSessionManager {
     if (fields.isPinned !== undefined) dbFields.is_pinned = fields.isPinned ? 1 : 0
     if (fields.isDraft !== undefined) dbFields.is_draft = fields.isDraft ? 1 : 0
     this.sqlitePresenter.newSessionsTable.update(id, dbFields)
+
+    for (const path of this.sqlitePresenter.newEnvironmentsTable.listPathsForSession(id)) {
+      affectedPaths.add(path)
+    }
+
+    for (const path of affectedPaths) {
+      this.sqlitePresenter.newEnvironmentsTable.syncPath(path)
+    }
   }
 
   delete(id: string): void {
+    const affectedPaths = this.sqlitePresenter.newEnvironmentsTable.listPathsForSession(id)
     this.sqlitePresenter.newSessionsTable.delete(id)
+    for (const path of affectedPaths) {
+      this.sqlitePresenter.newEnvironmentsTable.syncPath(path)
+    }
   }
 
   getDisabledAgentTools(id: string): string[] {
@@ -81,6 +101,7 @@ export class NewSessionManager {
 
   updateDisabledAgentTools(id: string, disabledAgentTools: string[]): void {
     this.sqlitePresenter.newSessionsTable.updateDisabledAgentTools(id, disabledAgentTools)
+    this.sqlitePresenter.newEnvironmentsTable.syncForSession(id)
   }
 
   // Window binding management

src/main/presenter/projectPresenter/index.ts

@@ -1,15 +1,23 @@
+import { app, shell } from 'electron'
+import fs from 'fs'
 import path from 'path'
 import type { IDevicePresenter } from '@shared/presenter'
 import type { SQLitePresenter } from '../sqlitePresenter'
-import type { Project } from '@shared/types/agent-interface'
+import type { EnvironmentSummary, Project } from '@shared/types/agent-interface'
 
 export class ProjectPresenter {
   private sqlitePresenter: SQLitePresenter
   private devicePresenter: IDevicePresenter
+  private readonly tempRoot: string
+  private readonly userDataWorkspacesRoot: string
+  private readonly appDataRoot: string
 
   constructor(sqlitePresenter: SQLitePresenter, devicePresenter: IDevicePresenter) {
     this.sqlitePresenter = sqlitePresenter
     this.devicePresenter = devicePresenter
+    this.tempRoot = path.resolve(app.getPath('temp'))
+    this.userDataWorkspacesRoot = path.resolve(path.join(app.getPath('userData'), 'workspaces'))
+    this.appDataRoot = path.resolve(app.getPath('appData'))
   }
 
   async getProjects(): Promise<Project[]> {
@@ -32,6 +40,39 @@ export class ProjectPresenter {
     }))
   }
 
+  async getEnvironments(): Promise<EnvironmentSummary[]> {
+    const rows = this.sqlitePresenter.newEnvironmentsTable.list()
+    return rows.map((row) => ({
+      path: row.path,
+      name: path.basename(row.path) || row.path,
+      sessionCount: row.session_count,
+      lastUsedAt: row.last_used_at,
+      isTemp: this.isTempPath(row.path),
+      exists: fs.existsSync(row.path)
+    }))
+  }
+
+  async pathExists(targetPath: string): Promise<boolean> {
+    const normalizedPath = targetPath?.trim()
+    if (!normalizedPath) {
+      return false
+    }
+
+    return fs.existsSync(normalizedPath)
+  }
+
+  async openDirectory(dirPath: string): Promise<void> {
+    const normalizedPath = dirPath?.trim()
+    if (!normalizedPath) {
+      return
+    }
+
+    const errorMessage = await shell.openPath(normalizedPath)
+    if (errorMessage) {
+      throw new Error(errorMessage)
+    }
+  }
+
   async selectDirectory(): Promise<string | null> {
     const result = await this.devicePresenter.selectDirectory()
     if (result.canceled || result.filePaths.length === 0) return null
@@ -42,4 +83,38 @@ export class ProjectPresenter {
     this.sqlitePresenter.newProjectsTable.upsert(dirPath, dirName)
     return dirPath
   }
+
+  private isTempPath(projectPath: string): boolean {
+    const normalized = projectPath?.trim()
+    if (!normalized) {
+      return false
+    }
+
+    const resolvedPath = path.resolve(normalized)
+    return (
+      this.isWithinRoot(resolvedPath, this.tempRoot) ||
+      this.isWithinRoot(resolvedPath, this.userDataWorkspacesRoot) ||
+      this.isAppManagedWorkspacePath(resolvedPath)
+    )
+  }
+
+  private isWithinRoot(targetPath: string, rootPath: string): boolean {
+    const relative = path.relative(rootPath, targetPath)
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative))
+  }
+
+  private isAppManagedWorkspacePath(targetPath: string): boolean {
+    const workspaceMarker = `${path.sep}workspaces`
+    const markerIndex = targetPath.indexOf(workspaceMarker)
+    if (markerIndex < 0) {
+      return false
+    }
+
+    const appContainerPath = targetPath.slice(0, markerIndex)
+    if (!appContainerPath) {
+      return false
+    }
+
+    return this.isWithinRoot(appContainerPath, this.appDataRoot)
+  }
 }