@jingyi0605/codingns 0.3.5 → 0.3.6

package/dist/server/modules/sessions/session-history-service.js

@@ -14,13 +14,15 @@ import { SessionForkRepository } from "../../storage/repositories/session-fork-r
 import { enrichClaudeCapabilities } from "../provider/claude-model-options.js";
 import { CodexModelOptionsService, createFallbackCodexModelOptions, enrichCodexCapabilities } from "../provider/codex-model-options.js";
 import { OpenCodeModelOptionsService, createFallbackOpenCodeModelOptions, enrichOpenCodeCapabilities } from "../provider/opencode-model-options.js";
-import { ProviderDiscoveryHelperClient } from "../provider/provider-discovery-helper-client.js";
+import { getSharedProviderDiscoveryHelperClient } from "../provider/provider-discovery-helper-client.js";
+import { discoverWorkspaceSessionsInRuntime } from "../provider/provider-discovery-runtime.js";
 import { createTaskManager } from "../tasks/task-manager.js";
 import { HOST_TASK_TYPES } from "../tasks/task-types.js";
 import { CodexAppServerHelperClient } from "./codex-app-server-helper-client.js";
 const RECONSTRUCTED_FORK_TARGET_PROVIDERS = new Set(["codex", "claude-code", "opencode"]);
 const FORK_RECONSTRUCTION_PAGE_SIZE = 200;
 const MAX_FORK_DEPTH = 4;
