@jingyi0605/codingns 0.5.1 → 0.6.0

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

@@ -187,6 +187,7 @@ export declare class SessionLiveRuntimeService {
     private readonly sessionPermissionRequestService;
     private readonly runtimeAdapterDisposables;
     private readonly externalRuntimeSnapshots;
+    private readonly externalRuntimeInterruptSuppressions;
     private readonly runtimeListeners;
     private readonly terminalStateListeners;
     private readonly deadRuntimeReconciliationSessions;
@@ -246,6 +247,8 @@ export declare class SessionLiveRuntimeService {
     private buildBindingSnapshot;
     private persistRuntimeEvent;
     private emitTerminalStateEvent;
+    private reconcileTerminalRuntimeSnapshot;
+    private forceInterruptInactiveSession;
     private beginPendingSendDebugTrace;
     private logSendDebugStep;
     private markSendDebugResponseReady;
@@ -265,6 +268,11 @@ export declare class SessionLiveRuntimeService {
     private upsertSnapshot;
     private shouldIgnoreClaudeExternalRuntimeUpdate;
     private clearExternalRuntimeSnapshot;
+    private getFreshExternalRuntimeSnapshot;
+    private suppressInterruptedExternalRuntime;
+    private clearExternalRuntimeInterruptSuppression;
+    private shouldIgnoreInterruptedExternalRuntime;
+    private forceInterruptExternalSession;
     private resolveActiveClaudePermissionSession;
 }
 export {};

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

@@ -14,6 +14,8 @@ import { ClaudeRuntimeHelperAdapter } from "./claude-runtime-helper-client.js";
 import { CodexAppServerHelperClient } from "./codex-app-server-helper-client.js";
 const RUNTIME_START_BINDING_WAIT_TIMEOUT_MS = 10_000;
 const START_BINDING_POLL_INTERVAL_MS = 50;
+const EXTERNAL_RUNTIME_INTERRUPT_SUPPRESSION_MS = 30_000;
+const EXTERNAL_RUNTIME_SNAPSHOT_MAX_AGE_MS = 90_000;
 export class SessionLiveRuntimeService {
     sessionHistoryService;
     sessionMessageAttachmentService;
@@ -31,6 +33,7 @@ export class SessionLiveRuntimeService {
     sessionPermissionRequestService;
     runtimeAdapterDisposables;
     externalRuntimeSnapshots = new Map();
+    externalRuntimeInterruptSuppressions = new Map();
     runtimeListeners = new Map();
     terminalStateListeners = new Set();
     deadRuntimeReconciliationSessions = new Set();
@@ -435,7 +438,7 @@ export class SessionLiveRuntimeService {
     async getSessionRuntime(sessionId, userId) {
         const runtimeSessionId = this.resolveRuntimeSessionId(sessionId);
         const runtimeSnapshot = this.getLiveRuntimeSnapshot(runtimeSessionId);
-        const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(runtimeSessionId) ?? null;
+        const externalRuntimeSnapshot = this.getFreshExternalRuntimeSnapshot(runtimeSessionId);
         const runtimeHasActiveRun = runtimeSnapshot ? isActiveRuntimeState(runtimeSnapshot.runningState) : false;
         const externalHasActiveRun = externalRuntimeSnapshot
             ? isActiveRuntimeState(externalRuntimeSnapshot.runningState)
@@ -485,7 +488,7 @@ export class SessionLiveRuntimeService {
                 runningState: resolution.runningState,
                 hasActiveRun: externalHasActiveRun,
                 canAttach: false,
-                canInterrupt: false,
+                canInterrupt: externalHasActiveRun,
                 inRunInputMode: capabilities.inRunInputMode,
                 activityResolutionSource: resolution.activityResolutionSource,
                 activityConfidence: resolution.activityConfidence,
@@ -528,32 +531,59 @@ export class SessionLiveRuntimeService {
         if (runtimeSnapshot) {
             return createRuntimeActivityObservation(runtimeSessionId, runtimeSnapshot);
         }
-        const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(runtimeSessionId) ?? null;
+        const externalRuntimeSnapshot = this.getFreshExternalRuntimeSnapshot(runtimeSessionId);
         if (externalRuntimeSnapshot) {
             return createExternalRuntimeActivityObservation(runtimeSessionId, externalRuntimeSnapshot);
         }
         return null;
     }
     async interruptSession(sessionId, userId) {
-        this.sessionHistoryService.getSession(sessionId, userId);
+        const session = this.sessionHistoryService.getSession(sessionId, userId);
         const runtimeSessionId = this.resolveRuntimeSessionId(sessionId);
         const runtime = this.getLiveRuntimeSnapshot(runtimeSessionId);
-        const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(runtimeSessionId) ?? null;
+        const externalRuntimeSnapshot = this.getFreshExternalRuntimeSnapshot(runtimeSessionId);
         if (!runtime || (runtime.runningState !== "running" && runtime.runningState !== "starting")) {
+            if (runtime && !isActiveRuntimeState(runtime.runningState)) {
+                await this.reconcileTerminalRuntimeSnapshot(sessionId, runtime);
+                return {
+                    sessionId,
+                    interrupted: true,
+                    detail: runtime.detail ?? "当前会话已结束，已自动同步状态"
+                };
+            }
             if (externalRuntimeSnapshot && isActiveRuntimeState(externalRuntimeSnapshot.runningState)) {
-                throw new AppError({
-                    statusCode: 409,
-                    errorCode: "CAPABILITY_NOT_SUPPORTED",
-                    detail: "当前 Claude 外部运行仍在进行，但现有链路不支持中断",
-                    field: "sessionId"
-                });
+                const refreshedSession = await Promise.resolve(this.sessionHistoryService.refreshRuntimeFallbackSession(sessionId, userId)).catch(() => null);
+                if (refreshedSession && !isPendingSessionRunningState(refreshedSession.runningState)) {
+                    await this.forceInterruptInactiveSession(sessionId);
+                    return {
+                        sessionId,
+                        interrupted: true,
+                        detail: "当前会话已停止，已自动同步状态"
+                    };
+                }
+                await this.forceInterruptExternalSession(sessionId);
+                return {
+                    sessionId,
+                    interrupted: true,
+                    detail: "Claude 外部运行当前无法直接中断，已强制清理本地运行状态"
+                };
             }
-            throw new AppError({
-                statusCode: 409,
-                errorCode: "SESSION_NOT_RUNNING",
-                detail: "当前会话不在运行中，无法中断",
-                field: "sessionId"
-            });
+            const refreshedSession = isPendingSessionRunningState(session.runningState)
+                ? await Promise.resolve(this.sessionHistoryService.refreshRuntimeFallbackSession(sessionId, userId)).catch(() => null)
+                : session;
+            if (refreshedSession && !isPendingSessionRunningState(refreshedSession.runningState)) {
+                return {
+                    sessionId,
+                    interrupted: true,
+                    detail: "当前会话已停止，已自动同步状态"
+                };
+            }
+            await this.forceInterruptInactiveSession(sessionId);
+            return {
+                sessionId,
+                interrupted: true,
+                detail: "当前会话已停止，已自动修正残留运行状态"
+            };
         }
         const interrupted = await this.providerRuntimeService.interrupt(runtimeSessionId).catch((error) => {
             if (error instanceof Error && error.message === "INTERRUPT_NOT_SUPPORTED") {
@@ -589,7 +619,7 @@ export class SessionLiveRuntimeService {
     subscribeRuntime(sessionId, onEnvelope) {
         const runtimeSessionId = this.resolveRuntimeSessionId(sessionId);
         const runtimeSnapshot = this.getLiveRuntimeSnapshot(runtimeSessionId);
-        const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(runtimeSessionId) ?? null;
+        const externalRuntimeSnapshot = this.getFreshExternalRuntimeSnapshot(runtimeSessionId);
         const initialActivityEnvelope = this.buildSessionActivityEnvelope(sessionId, runtimeSessionId);
         if (runtimeSnapshot) {
             void onEnvelope({
@@ -767,13 +797,13 @@ export class SessionLiveRuntimeService {
                 sessionId
             };
         }
-        const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(runtimeSessionId) ?? null;
+        const externalRuntimeSnapshot = this.getFreshExternalRuntimeSnapshot(runtimeSessionId);
         if (externalRuntimeSnapshot) {
             const resolution = this.sessionActivityAuthorityService.observe(createExternalRuntimeActivityObservation(runtimeSessionId, externalRuntimeSnapshot));
             return {
                 ...this.mapResolutionToActivityEnvelope(resolution, {
                     hasActiveRun: isActiveRuntimeState(externalRuntimeSnapshot.runningState),
-                    canInterrupt: false
+                    canInterrupt: isActiveRuntimeState(externalRuntimeSnapshot.runningState)
                 }),
                 sessionId
             };
@@ -792,7 +822,7 @@ export class SessionLiveRuntimeService {
     }
     resolveRuntimeSessionId(sessionId) {
         if (this.providerRuntimeService.getSnapshot(sessionId)
-            || this.externalRuntimeSnapshots.has(sessionId)) {
+            || this.getFreshExternalRuntimeSnapshot(sessionId)) {
             return sessionId;
         }
         const listSnapshots = "listSnapshots" in this.providerRuntimeService
@@ -898,6 +928,12 @@ export class SessionLiveRuntimeService {
         };
     }
     async applyExternalRuntimeUpdate(input) {
+        if (input.runningState === "running" && this.shouldIgnoreInterruptedExternalRuntime(input.sessionId)) {
+            return;
+        }
+        if (input.runningState !== "running") {
+            this.clearExternalRuntimeInterruptSuppression(input.sessionId);
+        }
         const userIds = this.authUserRepository.listIds();
         if (userIds.length === 0) {
             return;
@@ -994,6 +1030,7 @@ export class SessionLiveRuntimeService {
     async startRuntimeRun(request, userId, mode) {
         this.runtimeMessageSeenSessions.delete(request.sessionId);
         this.runtimeHistoryFallbackSentSessions.delete(request.sessionId);
+        this.clearExternalRuntimeInterruptSuppression(request.sessionId);
         if (request.provider === "claude-code") {
             this.clearExternalRuntimeSnapshot(request.sessionId);
         }
@@ -1061,7 +1098,7 @@ export class SessionLiveRuntimeService {
             };
             const runtimeSessionId = this.resolveRuntimeSessionId(input.sessionId);
             const activeRun = this.getLiveRuntimeSnapshot(runtimeSessionId);
-            const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(runtimeSessionId);
+            const externalRuntimeSnapshot = this.getFreshExternalRuntimeSnapshot(runtimeSessionId);
             if (activeRun &&
                 activeRun.provider === "claude-code" &&
                 isActiveRuntimeState(activeRun.runningState)) {
@@ -1156,7 +1193,7 @@ export class SessionLiveRuntimeService {
         this.queueDispatchSessions.add(sessionId);
         try {
             const runtimeSnapshot = this.getLiveRuntimeSnapshot(sessionId);
-            const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(sessionId);
+            const externalRuntimeSnapshot = this.getFreshExternalRuntimeSnapshot(sessionId);
             if ((runtimeSnapshot && isActiveRuntimeState(runtimeSnapshot.runningState))
                 || (externalRuntimeSnapshot && isActiveRuntimeState(externalRuntimeSnapshot.runningState))) {
                 return;
@@ -1222,7 +1259,7 @@ export class SessionLiveRuntimeService {
         if (runtimeSnapshot && isActiveRuntimeState(runtimeSnapshot.runningState)) {
             return true;
         }
-        const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(session.sessionId);
+        const externalRuntimeSnapshot = this.getFreshExternalRuntimeSnapshot(session.sessionId);
         if (externalRuntimeSnapshot && isActiveRuntimeState(externalRuntimeSnapshot.runningState)) {
             return true;
         }
@@ -1259,7 +1296,7 @@ export class SessionLiveRuntimeService {
             return session;
         }
         const runtimeSnapshot = this.getLiveRuntimeSnapshot(sessionId);
-        const externalRuntimeSnapshot = this.externalRuntimeSnapshots.get(sessionId);
+        const externalRuntimeSnapshot = this.getFreshExternalRuntimeSnapshot(sessionId);
         if ((runtimeSnapshot && isActiveRuntimeState(runtimeSnapshot.runningState))
             || (externalRuntimeSnapshot && isActiveRuntimeState(externalRuntimeSnapshot.runningState))) {
             return session;
@@ -1482,6 +1519,112 @@ export class SessionLiveRuntimeService {
             await listener(event);
         }
     }
+    async reconcileTerminalRuntimeSnapshot(sessionId, runtime) {
+        const timestamp = runtime.lastEventAt ?? runtime.completedAt ?? runtime.startedAt;
+        const runningState = toStoredRunningState(runtime.runningState);
+        const currentSnapshot = this.sessionStatusSnapshotRepository.findBySessionId(sessionId);
+        for (const userId of this.authUserRepository.listIds()) {
+            const current = this.sessionStateRepository.findBySessionAndUser(sessionId, userId);
+            if (current?.lastEventAt
+                && current.lastEventAt.localeCompare(timestamp) > 0
+                && isTerminalSessionRunningState(current.runningState)) {
+                continue;
+            }
+            this.sessionStateRepository.upsert({
+                sessionId,
+                userId,
+                runningState,
+                activitySource: "runtime",
+                favorite: current?.favorite ?? false,
+                lastEventAt: timestamp,
+                completedAt: isTerminalSessionRunningState(runningState)
+                    ? (runtime.completedAt ?? timestamp)
+                    : current?.completedAt ?? null,
+                lastSeenAt: current?.lastSeenAt ?? null,
+                updatedAt: nowIso()
+            });
+        }
+        this.upsertSnapshot(sessionId, {
+            syncStatus: runningState === "failed" ? "error" : "idle",
+            syncCursor: currentSnapshot?.syncCursor ?? null,
+            lastSyncAt: timestamp,
+            lastErrorCode: runningState === "failed" ? runtime.errorCode ?? null : null,
+            lastErrorDetail: runningState === "failed" ? runtime.detail ?? null : null,
+            resumedAt: currentSnapshot?.resumedAt ?? null
+        });
+        this.sessionActivityAuthorityService.observe(createRuntimeActivityObservation(sessionId, runtime));
+        await this.emitExternalRuntimeEnvelope({
+            type: "session.runtime_status",
+            sessionId,
+            status: runtime.runningState,
+            detail: runtime.detail,
+            interruptSource: runtime.interruptSource,
+            timestamp
+        });
+        if (isTerminalSessionRunningState(runningState)) {
+            await this.emitTerminalStateEvent({
+                sessionId,
+                status: runningState,
+                timestamp,
+                detail: runtime.detail,
+                source: "runtime"
+            });
+            void this.dispatchNextQueuedMessage(sessionId);
+        }
+    }
+    async forceInterruptInactiveSession(sessionId) {
+        const timestamp = nowIso();
+        const currentSnapshot = this.sessionStatusSnapshotRepository.findBySessionId(sessionId);
+        for (const userId of this.authUserRepository.listIds()) {
+            const current = this.sessionStateRepository.findBySessionAndUser(sessionId, userId);
+            if (!current || !isPendingSessionRunningState(current.runningState)) {
+                continue;
+            }
+            this.sessionStateRepository.upsert({
+                ...current,
+                runningState: "interrupted",
+                activitySource: "runtime",
+                completedAt: timestamp,
+                updatedAt: timestamp
+            });
+        }
+        this.clearExternalRuntimeSnapshot(sessionId);
+        this.upsertSnapshot(sessionId, {
+            syncStatus: "idle",
+            syncCursor: currentSnapshot?.syncCursor ?? null,
+            lastSyncAt: timestamp,
+            lastErrorCode: null,
+            lastErrorDetail: null,
+            resumedAt: currentSnapshot?.resumedAt ?? null
+        });
+        this.sessionActivityAuthorityService.observe({
+            sessionId,
+            runId: null,
+            runningState: "interrupted",
+            source: "authoritative_runtime",
+            confidence: "strong",
+            detail: "检测到会话实际已停止，已自动修正残留运行状态",
+            interruptSource: "runtime",
+            errorCode: null,
+            observedAt: timestamp
+        });
+        await this.emitExternalRuntimeEnvelope({
+            type: "session.runtime_status",
+            sessionId,
+            status: "interrupted",
+            detail: "检测到会话实际已停止，已自动修正残留运行状态",
+            interruptSource: "runtime",
+            timestamp
+        });
+        await this.emitTerminalStateEvent({
+            sessionId,
+            status: "interrupted",
+            timestamp,
+            detail: "检测到会话实际已停止，已自动修正残留运行状态",
+            source: "runtime"
+        });
+        void this.dispatchNextQueuedMessage(sessionId);
+    }
     beginPendingSendDebugTrace(input) {
         if (!isPerfDebugEnabled()) {
             return null;
@@ -1764,6 +1907,39 @@ export class SessionLiveRuntimeService {
     clearExternalRuntimeSnapshot(sessionId) {
         this.externalRuntimeSnapshots.delete(sessionId);
     }
+    getFreshExternalRuntimeSnapshot(sessionId) {
+        const snapshot = this.externalRuntimeSnapshots.get(sessionId) ?? null;
+        if (!snapshot) {
+            return null;
+        }
+        if (!isExternalRuntimeSnapshotExpired(snapshot)) {
+            return snapshot;
+        }
+        this.clearExternalRuntimeSnapshot(sessionId);
+        this.sessionActivityAuthorityService.clearSession(sessionId);
+        return null;
+    }
+    suppressInterruptedExternalRuntime(sessionId) {
+        this.externalRuntimeInterruptSuppressions.set(sessionId, Date.now() + EXTERNAL_RUNTIME_INTERRUPT_SUPPRESSION_MS);
+    }
+    clearExternalRuntimeInterruptSuppression(sessionId) {
+        this.externalRuntimeInterruptSuppressions.delete(sessionId);
+    }
+    shouldIgnoreInterruptedExternalRuntime(sessionId) {
+        const expiresAt = this.externalRuntimeInterruptSuppressions.get(sessionId);
+        if (!expiresAt) {
+            return false;
+        }
+        if (Date.now() >= expiresAt) {
+            this.externalRuntimeInterruptSuppressions.delete(sessionId);
+            return false;
+        }
+        return true;
+    }
+    async forceInterruptExternalSession(sessionId) {
+        this.suppressInterruptedExternalRuntime(sessionId);
+        await this.forceInterruptInactiveSession(sessionId);
+    }
     async resolveActiveClaudePermissionSession(input) {
         const activeSnapshots = this.providerRuntimeService
             .listSnapshots()
@@ -1835,6 +2011,13 @@ function createExternalRuntimeActivityObservation(sessionId, snapshot) {
         observedAt: snapshot.updatedAt
     };
 }
+function isExternalRuntimeSnapshotExpired(snapshot) {
+    const updatedAtMs = Date.parse(snapshot.updatedAt);
+    if (!Number.isFinite(updatedAtMs)) {
+        return true;
+    }
+    return Date.now() - updatedAtMs > EXTERNAL_RUNTIME_SNAPSHOT_MAX_AGE_MS;
+}
 function createRuntimeEventObservation(sessionId, event, startedAt) {
     return {
         sessionId,