neoctl 0.2.51 → 0.2.52

package/dist/web/index.js

@@ -478,6 +478,66 @@ function parseResumeFlag(value) {
 }
 export class WebRuntimeRouter {
     repls = new Map();
+    deletedSessions = new Set();
+    deletingSessions = new Set();
+    assertSessionAvailable(sessionId) {
+        if (sessionId && (this.deletedSessions.has(sessionId) || this.deletingSessions.has(sessionId))) {
+            throw new Error("会话已删除或正在删除");
+        }
+    }
+    async deleteSession(scope, sessionId) {
+        if (!sessionId)
+            return actionFailure("INVALID_REQUEST", "sessionId is required");
+        if (this.deletingSessions.has(sessionId))
+            return actionFailure("SESSION_DELETING", "会话正在删除");
+        if (this.deletedSessions.has(sessionId))
+            return actionFailure("SESSION_NOT_FOUND", "会话已删除");
+        this.deletingSessions.add(sessionId);
+        try {
+            const entries = await Promise.all([...this.repls.entries()].map(async ([key, promise]) => ({ key, promise, repl: await promise.catch(() => undefined) })));
+            const owners = [...new Set(entries.filter(entry => entry.repl?.currentSessionId() === sessionId).map(entry => entry.repl))];
+            // Shared hubs should have one owner. Never orphan a legacy second writer.
+            if (owners.length > 1)
+                return actionFailure("SESSION_IN_USE", "会话被多个运行实例占用，请先关闭其它窗口");
+            // A cold current-session request must restore its owner without passing the deletion gate.
+            if (!owners.length && scope.sessionId === sessionId) {
+                const key = `session:${sessionId}`;
+                const promise = this.createRuntime({ sessionId, resume: true }).then(runtime => this.createRepl(runtime));
+                this.repls.set(key, promise);
+                try {
+                    const repl = await promise;
+                    entries.push({ key, promise, repl });
+                    owners.push(repl);
+                }
+                catch (error) {
+                    this.repls.delete(key);
+                    throw error;
+                }
+            }
+            const repl = owners[0] || await this.get(scope);
+            if (entries.some(entry => entry.repl?.runningSessionIds().includes(sessionId)))
+                return actionFailure("SESSION_RUNNING", "运行中的会话不可删除");
+            const result = await repl.deleteSession(sessionId);
+            if (!result.ok)
+                return result;
+            this.deletedSessions.add(sessionId);
+            // Retire every cache alias of the deleted writer, then publish only the replacement key.
+            if (owners.length) {
+                for (const entry of entries)
+                    if (entry.repl === repl && this.repls.get(entry.key) === entry.promise)
+                        this.repls.delete(entry.key);
+                if (result.replacementSessionId)
+                    this.repls.set(`session:${result.replacementSessionId}`, Promise.resolve(repl));
+            }
+            // Publish only after the replacement is routable; SSE clients may reconnect immediately.
+            if (owners.length)
+                repl.publishSessionDeletion(sessionId, result.replacementSessionId);
+            return result;
+        }
+        finally {
+            this.deletingSessions.delete(sessionId);
+        }
+    }
     createRuntime;
     createRepl;
     clientRevision = process.env.NEO_CLIENT_REVISION?.trim() || `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
@@ -487,6 +547,7 @@ export class WebRuntimeRouter {
         this.createRepl = options.createRepl ?? ((runtime) => new WebRepl(runtime));
     }
     get(scope = {}) {
+        this.assertSessionAvailable(scope.sessionId);
         const key = webRuntimeScopeKey(scope);
         let repl = this.repls.get(key);
         if (!repl) {
@@ -551,6 +612,9 @@ function webRuntimeScopeKey(scope) {
 export class WebRepl {
     runtime;
     demoOptions;
+    currentSessionId() { return this.runtime.engine.snapshot().session?.sessionId; }
+    deletingSession = false;
+    sessionMutations = 0;
     pendingContinuation;
     runControl() {
         const execution = this.runtime.engine.getExecutionState?.();
@@ -896,6 +960,8 @@ export class WebRepl {
         await this.refreshToolConfiguration();
     }
     async setSessionTools(value) {
+        if (this.deletingSession)
+            return actionFailure("SESSION_DELETING", "会话正在删除");
         if (this.busy)
             return actionFailure("TOOL_UPDATE_BLOCKED", "cannot change session tools while a response is running");
         if (!isRecord(value))
@@ -906,6 +972,7 @@ export class WebRepl {
         const normalized = this.parseToolModes(value, support);
         if (!normalized.ok)
             return normalized;
+        this.sessionMutations++;
         try {
             await this.applySessionToolOverrides(normalized.value, true);
             return { ok: true, state: this.sessionTools() };
@@ -913,6 +980,9 @@ export class WebRepl {
         catch (error) {
             return actionFailure("TOOL_UPDATE_FAILED", error instanceof Error ? error.message : String(error));
         }
+        finally {
+            this.sessionMutations--;
+        }
     }
     async loadSessionTools(sessionId) {
         const support = this.runtime.toolSupport;
@@ -921,6 +991,8 @@ export class WebRepl {
         await this.applySessionToolOverrides(await support.resolveSession(sessionId), false);
     }
     async setSessionPlugins(value) {
+        if (this.deletingSession)
+            return actionFailure("SESSION_DELETING", "会话正在删除");
         if (!isRecord(value))
             return actionFailure("INVALID_REQUEST", "plugin overrides must be an object");
         const support = this.runtime.pluginSupport;
@@ -938,6 +1010,7 @@ export class WebRepl {
             else if (mode !== "inherit" && mode !== null && mode !== undefined)
                 return actionFailure("PLUGIN_INVALID", `invalid plugin mode: ${id}`);
         }
+        this.sessionMutations++;
         try {
             await this.applySessionPluginOverrides(overrides, true);
             return { ok: true, state: this.sessionPlugins() };
@@ -945,6 +1018,9 @@ export class WebRepl {
         catch (error) {
             return actionFailure("PLUGIN_UPDATE_FAILED", error instanceof Error ? error.message : String(error));
         }
+        finally {
+            this.sessionMutations--;
+        }
     }
     async loadSessionPlugins(sessionId) {
         const support = this.runtime.pluginSupport;
@@ -1035,6 +1111,8 @@ export class WebRepl {
         this.publishRuntimeContext();
     }
     async submit(text, attachments = []) {
+        if (this.deletingSession)
+            return actionFailure("SESSION_DELETING", "会话正在删除");
         if (this.runControl().canResume && (!text.trimStart().startsWith("/") || !text.trim()))
             return this.continueRun(text, attachments);
         if (this.pendingContinuation)
@@ -1063,6 +1141,8 @@ export class WebRepl {
         return { ok: true };
     }
     async submitImmediately(text, attachments = []) {
+        if (this.deletingSession)
+            return actionFailure("SESSION_DELETING", "会话正在删除");
         if (this.runControl().canResume) {
             const result = this.continueRun(text, attachments);
             return result.ok ? { ok: true, interrupted: false } : result;
@@ -1083,6 +1163,8 @@ export class WebRepl {
         return this.sendQueuedNow();
     }
     sendQueuedNow() {
+        if (this.deletingSession)
+            return Promise.reject(new Error("会话正在删除"));
         if (this.immediateSend)
             return this.immediateSend;
         const queuedText = this.queuedInput;
@@ -1121,8 +1203,11 @@ export class WebRepl {
         return { ...(options ? paginateSessions(sessions, options) : { sessions }), runningSessionIds };
     }
     async resumeSession(sessionId) {
+        if (this.deletingSession)
+            return actionFailure("SESSION_DELETING", "会话正在删除");
         if (!sessionId)
             return actionFailure("INVALID_REQUEST", "sessionId is required");
+        this.sessionMutations++;
         try {
             const running = this.backgroundSessionRuns.get(sessionId);
             if (running) {
@@ -1144,8 +1229,14 @@ export class WebRepl {
             const message = error instanceof Error ? error.message : String(error);
             return actionFailure("SESSION_RESUME_FAILED", message);
         }
+        finally {
+            this.sessionMutations--;
+        }
     }
     async newSession() {
+        if (this.deletingSession)
+            return actionFailure("SESSION_DELETING", "会话正在删除");
+        this.sessionMutations++;
         try {
             await this.detachRunningForeground("new session");
             this.runtime.engine = this.runtime.engine.forkForSession(undefined, false);
@@ -1162,8 +1253,11 @@ export class WebRepl {
             const message = error instanceof Error ? error.message : String(error);
             return actionFailure("SESSION_CREATE_FAILED", message);
         }
+        finally {
+            this.sessionMutations--;
+        }
     }
-    async refreshSessionView() {
+    async refreshSessionView(publish = true) {
         const metrics = await this.runtime.engine.contextMetrics();
         this.runtime.usage.reset();
         this.status = initialStatus(this.runtime, metrics);
@@ -1175,27 +1269,75 @@ export class WebRepl {
         this.thinkingLineId = undefined;
         this.finalizedThinkingLineId = undefined;
         this.liveToolLineIds.clear();
-        this.broadcastSync();
-        this.publishRuntimeContext();
+        if (publish) {
+            this.broadcastSync();
+            this.publishRuntimeContext();
+        }
     }
     async deleteSession(sessionId) {
         if (!sessionId)
             return actionFailure("INVALID_REQUEST", "sessionId is required");
-        if (this.runtime.engine.snapshot().session?.sessionId === sessionId) {
-            return actionFailure("SESSION_ACTIVE", "cannot delete the active session");
-        }
-        if (this.backgroundSessionRuns.has(sessionId)) {
-            return actionFailure("SESSION_RUNNING", "cannot delete a running session");
-        }
+        if (this.deletingSession)
+            return actionFailure("SESSION_DELETING", "会话正在删除");
+        if (this.sessionMutations)
+            return actionFailure("SESSION_IN_USE", "会话正在保存或切换，请稍后重试");
+        const active = this.runtime.engine.snapshot().session?.sessionId === sessionId;
+        if (this.backgroundSessionRuns.has(sessionId) || (active && (this.busy || this.foregroundRun || this.compactingSession || this.pendingContinuation || this.immediateSend || this.backgroundTaskCount))) {
+            return actionFailure("SESSION_RUNNING", "运行中的会话不可删除");
+        }
+        this.deletingSession = true;
+        const previous = this.runtime.engine;
+        let deleted = false;
         try {
-            const deleted = await this.runtime.engine.deleteSession(sessionId);
-            if (!deleted)
+            if (active) {
+                // Retire the writer before removing files; an uninitialized fork owns no directory.
+                await this.runtimeContextPublishQueue;
+                await previous.settleSessionWrites();
+                await this.demoMessageQueues.get(previous);
+                this.queuedInput = undefined;
+                this.queuedAttachments = undefined;
+                this.pendingContinuation = undefined;
+                this.runtime.engine = previous.forkForSession(undefined, false);
+                activateSession(this.runtime);
+            }
+            deleted = await this.runtime.engine.deleteSession(sessionId);
+            if (!deleted) {
+                if (active) {
+                    this.runtime.engine = previous;
+                    activateSession(this.runtime);
+                }
                 return actionFailure("SESSION_NOT_FOUND", `session not found: ${sessionId}`);
-            return { ok: true };
+            }
+            if (!active)
+                return { ok: true };
+            await this.runtime.engine.initialize();
+            activateSession(this.runtime);
+            const replacementSessionId = this.runtime.engine.snapshot().session?.sessionId;
+            if (!replacementSessionId)
+                throw new Error("新会话初始化失败");
+            await Promise.all([this.loadSessionPlugins(replacementSessionId), this.loadSessionTools(replacementSessionId)]);
+            await this.refreshSessionView(false);
+            return { ok: true, replacementSessionId };
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return actionFailure("SESSION_DELETE_FAILED", message);
+            if (active && !deleted) {
+                this.runtime.engine = previous;
+                activateSession(this.runtime);
+            }
+            if (active && deleted) {
+                // A deletion cannot be rolled back; never restore the deleted writer.
+                return { ok: true };
+            }
+            return actionFailure("SESSION_DELETE_FAILED", error instanceof Error ? error.message : String(error));
+        }
+        finally {
+            this.deletingSession = false;
+        }
+    }
+    publishSessionDeletion(sessionId, replacementSessionId) {
+        for (const subscriber of this.subscribers) {
+            this.send(subscriber, replacementSessionId ? "session.replaced" : "session.deleted", replacementSessionId
+                ? { deletedSessionId: sessionId, sessionId: replacementSessionId } : { sessionId });
         }
     }
     appPrompt() {
@@ -1274,6 +1416,8 @@ export class WebRepl {
         this.setStatus({ ...this.status, metrics, activityTick: this.status.activityTick + 1 });
     }
     async setFastMode(enabled) {
+        if (this.deletingSession)
+            return actionFailure("SESSION_DELETING", "会话正在删除");
         const engine = this.runtime.engine;
         try {
             const { deferred } = await engine.updateSessionSettings({ fastMode: enabled });
@@ -1286,6 +1430,8 @@ export class WebRepl {
         }
     }
     async setContextWindowK(value) {
+        if (this.deletingSession)
+            return actionFailure("SESSION_DELETING", "会话正在删除");
         if (typeof value !== "string" || !/^\d+$/u.test(value) || Number(value) <= 0 || !Number.isSafeInteger(Number(value) * 1000)) {
             return actionFailure("CONTEXT_WINDOW_INVALID", "context window must be a positive integer in k");
         }
@@ -1305,6 +1451,8 @@ export class WebRepl {
         }
     }
     async setSessionModel(model, reasoning) {
+        if (this.deletingSession)
+            return actionFailure("SESSION_DELETING", "会话正在删除");
         if (typeof model !== "string" || !model.trim() || model.length > 256 || /[\s\x00-\x1f]/u.test(model.trim())) {
             return actionFailure("MODEL_INVALID", "invalid model");
         }
@@ -1337,6 +1485,8 @@ export class WebRepl {
         return readSessionPrompt(this.runtime.engine);
     }
     async saveSessionPrompt(body) {
+        if (this.deletingSession)
+            return actionFailure("SESSION_DELETING", "会话正在删除");
         const engine = this.runtime.engine;
         const result = await updateSessionPrompt(engine, body);
         if (this.runtime.engine === engine) {
@@ -1348,6 +1498,8 @@ export class WebRepl {
         return result;
     }
     async compactSession() {
+        if (this.deletingSession)
+            return actionFailure("SESSION_DELETING", "会话正在删除");
         const engine = this.runtime.engine;
         if (this.isDemo())
             return actionFailure("DEMO_SCRIPTED", "演示会话由后台安排压缩");
@@ -1484,6 +1636,8 @@ export class WebRepl {
         return { ok: true };
     }
     continueRun(text = "", attachments = []) {
+        if (this.deletingSession)
+            return actionFailure("SESSION_DELETING", "会话正在删除");
         if (!this.runControl().canResume)
             return actionFailure("INVALID_REQUEST", "没有可恢复的执行，或续接请求已经提交");
         const useQueue = !text.trim() && attachments.length === 0 && this.queuedInput !== undefined;
@@ -2440,6 +2594,8 @@ export class WebRepl {
         });
     }
     publishRuntimeContext(targets) {
+        if (this.deletingSession)
+            return;
         this.runtimeContextPublishQueue = this.runtimeContextPublishQueue.then(async () => {
             const revision = ++this.runtimeContextRevision;
             const payload = await this.buildRuntimeContext(revision);
@@ -2528,6 +2684,8 @@ export class WebRepl {
                 this.send(subscriber, "terminal.output", { updates });
     }
     broadcastSync() {
+        if (this.deletingSession)
+            return;
         this.discardPendingDeltaOperations();
         const payload = this.snapshot(false);
         for (const subscriber of this.subscribers)
@@ -2590,6 +2748,10 @@ export async function handleWebRequest(req, res, router) {
         if (req.method === "GET" && url.pathname === "/api/sessions/running")
             return sendJson(res, { runningSessionIds: await router.runningSessionIds() });
         const scope = webRuntimeScopeFromUrl(url);
+        if (req.method === "POST" && url.pathname === "/api/sessions/delete") {
+            const body = await readJsonBody(req);
+            return sendJson(res, await router.deleteSession(scope, String(body.sessionId ?? "")));
+        }
         const repl = await router.get(scope);
         if (req.method === "GET" && url.pathname === "/events")
             return repl.subscribe(res, router.clientInfo());
@@ -2800,10 +2962,6 @@ export async function handleWebRequest(req, res, router) {
         }
         if (req.method === "POST" && url.pathname === "/api/sessions/new")
             return sendJson(res, await repl.newSession());
-        if (req.method === "POST" && url.pathname === "/api/sessions/delete") {
-            const body = await readJsonBody(req);
-            return sendJson(res, await repl.deleteSession(String(body.sessionId ?? "")));
-        }
         if (req.method === "GET" && url.pathname === "/api/login")
             return sendJson(res, repl.loginForm(url.searchParams.get("provider") ?? undefined));
         if (req.method === "POST" && url.pathname === "/api/login") {