+const SYNTHETIC_CODEX_SESSION_CLEANUP_GRACE_MS = 120_000;
 const SESSION_START_DEFERRED_PROVIDERS = new Set([
     "codex",
     "claude-code",
@@ -32,6 +34,7 @@ const MUTABLE_HISTORY_TAIL_REFRESH_INTERVAL_MS = 1_200;
 const WORKSPACE_DISCOVERY_BACKGROUND_MAX_AGE_MS = 15_000;
 const PROVIDER_CAPABILITY_CACHE_MAX_AGE_MS = 5_000;
 const WORKSPACE_DISCOVERY_PERSIST_BATCH_SIZE = 25;
+const SESSION_TRANSACTION_HOTSPOT_THRESHOLD_MS = 150;
 export class SessionHistoryService {
     db;
     workspaceRepository;
@@ -52,7 +55,7 @@ export class SessionHistoryService {
     openCodeModelOptionsService;
     providerCliCommandPaths;
     providerCliAvailability;
-    providerDiscoveryHelperClient = new ProviderDiscoveryHelperClient();
+    providerDiscoveryHelperClient = getSharedProviderDiscoveryHelperClient();
     providerSessionDiscoveryConfig;
     taskManager;
     workspaceDiscoveryStatuses = new Map();
@@ -148,8 +151,16 @@ export class SessionHistoryService {
         if (!this.taskManager.has(HOST_TASK_TYPES.workspaceDiscovery)) {
             this.taskManager.register({
                 taskType: HOST_TASK_TYPES.workspaceDiscovery,
+                executionLane: "host_background",
+                run: async ({ workspaceId, userId, refreshStateMode }, context) => this.runDiscoverWorkspaceSessions(workspaceId, userId, refreshStateMode, context.signal)
+            });
+        }
+        if (!this.taskManager.has(HOST_TASK_TYPES.workspaceDiscoveryScan)) {
+            this.taskManager.register({
+                taskType: HOST_TASK_TYPES.workspaceDiscoveryScan,
                 executionLane: "helper_process",
-                run: async ({ workspaceId, userId, refreshStateMode }) => this.runDiscoverWorkspaceSessions(workspaceId, userId, refreshStateMode)
+                helperProcessHandler: "session.workspace_discovery",
+                run: async ({ config, workspacePath, knownSessions }, context) => await discoverWorkspaceSessionsInRuntime(config, workspacePath, knownSessions, context.signal)
             });
         }
         if (!this.taskManager.has(HOST_TASK_TYPES.providerCapabilityRefresh)) {
@@ -233,7 +244,10 @@ export class SessionHistoryService {
     async readSessionHistory(sessionId, cursor, limit, direction = "forward", userId) {
         const startedAt = Date.now();
         const resolvedSessionId = this.resolveCanonicalSessionId(sessionId, userId);
-        const binding = this.getBindingOrThrow(resolvedSessionId);
+        let binding = this.getBindingOrThrow(resolvedSessionId);
+        if (userId) {
+            binding = await this.repairCodexDirtyBindingBeforeHistoryRead(resolvedSessionId, userId, binding);
+        }
         const current = this.sessionStatusSnapshotRepository.findBySessionId(resolvedSessionId);
         const safeLimit = clampLimit(limit);
         const knownTotalMessageCount = direction === "backward" && cursor === null
@@ -335,17 +349,17 @@ export class SessionHistoryService {
         await this.refreshSessionState(sessionId, userId);
         return this.enrichSessionItem(this.getSessionListItemOrThrow(sessionId, userId));
     }
-    async syncSessionTitle(sessionId) {
+    async syncSessionTitle(sessionId, signal) {
         const binding = this.getBindingOrThrow(sessionId);
-        await this.syncSessionTitleFromProvider(sessionId, binding);
+        await this.syncSessionTitleFromProvider(sessionId, binding, signal);
     }
-    async syncWorkspaceSessionTitles(workspaceId, userId, concurrency = 1) {
+    async syncWorkspaceSessionTitles(workspaceId, userId, concurrency = 1, signal) {
         const sessions = this.sessionIndexRepository.listByWorkspace(workspaceId, userId);
         await runWithConcurrency(sessions, concurrency, async (session) => {
-            await this.syncSessionTitle(session.sessionId).catch(() => {
+            await this.syncSessionTitle(session.sessionId, signal).catch(() => {
                 return;
             });
-        });
+        }, signal);
     }
     async listSessionChangedFiles(sessionId, userId) {
         this.getSession(sessionId, userId);
@@ -1137,7 +1151,7 @@ export class SessionHistoryService {
             }
         }
     }
-    async runDiscoverWorkspaceSessions(workspaceId, userId, refreshStateMode = "inline") {
+    async runDiscoverWorkspaceSessions(workspaceId, userId, refreshStateMode = "inline", signal) {
         const startedAt = Date.now();
         const debugStartedAtMs = terminalDebugNowMs();
         const workspace = this.getWorkspaceOrThrow(workspaceId);
@@ -1158,13 +1172,16 @@ export class SessionHistoryService {
             const discoverStartedAt = Date.now();
             const existingWorkspaceSessions = this.sessionIndexRepository.listByWorkspace(workspaceId, userId);
             const knownSessions = this.buildKnownSessionSummaries(existingWorkspaceSessions, workspace.path);
-            const discovery = await this.providerDiscoveryHelperClient
-                .discoverWorkspaceSessions({
-                config: this.providerSessionDiscoveryConfig,
-                workspacePath: workspace.path,
-                knownSessions
-            })
-                .catch((error) => {
+            const discoveryHandle = this.taskManager.enqueue(HOST_TASK_TYPES.workspaceDiscoveryScan, {
+                key: workspaceId,
+                source: "session_history.workspace_discovery.scan",
+                input: {
+                    config: this.providerSessionDiscoveryConfig,
+                    workspacePath: workspace.path,
+                    knownSessions
+                }
+            });
+            const discovery = await awaitTaskHandleWithSignal(discoveryHandle, signal).catch((error) => {
                 throw mapSessionProviderError(error);
             });
             const sessions = discovery.sessions;
@@ -1251,7 +1268,15 @@ export class SessionHistoryService {
                 }
             });
             const persistPass1StartedAt = Date.now();
-            const persistPass1Stats = await runBatchedTransactions(sessions, WORKSPACE_DISCOVERY_PERSIST_BATCH_SIZE, persistPass1Transaction);
+            const persistPass1Stats = await runBatchedTransactions(sessions, WORKSPACE_DISCOVERY_PERSIST_BATCH_SIZE, persistPass1Transaction, {
+                scope: "workspace.discover_sessions.persist_pass1.batch",
+                thresholdMs: SESSION_TRANSACTION_HOTSPOT_THRESHOLD_MS,
+                detail: {
+                    workspaceId,
+                    workspacePath: workspace.path,
+                    phase: "pass1"
+                }
+            });
             persistPass1DurationMs = Date.now() - persistPass1StartedAt;
             persistPass1BatchCount = persistPass1Stats.batchCount;
             persistPass1MaxBatchMs = persistPass1Stats.maxBatchMs;
@@ -1298,7 +1323,15 @@ export class SessionHistoryService {
                 }
             });
             const persistPass2StartedAt = Date.now();
-            const persistPass2Stats = await runBatchedTransactions(persistedSessions, WORKSPACE_DISCOVERY_PERSIST_BATCH_SIZE, persistPass2Transaction);
+            const persistPass2Stats = await runBatchedTransactions(persistedSessions, WORKSPACE_DISCOVERY_PERSIST_BATCH_SIZE, persistPass2Transaction, {
+                scope: "workspace.discover_sessions.persist_pass2.batch",
+                thresholdMs: SESSION_TRANSACTION_HOTSPOT_THRESHOLD_MS,
+                detail: {
+                    workspaceId,
+                    workspacePath: workspace.path,
+                    phase: "pass2"
+                }
+            });
             persistPass2DurationMs = Date.now() - persistPass2StartedAt;
             persistPass2BatchCount = persistPass2Stats.batchCount;
             persistPass2MaxBatchMs = persistPass2Stats.maxBatchMs;
@@ -1677,7 +1710,7 @@ export class SessionHistoryService {
             messages
         });
     }
-    async syncSessionTitleFromProvider(sessionId, binding) {
+    async syncSessionTitleFromProvider(sessionId, binding, signal) {
         const currentIndex = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId);
         if (!currentIndex) {
             return;
@@ -1690,7 +1723,7 @@ export class SessionHistoryService {
             provider: binding.provider,
             providerSessionId: binding.providerSessionId,
             rawStoreRef: binding.rawStoreRef
-        })).trim();
+        }, signal)).trim();
         const resolvedTitle = resolvePersistedSessionTitle(binding.provider, nextTitle, currentIndex.title);
         if (resolvedTitle.length === 0 || resolvedTitle === currentIndex.title) {
             return;
@@ -1925,6 +1958,7 @@ export class SessionHistoryService {
     async cleanupStaleHiddenSessions(workspaceId, userId, sessions) {
         const discoveredProviderSessionIds = new Set(sessions.map((session) => buildProviderSessionKey(session.provider, session.providerSessionId)));
         const discoveredRawStoreRefs = new Set(sessions.map((session) => session.rawStoreRef));
+        const nowMs = Date.now();
         const staleHiddenSessions = this.sessionIndexRepository
             .listByWorkspace(workspaceId, userId)
             .filter((session) => {
@@ -1936,10 +1970,13 @@ export class SessionHistoryService {
             }
             return ((session.provider === "codex" &&
                 (isLegacyCodingNsRolloutSession(session.providerSessionId, session.rawStoreRef) ||
-                    shouldRemoveMissingSyntheticCodexSession(session.rawStoreRef))) ||
+                    (shouldRemoveMissingSyntheticCodexSession(session.rawStoreRef) &&
+                        !this.shouldPreserveSyntheticCodexSession(session, nowMs)))) ||
                 (session.provider === "claude-code" && shouldRemoveHiddenClaudeDebugSession(session)));
         });
-        if (staleHiddenSessions.length === 0) {
+        const managedButlerSessionIds = this.listManagedButlerSessionIds(staleHiddenSessions.map((session) => session.sessionId));
+        const deletableSessions = staleHiddenSessions.filter((session) => !managedButlerSessionIds.has(session.sessionId));
+        if (deletableSessions.length === 0) {
             return;
         }
         const deleteTransaction = this.db.transaction((ids) => {
@@ -1947,7 +1984,53 @@ export class SessionHistoryService {
                 this.deleteSessionById(sessionId);
             }
         });
-        await runBatchedTransactions(staleHiddenSessions.map((session) => session.sessionId), WORKSPACE_DISCOVERY_PERSIST_BATCH_SIZE, deleteTransaction);
+        await runBatchedTransactions(deletableSessions.map((session) => session.sessionId), WORKSPACE_DISCOVERY_PERSIST_BATCH_SIZE, deleteTransaction, {
+            scope: "workspace.discover_sessions.cleanup_hidden.batch",
+            thresholdMs: SESSION_TRANSACTION_HOTSPOT_THRESHOLD_MS,
+            detail: {
+                workspaceId,
+                userId,
+                phase: "cleanup_hidden"
+            }
+        });
+    }
+    listManagedButlerSessionIds(sessionIds) {
+        if (sessionIds.length === 0) {
+            return new Set();
+        }
+        const managedSessionIds = new Set();
+        for (let index = 0; index < sessionIds.length; index += WORKSPACE_DISCOVERY_PERSIST_BATCH_SIZE) {
+            const batch = sessionIds.slice(index, index + WORKSPACE_DISCOVERY_PERSIST_BATCH_SIZE);
+            const placeholders = batch.map(() => "?").join(", ");
+            const rows = this.db
+                .prepare(`SELECT session_id
+           FROM butler_sessions
+           WHERE session_id IN (${placeholders})`)
+                .all(...batch);
+            for (const row of rows) {
+                managedSessionIds.add(row.session_id);
+            }
+        }
+        return managedSessionIds;
+    }
+    shouldPreserveSyntheticCodexSession(session, nowMs) {
+        if (session.activitySource === "runtime"
+            || session.runningState === "starting"
+            || session.runningState === "running") {
+            return true;
+        }
+        const hasActiveRuntimeState = this.listSessionStatesBySessionId(session.sessionId).some((state) => state.activitySource === "runtime"
+            || state.runningState === "starting"
+            || state.runningState === "running");
+        if (hasActiveRuntimeState) {
+            return true;
+        }
+        const latestTouchedAt = pickLaterIso(session.updatedAt, session.createdAt) ?? session.updatedAt;
+        const latestTouchedAtMs = Date.parse(latestTouchedAt);
+        if (!Number.isFinite(latestTouchedAtMs)) {
+            return false;
+        }
+        return nowMs - latestTouchedAtMs <= SYNTHETIC_CODEX_SESSION_CLEANUP_GRACE_MS;
     }
     findSameWorkspaceBindingDuplicate(sessionId, workspaceId, snapshot) {
         if (isPendingBindingValue(snapshot.providerSessionId)) {
@@ -2282,6 +2365,18 @@ export class SessionHistoryService {
         });
         return nextRecord;
     }
+    async repairCodexDirtyBindingBeforeHistoryRead(sessionId, userId, binding) {
+        if (!shouldRepairCodexDirtyBinding(binding)) {
+            return binding;
+        }
+        await this.discoverWorkspaceSessions(binding.workspaceId, userId, {
+            force: true,
+            refreshStateMode: "deferred"
+        }).catch(() => {
+            return [];
+        });
+        return this.getBindingOrThrow(sessionId);
+    }
     resolveLiveActivityObservation(sessionId) {
         for (const resolver of this.liveActivityObservationResolvers) {
             const observation = resolver(sessionId);
@@ -2945,6 +3040,48 @@ function isLegacyCodingNsRolloutSession(providerSessionId, rawStoreRef) {
 function shouldRemoveMissingSyntheticCodexSession(rawStoreRef) {
     return isSyntheticCodexRawStoreRef(rawStoreRef) && !existsSync(rawStoreRef);
 }
+function shouldRepairCodexDirtyBinding(binding) {
+    if (binding.provider !== "codex") {
+        return false;
+    }
+    if (isSyntheticCodexRawStoreRef(binding.rawStoreRef)) {
+        return false;
+    }
+    const expectedThreadId = binding.providerSessionId.trim();
+    if (!expectedThreadId) {
+        return false;
+    }
+    const boundThreadId = readCodexThreadIdFromRawStore(binding.rawStoreRef);
+    if (boundThreadId) {
+        return boundThreadId !== expectedThreadId;
+    }
+    return !existsSync(binding.rawStoreRef);
+}
+function readCodexThreadIdFromRawStore(filePath) {
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    try {
+        const firstLine = readFileSync(filePath, "utf8")
+            .split(/\r?\n/, 1)
+            .at(0)
+            ?.trim();
+        if (!firstLine) {
+            return null;
+        }
+        const record = JSON.parse(firstLine);
+        if (record.type !== "session_meta") {
+            return null;
+        }
+        const threadId = typeof record.payload?.id === "string"
+            ? record.payload.id.trim()
+            : "";
+        return threadId.length > 0 ? threadId : null;
+    }
+    catch {
+        return null;
+    }
+}
 function shouldMatchSessionBindingByRawStoreRef(provider) {
     return provider !== "codex";
 }
@@ -3134,13 +3271,14 @@ function buildReconstructedForkPrompt(input) {
 function buildProviderCapabilityCacheKey(provider, workspacePath) {
     return `${provider}::${workspacePath ?? ""}`;
 }
-async function runWithConcurrency(items, concurrency, worker) {
+async function runWithConcurrency(items, concurrency, worker, signal) {
     const normalizedConcurrency = Math.max(1, Math.floor(concurrency) || 1);
     const queue = [...items];
     const runners = Array.from({
         length: Math.min(normalizedConcurrency, queue.length || 1)
     }, async () => {
         while (queue.length > 0) {
+            throwIfAborted(signal);
             const current = queue.shift();
             if (current === undefined) {
                 return;
@@ -3150,7 +3288,44 @@ async function runWithConcurrency(items, concurrency, worker) {
     });
     await Promise.all(runners);
 }
-async function runBatchedTransactions(items, batchSize, transaction) {
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw signal.reason ?? new Error("任务已取消");
+    }
+}
+async function awaitTaskHandleWithSignal(handle, signal) {
+    if (!signal) {
+        return await handle.promise;
+    }
+    if (signal.aborted) {
+        handle.cancel(getAbortMessage(signal.reason));
+        throw signal.reason ?? new Error("任务已取消");
+    }
+    return await new Promise((resolve, reject) => {
+        const onAbort = () => {
+            handle.cancel(getAbortMessage(signal.reason));
+            reject(signal.reason ?? new Error("任务已取消"));
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        handle.promise.then((value) => {
+            signal.removeEventListener("abort", onAbort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", onAbort);
+            reject(error);
+        });
+    });
+}
+function getAbortMessage(reason) {
+    if (reason instanceof Error && reason.message.trim().length > 0) {
+        return reason.message;
+    }
+    if (typeof reason === "string" && reason.trim().length > 0) {
+        return reason;
+    }
+    return "任务已取消";
+}
+async function runBatchedTransactions(items, batchSize, transaction, logOptions) {
     const normalizedBatchSize = Math.max(1, Math.floor(batchSize) || 1);
     let batchCount = 0;
     let maxBatchMs = 0;
@@ -3159,6 +3334,19 @@ async function runBatchedTransactions(items, batchSize, transaction) {
         const batchStartedAt = Date.now();
         transaction(batch);
         const batchDurationMs = Date.now() - batchStartedAt;
+        const nextBatchIndex = batchCount + 1;
+        if (logOptions) {
+            logPerformance(logOptions.scope, batchDurationMs, {
+                ...logOptions.detail,
+                batchIndex: nextBatchIndex,
+                batchSize: batch.length,
+                batchStartIndex: index,
+                totalItems: items.length,
+                configuredBatchSize: normalizedBatchSize
+            }, {
+                thresholdMs: logOptions.thresholdMs ?? SESSION_TRANSACTION_HOTSPOT_THRESHOLD_MS
+            });
+        }
         batchCount += 1;
         maxBatchMs = Math.max(maxBatchMs, batchDurationMs);
         if (index + normalizedBatchSize < items.length) {