@jingyi0605/codingns 0.9.6 → 0.9.8

package/dist/server/modules/sessions/session-history-service.d.ts

@@ -75,6 +75,12 @@ interface SessionHistoryAdapterOverrides {
     providerSessionDeleteCli?: ProviderSessionDeleteCli;
 }
 type LiveActivityObservationResolver = (sessionId: string) => SessionActivityObservation | null;
+type SessionTitleChangedObserver = (input: {
+    sessionId: string;
+    userId: string;
+    workspaceId: string;
+    title: string;
+}) => Promise<void> | void;
 type SessionDeletedObserver = (input: {
     sessionId: string;
     userId: string;
@@ -106,6 +112,7 @@ export declare class SessionHistoryService {
     private readonly providerDiscoveryHelperClient;
     private readonly providerSessionDiscoveryConfig;
     private readonly providerRuntimeStateService;
+    private readonly codexSessionTitleGenerator;
     private readonly sessionProviderConfigService;
     private readonly providerControlRepository;
     private readonly taskManager;
@@ -115,6 +122,7 @@ export declare class SessionHistoryService {
     private readonly codexDirtyBindingRepairStates;
     private readonly streamingDeltaSuppressionDebugState;
     private readonly liveActivityObservationResolvers;
+    private readonly sessionTitleChangedObservers;
     private readonly sessionDeletedObservers;
     private readonly workspaceSessionRelations;
     private workspaceStateRefreshTaskSequence;
@@ -126,6 +134,9 @@ export declare class SessionHistoryService {
     registerSessionDeletedObserver(observer: SessionDeletedObserver): {
         close(): void;
     };
+    registerSessionTitleChangedObserver(observer: SessionTitleChangedObserver): {
+        close(): void;
+    };
     private registerBackgroundTasks;
     discoverWorkspaceSessions(workspaceId: string, userId: string, options?: {
         maxAgeMs?: number;
@@ -207,6 +218,7 @@ export declare class SessionHistoryService {
     private sanitizeForkHistoryPage;
     private resolveMessageOrigins;
     private buildWorkspaceSessionRelationMap;
+    private observeDiscoveredProviderActivity;
     private enrichSessionItems;
     private enrichSessionItem;
     private buildParallelProjectionBySessionId;
@@ -216,6 +228,10 @@ export declare class SessionHistoryService {
     private shouldSuppressStreamingSessionDelta;
     private publishHistoryEnvelope;
     private syncSessionTitleFromProvider;
+    requestCodexTitleGenerationForNewSession(sessionId: string, firstUserMessage: string): void;
+    private shouldRequestCodexTitleGeneration;
+    private runCodexSessionTitleGeneration;
+    private notifySessionTitleChanged;
     private readFirstUserMessageTitleForSync;
     private resolvePersistedParentSessionId;
     private ensureSessionChangedFilesIndexed;

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

@@ -9,6 +9,7 @@ import { isTerminalDebugEnabled, logTerminalDebug, terminalDebugNowMs } from "..
 import { nowIso } from "../../shared/utils/time.js";
 import { inspectSessionActivity } from "./session-activity-inspector.js";
 import { SessionActivityAuthorityService } from "./session-activity-authority-service.js";
+import { buildSessionTitleFromContent, normalizeRuntimePromptTitle } from "./session-title-utils.js";
 import { mapSessionProviderError } from "./session-provider-error-mapper.js";
 import { SessionForkRepository } from "../../storage/repositories/session-fork-repository.js";
 import { buildParallelGroupColorToken, resolveParallelDisplayParentSessionId } from "../parallel-sessions/parallel-session-group-service.js";
@@ -22,6 +23,7 @@ import { ProviderRuntimeStateService } from "../provider/provider-runtime-state-
 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";
+import { CodexSessionTitleGenerator } from "./codex-session-title-generator.js";
 import { CodingnsProviderSessionDeleteCli } from "./provider-session-delete-cli.js";
 const RECONSTRUCTED_FORK_TARGET_PROVIDERS = new Set(["codex", "claude-code", "opencode"]);
 const FORK_RECONSTRUCTION_PAGE_SIZE = 200;
@@ -80,6 +82,7 @@ export class SessionHistoryService {
     providerDiscoveryHelperClient = getSharedProviderDiscoveryHelperClient();
     providerSessionDiscoveryConfig;
     providerRuntimeStateService;
+    codexSessionTitleGenerator;
     sessionProviderConfigService;
     providerControlRepository;
     taskManager;
@@ -89,6 +92,7 @@ export class SessionHistoryService {
     codexDirtyBindingRepairStates = new Map();
     streamingDeltaSuppressionDebugState = new Map();
     liveActivityObservationResolvers = new Set();
+    sessionTitleChangedObservers = new Set();
     sessionDeletedObservers = new Set();
     workspaceSessionRelations = new Map();
     workspaceStateRefreshTaskSequence = 0;
@@ -113,6 +117,10 @@ export class SessionHistoryService {
         this.sessionProviderConfigService = sessionProviderConfigService;
         this.providerRuntimeStateService = providerRuntimeStateService
             ?? new ProviderRuntimeStateService(config);
+        this.codexSessionTitleGenerator = new CodexSessionTitleGenerator({
+            hostDataRootDir: dirname(config.databasePath),
+            codexHomeDir: config.codexHomeDir
+        });
         this.providerControlRepository = providerControlRepository ?? {
             get: (providerId) => ({
                 providerId: providerId.trim(),
@@ -198,6 +206,14 @@ export class SessionHistoryService {
             }
         };
     }
+    registerSessionTitleChangedObserver(observer) {
+        this.sessionTitleChangedObservers.add(observer);
+        return {
+            close: () => {
+                this.sessionTitleChangedObservers.delete(observer);
+            }
+        };
+    }
     registerBackgroundTasks() {
         if (!this.taskManager.has(HOST_TASK_TYPES.workspaceDiscovery)) {
             this.taskManager.register({
@@ -228,6 +244,15 @@ export class SessionHistoryService {
                 }
             });
         }
+        if (!this.taskManager.has(HOST_TASK_TYPES.sessionCodexTitleGenerate)) {
+            this.taskManager.register({
+                taskType: HOST_TASK_TYPES.sessionCodexTitleGenerate,
+                executionLane: "external_process",
+                concurrency: 1,
+                timeoutMs: 45_000,
+                run: async ({ sessionId, firstUserMessage }, context) => this.runCodexSessionTitleGeneration(sessionId, firstUserMessage, context.signal)
+            });
+        }
     }
     async discoverWorkspaceSessions(workspaceId, userId, options) {
         const maxAgeMs = options?.maxAgeMs ?? 0;
@@ -1624,6 +1649,7 @@ export class SessionHistoryService {
                 cleanupDurationMs = Date.now() - cleanupStartedAt;
             }
             this.workspaceSessionRelations.set(workspaceId, relationMap);
+            this.observeDiscoveredProviderActivity(sessions, discoveredSessionIds, userId, timestamp);
             const listItemsStartedAt = Date.now();
             const items = this.sessionIndexRepository.listByWorkspace(workspaceId, userId);
             listItemsDurationMs = Date.now() - listItemsStartedAt;
@@ -1911,6 +1937,72 @@ export class SessionHistoryService {
         }
         return relationMap;
     }
+    observeDiscoveredProviderActivity(sessions, discoveredSessionIds, userId, timestamp) {
+        for (const session of sessions) {
+            const providerObservation = session.activityObservation ?? null;
+            if (!providerObservation) {
+                continue;
+            }
+            const sessionId = discoveredSessionIds.get(buildProviderSessionKey(session.provider, session.providerSessionId));
+            if (!sessionId) {
+                continue;
+            }
+            const observedAt = providerObservation.observedAt ?? timestamp;
+            const resolution = this.sessionActivityAuthorityService.observe({
+                sessionId,
+                runId: providerObservation.runId ?? null,
+                runningState: providerObservation.runningState,
+                source: "authoritative_provider_event",
+                confidence: providerObservation.confidence,
+                detail: providerObservation.detail ?? null,
+                interruptSource: providerObservation.runningState === "interrupted" ? "runtime" : null,
+                errorCode: providerObservation.errorCode ?? null,
+                observedAt
+            });
+            const current = this.sessionStateRepository.findBySessionAndUser(sessionId, userId);
+            this.sessionStateRepository.upsert({
+                sessionId,
+                userId,
+                runningState: mapResolvedRunningStateToStored(resolution.runningState, current),
+                activitySource: "runtime",
+                favorite: current?.favorite ?? false,
+                lastEventAt: resolution.lastObservedAt ?? current?.lastEventAt ?? null,
+                completedAt: isTerminalResolvedRunningState(resolution.runningState)
+                    ? resolution.terminalAt ?? current?.completedAt ?? observedAt
+                    : null,
+                lastSeenAt: current?.lastSeenAt ?? null,
+                updatedAt: timestamp
+            });
+            const currentSnapshot = this.sessionStatusSnapshotRepository.findBySessionId(sessionId);
+            const shouldClearFailure = currentSnapshot?.syncStatus === "error"
+                && providerObservation.runningState !== "failed";
+            this.sessionStatusSnapshotRepository.upsert({
+                sessionId,
+                syncStatus: providerObservation.runningState === "failed"
+                    ? "error"
+                    : shouldClearFailure
+                        ? "idle"
+                        : currentSnapshot?.syncStatus ?? "idle",
+                syncCursor: currentSnapshot?.syncCursor ?? null,
+                lastSyncAt: resolution.lastObservedAt
+                    ?? resolution.terminalAt
+                    ?? currentSnapshot?.lastSyncAt
+                    ?? null,
+                lastErrorCode: providerObservation.runningState === "failed"
+                    ? providerObservation.errorCode ?? "CODEX_PROVIDER_EVENT_FAILED"
+                    : shouldClearFailure
+                        ? null
+                        : currentSnapshot?.lastErrorCode ?? null,
+                lastErrorDetail: providerObservation.runningState === "failed"
+                    ? providerObservation.detail ?? "Provider reported session failure"
+                    : shouldClearFailure
+                        ? null
+                        : currentSnapshot?.lastErrorDetail ?? null,
+                resumedAt: currentSnapshot?.resumedAt ?? null,
+                updatedAt: timestamp
+            });
+        }
+    }
     enrichSessionItems(workspaceId, items) {
         const relationMap = this.workspaceSessionRelations.get(workspaceId);
         const projectionBySessionId = this.buildParallelProjectionBySessionId(items);
@@ -2187,6 +2279,102 @@ export class SessionHistoryService {
             updatedAt: nowIso()
         });
     }
+    requestCodexTitleGenerationForNewSession(sessionId, firstUserMessage) {
+        const normalizedFirstUserMessage = firstUserMessage.trim();
+        if (!normalizedFirstUserMessage) {
+            return;
+        }
+        if (!this.shouldRequestCodexTitleGeneration(sessionId, normalizedFirstUserMessage)) {
+            return;
+        }
+        const handle = this.taskManager.enqueue(HOST_TASK_TYPES.sessionCodexTitleGenerate, {
+            key: sessionId,
+            source: "session_history.new_codex_session_title",
+            input: {
+                sessionId,
+                firstUserMessage: normalizedFirstUserMessage
+            }
+        });
+        if (handle.deduped) {
+            return;
+        }
+        void handle.promise.catch((error) => {
+            logPerformance("session.codex_title_generate.background_failed", 0, {
+                sessionId,
+                error: error instanceof Error ? error.message : "unknown"
+            }, {
+                thresholdMs: 0,
+                force: true
+            });
+        });
+    }
+    shouldRequestCodexTitleGeneration(sessionId, firstUserMessage) {
+        const binding = this.sessionBindingRepository.findBySessionId(sessionId);
+        const index = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId);
+        if (!binding || !index || binding.provider !== "codex") {
+            return false;
+        }
+        if (isPendingBindingValue(binding.providerSessionId) || isPendingBindingValue(binding.rawStoreRef)) {
+            return false;
+        }
+        return shouldGenerateCodexSessionTitle(index.title, firstUserMessage);
+    }
+    async runCodexSessionTitleGeneration(sessionId, firstUserMessage, signal) {
+        const binding = this.sessionBindingRepository.findBySessionId(sessionId);
+        const index = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId);
+        if (!binding || !index || binding.provider !== "codex") {
+            return { title: null };
+        }
+        if (isPendingBindingValue(binding.providerSessionId) || isPendingBindingValue(binding.rawStoreRef)) {
+            return { title: null };
+        }
+        if (!shouldGenerateCodexSessionTitle(index.title, firstUserMessage)) {
+            return { title: null };
+        }
+        const title = await this.codexSessionTitleGenerator.generate({
+            currentTitle: index.title,
+            messages: [
+                {
+                    role: "user",
+                    content: firstUserMessage
+                }
+            ],
+            signal
+        });
+        if (!title || !shouldApplyGeneratedCodexSessionTitle(title, firstUserMessage)) {
+            return { title: null };
+        }
+        await this.sessionSyncService.renameSessionTitle(binding.provider, binding.providerSessionId, binding.rawStoreRef, title);
+        const latestIndex = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId);
+        if (latestIndex && shouldGenerateCodexSessionTitle(latestIndex.title, firstUserMessage)) {
+            this.sessionIndexRepository.upsert({
+                ...latestIndex,
+                title,
+                updatedAt: nowIso()
+            });
+            await this.notifySessionTitleChanged({
+                sessionId,
+                userId: binding.userId,
+                workspaceId: binding.workspaceId,
+                title
+            });
+        }
+        return { title };
+    }
+    async notifySessionTitleChanged(input) {
+        const userId = input.userId ?? this.workspaceRepository.findById(input.workspaceId)?.ownerUserId;
+        if (!userId) {
+            return;
+        }
+        await Promise.allSettled(Array.from(this.sessionTitleChangedObservers).map(async (observer) => {
+            await observer({
+                sessionId: input.sessionId,
+                userId,
+                workspaceId: input.workspaceId,
+                title: input.title
+            });
+        }));
+    }
     async readFirstUserMessageTitleForSync(binding) {
         const pageSize = 20;
         const maxPages = 3;
@@ -4101,7 +4289,7 @@ function shouldMatchSessionBindingByRawStoreRef(provider) {
 function resolveSessionListTitle(provider, existingTitle, fallbackContent, parentTitle = null) {
     const normalizedExistingTitle = existingTitle?.trim() ?? "";
     const normalizedParentTitle = parentTitle?.trim() ?? "";
-    const fallbackTitle = buildUserMessageTitle(fallbackContent, normalizedExistingTitle || "继续对话");
+    const fallbackTitle = buildSessionTitleFromContent(fallbackContent, normalizedExistingTitle || "继续对话");
     if (normalizedExistingTitle.length > 0 &&
         !isSyntheticCodexSessionTitle(normalizedExistingTitle) &&
         (normalizedParentTitle.length === 0 ||
@@ -4116,17 +4304,6 @@ function resolveSessionListTitle(provider, existingTitle, fallbackContent, paren
     }
     return normalizedExistingTitle || fallbackTitle;
 }
-function buildUserMessageTitle(content, fallbackTitle) {
-    const title = content.trim().replace(/\s+/g, " ");
-    return title.slice(0, 48) || fallbackTitle;
-}
-function normalizeRuntimePromptTitle(content) {
-    const normalized = (typeof content === "string" ? content : "").trim().replace(/\s+/g, " ");
-    if (normalized.length === 0) {
-        return null;
-    }
-    return normalized.slice(0, 48);
-}
 function buildRecoveredSessionTitle(provider, providerSessionId) {
     if (isPendingBindingValue(providerSessionId)) {
         return "新会话";
@@ -4195,6 +4372,25 @@ function shouldSyncSessionTitleFromProvider(provider, currentTitle, firstUserMes
     }
     return false;
 }
+function shouldGenerateCodexSessionTitle(currentTitle, firstUserMessage) {
+    const normalizedTitle = currentTitle?.trim() ?? "";
+    if (!normalizedTitle) {
+        return true;
+    }
+    if (looksLikeGeneratedSessionTitle(normalizedTitle) || isSyntheticCodexSessionTitle(normalizedTitle)) {
+        return true;
+    }
+    const firstUserTitle = normalizeRuntimePromptTitle(firstUserMessage);
+    return Boolean(firstUserTitle && normalizedTitle === firstUserTitle);
+}
+function shouldApplyGeneratedCodexSessionTitle(generatedTitle, firstUserMessage) {
+    const normalizedTitle = generatedTitle.trim();
+    const firstUserTitle = normalizeRuntimePromptTitle(firstUserMessage);
+    if (!normalizedTitle) {
+        return false;
+    }
+    return !firstUserTitle || normalizedTitle !== firstUserTitle;
+}
 function looksLikeSyntheticTitleSourceMessage(provider, content) {
     const normalizedProvider = provider.trim().toLowerCase();
     if (normalizedProvider === "codex") {