@jingyi0605/codingns 0.9.6 → 0.9.8

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

@@ -208,6 +208,7 @@ export declare class SessionLiveRuntimeService {
     private readonly queueDispatchSessions;
     private readonly queueRetryTimers;
     private readonly pendingSendDebugTracesBySessionId;
+    private readonly runtimePersistenceQueues;
     constructor(sessionHistoryService: SessionHistoryService, sessionMessageAttachmentService: SessionMessageAttachmentService, workspaceService: WorkspaceService, sessionChangedFileService: SessionChangedFileService, sessionBindingRepository: SessionBindingRepository, authUserRepository: AuthUserRepository, sessionSendQueueRepository: SessionSendQueueRepository, sessionIndexRepository: SessionIndexRepository, sessionStateRepository: SessionStateRepository, sessionStatusSnapshotRepository: SessionStatusSnapshotRepository, sessionProviderConfigService: SessionProviderConfigService, config: HostConfig, sessionActivityAuthorityService?: SessionActivityAuthorityService, openCliSessionPromptService?: OpenCliSessionPromptService | null, workspaceSessionRuntimeContextService?: Pick<WorkspaceSessionRuntimeContextService, "prepareWorkspaceInstructionBundle"> | null);
     startLiveSession(input: StartLiveSessionInput): Promise<LiveMessageAcceptedResult>;
     sendLiveMessage(input: SendLiveMessageInput): Promise<LiveMessageAcceptedResult>;
@@ -253,6 +254,7 @@ export declare class SessionLiveRuntimeService {
     private resolveQueueDispatchSession;
     private launchRuntimeRun;
     private attachRuntimePersistence;
+    private enqueueRuntimeEventPersistence;
     private createRuntimeBackedSession;
     private prepareWorkspaceRuntimeContext;
     private resolveEffectiveRuntimeHomeDir;
@@ -268,6 +270,9 @@ export declare class SessionLiveRuntimeService {
     private resolveCodexRuntimeRequestRawStoreRef;
     private buildBindingSnapshot;
     private persistRuntimeEvent;
+    private runRuntimeSqliteRead;
+    private runRuntimeSqliteWrite;
+    private runRuntimeSqliteOperation;
     private emitTerminalStateEvent;
     private reconcileTerminalRuntimeSnapshot;
     private forceInterruptInactiveSession;
@@ -282,6 +287,7 @@ export declare class SessionLiveRuntimeService {
     private findAcceptedUserMessage;
     private resolveNextUserSequence;
     private waitForResolvedStartBinding;
+    private requestCodexTitleGenerationAfterStartBinding;
     private persistMessageAttachments;
     private refreshSyntheticSessionTitle;
     private mapRuntimeEventToEnvelope;

package/dist/server/modules/sessions/session-live-runtime-service.js

@@ -9,12 +9,14 @@ import { logPermissionDebug } from "../../shared/utils/permission-debug-log.js";
 import { nowIso } from "../../shared/utils/time.js";
 import { SessionActivityAuthorityService } from "./session-activity-authority-service.js";
 import { createProviderCapabilityBlockedError } from "../provider/provider-disabled.js";
+import { buildSessionTitleFromContent } from "./session-title-utils.js";
 import { SessionPermissionRequestService } from "./session-permission-request-service.js";
 import { appendSessionProviderErrorContext, mapSessionProviderError } from "./session-provider-error-mapper.js";
 import { buildClaudeCompatibleHookBridgeUrl, buildClaudeCompatibleRawStoreRef, buildClaudeCompatibleSessionTitle, findClaudeCompatibleSessionFile, isClaudeCompatibleProvider } from "./claude-compatible-provider-registry.js";
 import { ClaudeRuntimeHelperAdapter } from "./claude-runtime-helper-client.js";
 import { CodexAppServerHelperClient } from "./codex-app-server-helper-client.js";
 const OPENCODE_ORDER_DEBUG_ENABLED = /^(1|true|yes)$/i.test(process.env.CODINGNS_OPENCODE_ORDER_DEBUG?.trim() ?? "");
+const RUNTIME_EVENT_SQLITE_BUSY_RETRY_DELAYS_MS = [100, 250, 500, 1_000, 1_500, 2_000];
 const RUNTIME_START_BINDING_WAIT_TIMEOUT_MS = 10_000;
 const START_BINDING_POLL_INTERVAL_MS = 50;
 const EXTERNAL_RUNTIME_INTERRUPT_SUPPRESSION_MS = 30_000;
@@ -48,6 +50,7 @@ export class SessionLiveRuntimeService {
     queueDispatchSessions = new Set();
     queueRetryTimers = new Map();
     pendingSendDebugTracesBySessionId = new Map();
+    runtimePersistenceQueues = new Map();
     constructor(sessionHistoryService, sessionMessageAttachmentService, workspaceService, sessionChangedFileService, sessionBindingRepository, authUserRepository, sessionSendQueueRepository, sessionIndexRepository, sessionStateRepository, sessionStatusSnapshotRepository, sessionProviderConfigService, config, sessionActivityAuthorityService = new SessionActivityAuthorityService(), openCliSessionPromptService = null, workspaceSessionRuntimeContextService = null) {
         this.sessionHistoryService = sessionHistoryService;
         this.sessionMessageAttachmentService = sessionMessageAttachmentService;
@@ -178,13 +181,20 @@ export class SessionLiveRuntimeService {
             // 先把基础记录建出来，再回放 runtime 缓存事件，避免超快启动时出现
             // “事件先到、索引还没落库”的竞态窗口。
             this.attachRuntimePersistence(handle, sessionId, workspace.id, input.userId);
-            const startBindingTask = this.waitForResolvedStartBinding(sessionId, workspace.id, input.provider, handle).catch(() => {
+            const startBindingTask = this.waitForResolvedStartBinding(sessionId, workspace.id, input.provider, handle);
+            if (input.provider === "codex") {
+                void this.requestCodexTitleGenerationAfterStartBinding(sessionId, input.content, startBindingTask)
+                    .catch(() => {
+                    return;
+                });
+            }
+            const safeStartBindingTask = startBindingTask.catch(() => {
                 return;
             });
             if (shouldAwaitStartBindingBeforeAcceptedUserLookup(input.provider)) {
                 const bindingWaitStartedAtMs = performance.now();
                 await Promise.race([
-                    startBindingTask,
+                    safeStartBindingTask,
                     waitForAcceptedUserLookupWindow()
                 ]);
                 this.logSendDebugStep(debugTrace, "binding_wait", bindingWaitStartedAtMs, {
@@ -201,7 +211,7 @@ export class SessionLiveRuntimeService {
                 matched: Boolean(acceptedMessage)
             });
             if (!shouldAwaitStartBindingBeforeAcceptedUserLookup(input.provider)) {
-                void startBindingTask;
+                void safeStartBindingTask;
             }
             const acceptedAt = acceptedMessage?.timestamp ?? requestStartedAt;
             const boundAttachments = this.sessionMessageAttachmentService.bindClientRequestToMessage(sessionId, input.clientRequestId, acceptedMessage?.messageId ?? null);
@@ -1466,9 +1476,24 @@ export class SessionLiveRuntimeService {
     }
     attachRuntimePersistence(handle, sessionId, workspaceId, userId) {
         handle.attach(async (event) => {
-            await this.persistRuntimeEvent(sessionId, workspaceId, userId, event);
+            await this.enqueueRuntimeEventPersistence(sessionId, workspaceId, userId, event);
         });
     }
+    enqueueRuntimeEventPersistence(sessionId, workspaceId, userId, event) {
+        const previous = this.runtimePersistenceQueues.get(sessionId) ?? Promise.resolve();
+        const task = previous
+            .catch(() => {
+            return;
+        })
+            .then(() => this.persistRuntimeEvent(sessionId, workspaceId, userId, event));
+        const queuedTask = task.finally(() => {
+            if (this.runtimePersistenceQueues.get(sessionId) === queuedTask) {
+                this.runtimePersistenceQueues.delete(sessionId);
+            }
+        });
+        this.runtimePersistenceQueues.set(sessionId, queuedTask);
+        return task;
+    }
     createRuntimeBackedSession(input) {
         this.upsertRuntimeBackedSessionRecords(input);
     }
@@ -1547,7 +1572,7 @@ export class SessionLiveRuntimeService {
             sessionVisibility: currentIndex?.sessionVisibility ?? input.sessionVisibility,
             isSubagent: currentIndex?.isSubagent ?? false,
             subagentLabel: currentIndex?.subagentLabel ?? null,
-            title: currentIndex?.title?.trim() || buildSessionTitle(input.initialContent),
+            title: currentIndex?.title?.trim() || buildSessionTitleFromContent(input.initialContent, "继续对话"),
             messageCount: currentIndex?.messageCount ?? 0,
             isArchived: currentIndex?.isArchived ?? false,
             lastMessageAt: currentIndex?.lastMessageAt ?? input.snapshot.lastEventAt,
@@ -1692,103 +1717,121 @@ export class SessionLiveRuntimeService {
     }
     async persistRuntimeEvent(sessionId, workspaceId, userId, event) {
         this.observePendingSendDebugTraceEvent(sessionId, event);
-        this.sessionHistoryService.persistSessionBinding(sessionId, workspaceId, {
-            provider: event.provider,
-            providerSessionId: event.providerSessionId,
-            rawStoreRef: event.rawStoreRef,
-            userId
+        await this.runRuntimeSqliteWrite(sessionId, "persistSessionBinding", () => {
+            this.sessionHistoryService.persistSessionBinding(sessionId, workspaceId, {
+                provider: event.provider,
+                providerSessionId: event.providerSessionId,
+                rawStoreRef: event.rawStoreRef,
+                userId
+            });
         });
-        const currentState = this.sessionStateRepository.findBySessionAndUser(sessionId, userId);
+        const currentState = await this.runRuntimeSqliteRead(sessionId, "findSessionState", () => this.sessionStateRepository.findBySessionAndUser(sessionId, userId));
         const currentRunningState = currentState?.runningState ?? null;
-        const shouldPreserveTerminalState = isTerminalSessionRunningState(currentRunningState);
+        const shouldPreserveTerminalStatusEvent = isTerminalSessionRunningState(currentRunningState);
         if (event.type === "message") {
             this.runtimeMessageSeenSessions.add(sessionId);
             this.runtimeHistoryFallbackSentSessions.delete(sessionId);
             const workspace = this.workspaceService.getWorkspaceOrThrow(workspaceId);
-            await this.sessionHistoryService.syncSessionTitle(sessionId).catch(() => {
-                return;
-            });
-            const existing = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId);
+            const existing = await this.runRuntimeSqliteRead(sessionId, "findSessionIndex", () => this.sessionIndexRepository.findIndexRecordBySessionId(sessionId));
             if (existing) {
-                this.sessionIndexRepository.upsert({
-                    ...existing,
-                    messageCount: existing.messageCount + 1,
-                    lastMessageAt: event.message.timestamp,
-                    updatedAt: event.message.timestamp
+                await this.runRuntimeSqliteWrite(sessionId, "upsertSessionIndex", () => {
+                    this.sessionIndexRepository.upsert({
+                        ...existing,
+                        messageCount: existing.messageCount + 1,
+                        lastMessageAt: event.message.timestamp,
+                        updatedAt: event.message.timestamp
+                    });
                 });
             }
-            this.sessionChangedFileService.recordMessages(sessionId, workspaceId, workspace.path, [event.message]);
-            this.sessionStateRepository.upsert({
-                sessionId,
-                userId,
-                runningState: shouldPreserveTerminalState ? currentRunningState : "running",
-                activitySource: "runtime",
-                favorite: currentState?.favorite ?? false,
-                lastEventAt: event.message.timestamp,
-                completedAt: shouldPreserveTerminalState ? currentState?.completedAt ?? null : null,
-                lastSeenAt: currentState?.lastSeenAt ?? null,
-                updatedAt: nowIso()
+            await this.runRuntimeSqliteWrite(sessionId, "recordChangedFiles", () => {
+                this.sessionChangedFileService.recordMessages(sessionId, workspaceId, workspace.path, [event.message]);
             });
-            this.upsertSnapshot(sessionId, {
-                syncStatus: "idle",
-                syncCursor: this.sessionStatusSnapshotRepository.findBySessionId(sessionId)?.syncCursor ?? null,
-                lastSyncAt: event.message.timestamp,
-                lastErrorCode: null,
-                lastErrorDetail: null,
-                resumedAt: this.sessionStatusSnapshotRepository.findBySessionId(sessionId)?.resumedAt ?? null
+            await this.runRuntimeSqliteWrite(sessionId, "upsertSessionState", () => {
+                this.sessionStateRepository.upsert({
+                    sessionId,
+                    userId,
+                    runningState: "running",
+                    activitySource: "runtime",
+                    favorite: currentState?.favorite ?? false,
+                    lastEventAt: event.message.timestamp,
+                    completedAt: null,
+                    lastSeenAt: currentState?.lastSeenAt ?? null,
+                    updatedAt: nowIso()
+                });
+            });
+            const currentSnapshot = await this.runRuntimeSqliteRead(sessionId, "findStatusSnapshot", () => this.sessionStatusSnapshotRepository.findBySessionId(sessionId));
+            await this.runRuntimeSqliteWrite(sessionId, "upsertStatusSnapshot", () => {
+                this.upsertSnapshot(sessionId, {
+                    syncStatus: "idle",
+                    syncCursor: currentSnapshot?.syncCursor ?? null,
+                    lastSyncAt: event.message.timestamp,
+                    lastErrorCode: null,
+                    lastErrorDetail: null,
+                    resumedAt: currentSnapshot?.resumedAt ?? null
+                });
             });
             return;
         }
-        if (shouldPreserveTerminalState) {
-            this.sessionStateRepository.upsert({
-                sessionId,
-                userId,
-                runningState: currentRunningState,
-                activitySource: "runtime",
-                favorite: currentState?.favorite ?? false,
-                lastEventAt: event.timestamp,
-                completedAt: currentState?.completedAt ?? null,
-                lastSeenAt: currentState?.lastSeenAt ?? null,
-                updatedAt: nowIso()
+        if (shouldPreserveTerminalStatusEvent) {
+            await this.runRuntimeSqliteWrite(sessionId, "upsertTerminalPreservedState", () => {
+                this.sessionStateRepository.upsert({
+                    sessionId,
+                    userId,
+                    runningState: currentRunningState,
+                    activitySource: "runtime",
+                    favorite: currentState?.favorite ?? false,
+                    lastEventAt: event.timestamp,
+                    completedAt: currentState?.completedAt ?? null,
+                    lastSeenAt: currentState?.lastSeenAt ?? null,
+                    updatedAt: nowIso()
+                });
             });
-            this.upsertSnapshot(sessionId, {
-                syncStatus: "idle",
-                syncCursor: this.sessionStatusSnapshotRepository.findBySessionId(sessionId)?.syncCursor ?? null,
-                lastSyncAt: event.timestamp,
-                lastErrorCode: null,
-                lastErrorDetail: null,
-                resumedAt: this.sessionStatusSnapshotRepository.findBySessionId(sessionId)?.resumedAt ?? null
+            const currentSnapshot = await this.runRuntimeSqliteRead(sessionId, "findStatusSnapshot", () => this.sessionStatusSnapshotRepository.findBySessionId(sessionId));
+            await this.runRuntimeSqliteWrite(sessionId, "upsertTerminalPreservedSnapshot", () => {
+                this.upsertSnapshot(sessionId, {
+                    syncStatus: "idle",
+                    syncCursor: currentSnapshot?.syncCursor ?? null,
+                    lastSyncAt: event.timestamp,
+                    lastErrorCode: null,
+                    lastErrorDetail: null,
+                    resumedAt: currentSnapshot?.resumedAt ?? null
+                });
             });
             await this.maybeEmitRuntimeHistoryFallback(sessionId, event);
             return;
         }
         const completedAt = event.status === "completed" || event.status === "interrupted" || event.status === "failed"
             ? event.timestamp
-            : this.sessionStateRepository.findBySessionAndUser(sessionId, userId)?.completedAt ?? null;
+            : (await this.runRuntimeSqliteRead(sessionId, "findCompletedState", () => this.sessionStateRepository.findBySessionAndUser(sessionId, userId)))?.completedAt ?? null;
         if (completedAt) {
             await this.sessionHistoryService.syncSessionTitle(sessionId).catch(() => {
                 return;
             });
         }
-        this.sessionStateRepository.upsert({
-            sessionId,
-            userId,
-            runningState: toStoredRunningState(event.status),
-            activitySource: "runtime",
-            favorite: currentState?.favorite ?? false,
-            lastEventAt: event.timestamp,
-            completedAt,
-            lastSeenAt: currentState?.lastSeenAt ?? null,
-            updatedAt: nowIso()
+        await this.runRuntimeSqliteWrite(sessionId, "upsertRuntimeState", () => {
+            this.sessionStateRepository.upsert({
+                sessionId,
+                userId,
+                runningState: toStoredRunningState(event.status),
+                activitySource: "runtime",
+                favorite: currentState?.favorite ?? false,
+                lastEventAt: event.timestamp,
+                completedAt,
+                lastSeenAt: currentState?.lastSeenAt ?? null,
+                updatedAt: nowIso()
+            });
         });
         this.sessionActivityAuthorityService.observe(createRuntimeEventObservation(sessionId, event, this.providerRuntimeService.getSnapshot(sessionId)?.startedAt ?? null));
-        this.upsertSnapshot(sessionId, {
-            syncStatus: event.type === "error" ? "error" : "idle",
-            syncCursor: this.sessionStatusSnapshotRepository.findBySessionId(sessionId)?.syncCursor ?? null,
-            lastSyncAt: event.timestamp,
-            lastErrorCode: event.type === "error" ? event.errorCode : null,
-            lastErrorDetail: event.type === "error" ? (event.detail ?? "runtime failed") : null,
-            resumedAt: this.sessionStatusSnapshotRepository.findBySessionId(sessionId)?.resumedAt ?? null
+        const currentSnapshot = await this.runRuntimeSqliteRead(sessionId, "findStatusSnapshot", () => this.sessionStatusSnapshotRepository.findBySessionId(sessionId));
+        await this.runRuntimeSqliteWrite(sessionId, "upsertRuntimeSnapshot", () => {
+            this.upsertSnapshot(sessionId, {
+                syncStatus: event.type === "error" ? "error" : "idle",
+                syncCursor: currentSnapshot?.syncCursor ?? null,
+                lastSyncAt: event.timestamp,
+                lastErrorCode: event.type === "error" ? event.errorCode : null,
+                lastErrorDetail: event.type === "error" ? (event.detail ?? "runtime failed") : null,
+                resumedAt: currentSnapshot?.resumedAt ?? null
+            });
         });
         await this.maybeEmitRuntimeHistoryFallback(sessionId, event);
         if (isTerminalRuntimeEventStatus(event.status)) {
@@ -1804,6 +1847,36 @@ export class SessionLiveRuntimeService {
             void this.dispatchNextQueuedMessage(sessionId);
         }
     }
+    async runRuntimeSqliteRead(sessionId, scope, operation) {
+        return await this.runRuntimeSqliteOperation(sessionId, scope, operation);
+    }
+    async runRuntimeSqliteWrite(sessionId, scope, operation) {
+        await this.runRuntimeSqliteOperation(sessionId, scope, operation);
+    }
+    async runRuntimeSqliteOperation(sessionId, scope, operation) {
+        let attempt = 0;
+        while (true) {
+            try {
+                return operation();
+            }
+            catch (error) {
+                if (!isSqliteBusyError(error) || attempt >= RUNTIME_EVENT_SQLITE_BUSY_RETRY_DELAYS_MS.length) {
+                    throw error;
+                }
+                const delayMs = RUNTIME_EVENT_SQLITE_BUSY_RETRY_DELAYS_MS[attempt];
+                attempt += 1;
+                logPerformance("session.runtime_event.sqlite_busy_retry", delayMs, {
+                    sessionId,
+                    scope,
+                    attempt
+                }, {
+                    thresholdMs: 0,
+                    force: true
+                });
+                await delay(delayMs);
+            }
+        }
+    }
     async emitTerminalStateEvent(event) {
         for (const listener of this.terminalStateListeners) {
             await listener(event);
@@ -2085,6 +2158,25 @@ export class SessionLiveRuntimeService {
             await waitForRuntimeBindingPoll();
         }
     }
+    async requestCodexTitleGenerationAfterStartBinding(sessionId, firstUserMessage, startBindingTask) {
+        const normalizedFirstUserMessage = firstUserMessage.trim();
+        if (!normalizedFirstUserMessage) {
+            return;
+        }
+        try {
+            await startBindingTask;
+        }
+        catch {
+            return;
+        }
+        const binding = this.sessionBindingRepository.findBySessionId(sessionId);
+        if (!binding
+            || binding.provider !== "codex"
+            || !hasResolvedRuntimeBinding(binding.providerSessionId, binding.rawStoreRef)) {
+            return;
+        }
+        this.sessionHistoryService.requestCodexTitleGenerationForNewSession(sessionId, normalizedFirstUserMessage);
+    }
     persistMessageAttachments(sessionId, clientRequestId, attachments) {
         if (!clientRequestId || attachments.length === 0) {
             return {
@@ -2422,10 +2514,6 @@ function mapClaudeHookToRuntimeUpdate(hookEventName, payload, timestamp) {
     }
     return null;
 }
-function buildSessionTitle(content) {
-    const title = content.trim().replace(/\s+/g, " ");
-    return title.slice(0, 48) || "继续对话";
-}
 function resolveRuntimeSessionTitle(provider, existingTitle, content, parentTitle, forkMethod, forkSourceType) {
     const normalizedExistingTitle = existingTitle.trim();
     const normalizedParentTitle = parentTitle?.trim() ?? "";
@@ -2435,7 +2523,7 @@ function resolveRuntimeSessionTitle(provider, existingTitle, content, parentTitl
         (!isForkSession || normalizedExistingTitle !== normalizedParentTitle)) {
         return null;
     }
-    return buildSessionTitle(content);
+    return buildSessionTitleFromContent(content, "继续对话");
 }
 function isSyntheticRuntimeSessionTitle(provider, title) {
     if (provider !== "codex") {
@@ -2737,6 +2825,19 @@ function normalizeOptionalBindingValue(value) {
     const normalized = value?.trim();
     return normalized && normalized.length > 0 ? normalized : null;
 }
+function isSqliteBusyError(error) {
+    if (!error || typeof error !== "object") {
+        return false;
+    }
+    const sqliteCode = "code" in error ? error.code : null;
+    const message = error instanceof Error ? error.message : String(error);
+    return sqliteCode === "SQLITE_BUSY" || message.includes("database is locked");
+}
+async function delay(ms) {
+    await new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
 function logOpenCodeOrderEnvelopeDebug(scope, detail) {
     if (!OPENCODE_ORDER_DEBUG_ENABLED) {
         return;