@jingyi0605/codingns 0.9.6 → 0.9.7

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

@@ -22,6 +22,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 +81,7 @@ export class SessionHistoryService {
     providerDiscoveryHelperClient = getSharedProviderDiscoveryHelperClient();
     providerSessionDiscoveryConfig;
     providerRuntimeStateService;
+    codexSessionTitleGenerator;
     sessionProviderConfigService;
     providerControlRepository;
     taskManager;
@@ -113,6 +115,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(),
@@ -228,6 +234,14 @@ export class SessionHistoryService {
                 }
             });
         }
+        if (!this.taskManager.has(HOST_TASK_TYPES.sessionCodexTitleGenerate)) {
+            this.taskManager.register({
+                taskType: HOST_TASK_TYPES.sessionCodexTitleGenerate,
+                executionLane: "external_process",
+                timeoutMs: 45_000,
+                run: async ({ sessionId }, context) => this.runCodexSessionTitleGeneration(sessionId, context.signal)
+            });
+        }
     }
     async discoverWorkspaceSessions(workspaceId, userId, options) {
         const maxAgeMs = options?.maxAgeMs ?? 0;
@@ -447,6 +461,7 @@ export class SessionHistoryService {
     async syncSessionTitle(sessionId, signal) {
         const binding = this.getBindingOrThrow(sessionId);
         await this.syncSessionTitleFromProvider(sessionId, binding, signal);
+        this.requestCodexTitleGenerationIfNeeded(sessionId, "session_history.sync_session_title");
     }
     async syncWorkspaceSessionTitles(workspaceId, userId, concurrency = 1, signal) {
         const sessions = this.sessionIndexRepository.listByWorkspace(workspaceId, userId);
@@ -1152,6 +1167,7 @@ export class SessionHistoryService {
             return null;
         }
         await this.syncSessionTitleFromProvider(sessionId, binding);
+        this.requestCodexTitleGenerationIfNeeded(sessionId, "session_history.read_recent_history");
         const snapshot = this.sessionStatusSnapshotRepository.findBySessionId(sessionId);
         this.upsertSnapshot(sessionId, {
             syncStatus: "idle",
@@ -1624,6 +1640,10 @@ export class SessionHistoryService {
                 cleanupDurationMs = Date.now() - cleanupStartedAt;
             }
             this.workspaceSessionRelations.set(workspaceId, relationMap);
+            this.observeDiscoveredProviderActivity(sessions, discoveredSessionIds, userId, timestamp);
+            for (const persisted of persistedSessions) {
+                this.requestCodexTitleGenerationIfNeeded(persisted.sessionId, "session_history.discover_workspace_sessions.codex_title");
+            }
             const listItemsStartedAt = Date.now();
             const items = this.sessionIndexRepository.listByWorkspace(workspaceId, userId);
             listItemsDurationMs = Date.now() - listItemsStartedAt;
@@ -1911,6 +1931,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);
@@ -2135,6 +2221,7 @@ export class SessionHistoryService {
             return;
         }
         await this.syncSessionTitleFromProvider(sessionId, binding);
+        this.requestCodexTitleGenerationIfNeeded(sessionId, "session_history.publish_history_envelope");
         const snapshot = this.sessionStatusSnapshotRepository.findBySessionId(sessionId);
         this.upsertSnapshot(sessionId, {
             syncStatus: "idle",
@@ -2187,6 +2274,83 @@ export class SessionHistoryService {
             updatedAt: nowIso()
         });
     }
+    requestCodexTitleGenerationIfNeeded(sessionId, source) {
+        if (!this.shouldRequestCodexTitleGeneration(sessionId)) {
+            return;
+        }
+        const handle = this.taskManager.enqueue(HOST_TASK_TYPES.sessionCodexTitleGenerate, {
+            key: sessionId,
+            source,
+            input: {
+                sessionId
+            }
+        });
+        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) {
+        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;
+        }
+        if (index.messageCount <= 0) {
+            return false;
+        }
+        return true;
+    }
+    async runCodexSessionTitleGeneration(sessionId, 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 };
+        }
+        const page = await this.sessionSyncService.readHistory(binding.provider, binding.providerSessionId, binding.rawStoreRef, null, 16, "forward").catch(() => null);
+        if (!page) {
+            return { title: null };
+        }
+        const firstUserMessage = page.messages.find((message) => message.role === "user")?.content ?? null;
+        if (!shouldGenerateCodexSessionTitle(index.title, firstUserMessage)) {
+            return { title: null };
+        }
+        const title = await this.codexSessionTitleGenerator.generate({
+            currentTitle: index.title,
+            messages: page.messages.map((message) => ({
+                role: message.role,
+                content: message.content
+            })),
+            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()
+            });
+        }
+        return { title };
+    }
     async readFirstUserMessageTitleForSync(binding) {
         const pageSize = 20;
         const maxPages = 3;
@@ -4195,6 +4359,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") {