@linkshell/host 0.4.67 → 0.4.69

package/dist/host/src/hub.js

@@ -10,6 +10,7 @@ import { slimEvent } from "./slim.js";
 import { outputRange } from "./task-output.js";
 import { ComputerPreviews } from "./computer-preview.js";
 import { MacPreviewCapture } from "./computer-preview-capture.js";
+import { SideChats } from "./side.js";
 /**
  * Whether an update is something happening in the session. Names, settings
  * and usage figures arrive when a session is merely opened or renamed, and
@@ -68,6 +69,8 @@ const STANDING = [
     "session_info_update",
     "ls_driver",
 ];
+/** How long a session nobody has open stays attached to a driver that pays to follow it. */
+const IDLE_DETACH_MS = 10 * 60_000;
 const PREVIEW_LENGTH = 160;
 const TITLE_LENGTH = 60;
 function compact(text, max) {
@@ -99,6 +102,9 @@ export class SessionHub {
     removedListeners = new Set();
     interactionListeners = new Set();
     agentListeners = new Set();
+    sideListeners = new Set();
+    sides;
+    idleTimers = new Map();
     auth = new Map();
     /** Terminals (`linkshell <agent>`) currently driving handoff sessions. */
     desktops = new Map();
@@ -195,8 +201,17 @@ export class SessionHub {
         });
         for (const driver of drivers)
             this.drivers.set(driver.id, driver);
+        this.sides = new SideChats((sessionId, side, closed) => {
+            for (const listener of this.sideListeners)
+                listener(sessionId, side, closed);
+        }, log);
     }
     async start(options = {}) {
+        for (const session of this.store.errorSessions()) {
+            const state = this.store.historyFailureRecoveryState(session.id);
+            if (state && state !== session.state)
+                this.commit(session.id, { sessionUpdate: "ls_status", state });
+        }
         for (const id of this.store.resetLiveSessions())
             this.pendingQuestions.delete(id);
         await Promise.all([...this.drivers.values()].map(async (driver) => {
@@ -249,7 +264,11 @@ export class SessionHub {
                 archived: true, state: "idle", asyncQuestions: [],
             });
         }
-        if (driver.sessionExists) {
+        if (driver.nativeSessionAvailability) {
+            for (const session of this.store.sessionsForAgent(driver.id))
+                this.reconcileNativeSession(driver, session);
+        }
+        else if (driver.sessionExists) {
             for (const session of this.store.sessionsForAgent(driver.id)) {
                 const live = this.live.get(session.id);
                 if (live?.turnActive || session.state === "running" || session.state === "waiting")
@@ -260,12 +279,69 @@ export class SessionHub {
             }
         }
     }
+    reconcileNativeSession(driver, session) {
+        if (!driver.nativeSessionAvailability)
+            return;
+        const live = this.live.get(session.id);
+        if (live?.turnActive || live?.held.length || this.desktops.has(session.id))
+            return;
+        const availability = driver.nativeSessionAvailability(session.nativeId, session.cwd);
+        if (availability === "missing")
+            this.hideMissingSession(session);
+        else if (availability === "available" && this.store.isNativeMissing(session.id)) {
+            this.store.setNativeMissing(session.id, false);
+            this.emitSummary(session);
+        }
+    }
+    hideMissingSession(session) {
+        if (this.store.isNativeMissing(session.id))
+            return;
+        this.store.setNativeMissing(session.id, true);
+        this.commit(session.id, { sessionUpdate: "ls_status", state: "offline", turnActive: false });
+        this.store.patchSession(session.id, { pendingPermissions: 0 });
+        this.store.setDriverState(session.id, "asyncQuestions", "[]");
+        this.pendingQuestions.delete(session.id);
+        const driver = this.drivers.get(session.agent);
+        driver?.watched?.(session.nativeId, false);
+        this.live.delete(session.id);
+        this.emitRemoved(session.id);
+        void driver?.detach(session.nativeId).catch((error) => this.log(`[hub] detach missing ${session.id}: ${String(error)}`));
+    }
     async stop() {
         if (this.discoveryTimer)
             clearInterval(this.discoveryTimer);
+        for (const timer of this.idleTimers.values())
+            clearTimeout(timer);
+        this.idleTimers.clear();
+        await this.sides.stop((sessionId) => this.sideTarget(sessionId));
         await Promise.allSettled([...this.drivers.values()].map((driver) => driver.stop()));
         await this.previews.stop();
     }
+    // ── side conversations ────────────────────────────────────────────
+    onSide(listener) {
+        this.sideListeners.add(listener);
+        return () => this.sideListeners.delete(listener);
+    }
+    side(sessionId, sideId, text) {
+        const summary = this.getSession(sessionId);
+        return this.sides.ask(sessionId, { driver: this.requireDriver(summary.agent), nativeId: summary.nativeId, cwd: summary.cwd }, sideId, text);
+    }
+    listSides(sessionId) {
+        this.getSession(sessionId);
+        return this.sides.list(sessionId);
+    }
+    cancelSide(sessionId, sideId) {
+        this.sides.cancel(sessionId, sideId);
+    }
+    async closeSide(sessionId, sideId) {
+        const target = this.sideTarget(sessionId);
+        await this.sides.close(sessionId, sideId, target?.driver, target?.nativeId ?? "");
+    }
+    sideTarget(sessionId) {
+        const summary = this.store.getSession(sessionId);
+        const driver = summary && this.drivers.get(summary.agent);
+        return summary && driver ? { driver, nativeId: summary.nativeId } : undefined;
+    }
     agents() {
         return [...this.drivers.values()].map((driver) => {
             const status = driver.status();
@@ -413,6 +489,8 @@ export class SessionHub {
         const summary = this.store.getSession(sessionId);
         if (!summary)
             throw RpcError.app("not_found", `session ${sessionId} not found`);
+        if (this.store.isNativeMissing(sessionId))
+            throw RpcError.app("not_found", "这个会话的原始记录已不存在，已从列表隐藏；本地缓存仍保留。");
         return this.decorate(summary);
     }
     /** Adds the live-only fields (current activity, first pending permission) to a stored summary. */
@@ -642,6 +720,8 @@ export class SessionHub {
         const summary = this.getSession(sessionId);
         const driver = this.drivers.get(summary.agent);
         if (driver && driver.status().installed) {
+            this.reconcileNativeSession(driver, summary);
+            this.getSession(sessionId);
             try {
                 await this.ensureAttached(sessionId);
             }
@@ -649,19 +729,21 @@ export class SessionHub {
                 // Serve the log we have; not_ready sessions attach once they get a turn.
                 if (!(error instanceof RpcError && error.appCode === "not_ready")) {
                     this.log(`[hub] attach ${sessionId} failed: ${error instanceof Error ? error.message : String(error)}`);
-                    this.commit(sessionId, { sessionUpdate: "ls_status", state: "error" });
-                    this.commit(sessionId, {
-                        sessionUpdate: "ls_error",
-                        code: error instanceof RpcError ? error.appCode ?? "history_unavailable" : "history_unavailable",
-                        message: `读取会话消息失败：${error instanceof Error ? error.message : String(error)}`,
-                        hint: "重新打开会话可重试",
-                    }, undefined, summary.updatedAt);
+                    this.reconcileNativeSession(driver, summary);
+                    this.getSession(sessionId);
+                    subscriber.notice?.({ severity: "warning", title: "暂时无法读取会话历史",
+                        description: `${error instanceof Error ? error.message : String(error)}\n已缓存的消息仍可查看，重新打开会话可重试。` });
                 }
             }
         }
         const live = this.liveFor(sessionId);
         if (driver?.behavior.desktop === "handoff")
             this.lendCommands(this.getSession(sessionId));
+        // Old clients may still hold the synthetic error cards in memory; replay a clean window.
+        if (fromSeq > 0 && this.store.hasHistoryLoadErrors(sessionId)) {
+            fromSeq = 0;
+            subscriber.window?.(0);
+        }
         const lastSeq = this.store.getSession(sessionId)?.lastSeq ?? 0;
         let startSeq = fromSeq;
         const missed = fromSeq > 0 && fromSeq <= lastSeq ? this.store.sizeAfter(sessionId, fromSeq) : undefined;
@@ -681,12 +763,15 @@ export class SessionHub {
         for (;;) {
             const batch = this.store.readEvents(sessionId, cursor, 200);
             for (const event of batch)
-                subscriber.event(event);
+                if (!this.store.isHistoryLoadEvent(event))
+                    subscriber.event(event);
             if (batch.length === 0)
                 break;
             cursor = batch[batch.length - 1].seq;
         }
         live.subscribers.add(subscriber);
+        clearTimeout(this.idleTimers.get(sessionId));
+        this.idleTimers.delete(sessionId);
         if (live.subscribers.size === 1)
             driver?.watched?.(summary.nativeId, true);
         return { session: this.getSession(sessionId), startSeq };
@@ -724,7 +809,7 @@ export class SessionHub {
         if (upTo < 1)
             return { events: [], startSeq: 0 };
         const startSeq = this.store.pageStart(sessionId, upTo);
-        return { events: this.store.readEvents(sessionId, startSeq, PAGE.maxEvents + 1, upTo), startSeq };
+        return { events: this.store.readEvents(sessionId, startSeq, PAGE.maxEvents + 1, upTo).filter((event) => !this.store.isHistoryLoadEvent(event)), startSeq };
     }
     tasks(sessionId) {
         if (!this.store.getSession(sessionId))
@@ -918,6 +1003,38 @@ export class SessionHub {
         const summary = this.store.getSession(sessionId);
         if (summary)
             this.drivers.get(summary.agent)?.watched?.(summary.nativeId, false);
+        this.detachWhenIdle(sessionId);
+    }
+    /**
+     * Detaches a session nobody has open, from a driver that pays to follow it, once it has been
+     * left alone a while with nothing under way. Without this every session opened since the host
+     * started stays followed for good.
+     */
+    detachWhenIdle(sessionId, delay = IDLE_DETACH_MS) {
+        const summary = this.store.getSession(sessionId);
+        const driver = summary && this.drivers.get(summary.agent);
+        if (!summary || !driver?.detachWhenIdle)
+            return;
+        clearTimeout(this.idleTimers.get(sessionId));
+        const timer = setTimeout(() => {
+            this.idleTimers.delete(sessionId);
+            const live = this.live.get(sessionId);
+            if (!live || live.subscribers.size > 0 || !live.attached || live.attaching || live.detaching)
+                return;
+            const tasks = this.tasksOf(sessionId, live);
+            const working = live.turnActive || live.permissions.size > 0 || !!live.queue?.length || live.held.length > 0
+                || [...tasks.values()].some((task) => task.state === "running")
+                || [...(live.subagents?.values() ?? [])].some((state) => subagentRunning(state));
+            // Something is under way: looked at again later.
+            if (working)
+                return this.detachWhenIdle(sessionId, delay);
+            live.attached = false;
+            live.detaching = driver.detach(summary.nativeId)
+                .catch((error) => this.log(`[hub] idle detach ${sessionId}: ${String(error)}`))
+                .finally(() => { live.detaching = undefined; });
+        }, delay);
+        timer.unref?.();
+        this.idleTimers.set(sessionId, timer);
     }
     async prompt(sessionId, clientMessageId, content, whenBusy) {
         const summary = this.getSession(sessionId);
@@ -1058,6 +1175,9 @@ export class SessionHub {
     }
     onRemoved(listener) {
         this.removedListeners.add(listener);
+        // A reconnecting client can retain sessions outside the first discovery page.
+        for (const id of this.store.nativeMissingSessionIds())
+            listener(id);
         return () => this.removedListeners.delete(listener);
     }
     async archive(sessionId, archived) {
@@ -1123,9 +1243,15 @@ export class SessionHub {
     forget(sessionId) {
         if (!this.store.getSession(sessionId))
             return;
+        clearTimeout(this.idleTimers.get(sessionId));
+        this.idleTimers.delete(sessionId);
         this.live.delete(sessionId);
         this.previews.forget(sessionId);
+        this.sides.forget(sessionId);
         this.store.removeSession(sessionId);
+        this.emitRemoved(sessionId);
+    }
+    emitRemoved(sessionId) {
         for (const listener of this.removedListeners) {
             try {
                 listener(sessionId);
@@ -1278,6 +1404,8 @@ export class SessionHub {
     /** Never throws synchronously: failures always arrive as a rejected promise. */
     ensureAttached(sessionId) {
         const live = this.liveFor(sessionId);
+        if (live.detaching)
+            return live.detaching.then(() => this.ensureAttached(sessionId));
         if (live.attached)
             return Promise.resolve();
         if (live.attaching)
@@ -1340,6 +1468,16 @@ export class SessionHub {
         if (this.store.isRemoved(sessionIdFor(agent, session.nativeId)))
             return;
         const before = this.store.getSession(sessionIdFor(agent, session.nativeId));
+        const driver = this.drivers.get(agent);
+        const availability = driver?.nativeSessionAvailability?.(session.nativeId, session.cwd);
+        if (availability === "missing") {
+            if (before)
+                this.reconcileNativeSession(driver, before);
+            return;
+        }
+        const restored = availability === "available" && !!before && this.store.isNativeMissing(before.id);
+        if (restored)
+            this.store.setNativeMissing(before.id, false);
         if (before && session.updatedAt > before.updatedAt) {
             // Renamed just now: the session keeps its place in the list.
             const renamed = this.store.getDriverState(before.id, RENAMED);
@@ -1379,10 +1517,12 @@ export class SessionHub {
             if (questionsChanged)
                 this.store.setDriverState(summary.id, "asyncQuestions", JSON.stringify(session.asyncQuestions));
         }
-        if (created || changed || questionsChanged)
+        if (created || changed || questionsChanged || restored)
             this.emitSummary(summary);
     }
     ingest(sessionId, update, itemId, ts) {
+        if (this.store.isNativeMissing(sessionId))
+            return;
         if (!this.store.getSession(sessionId)) {
             this.log(`[hub] dropping update for unknown session ${sessionId}`);
             return;
@@ -1564,6 +1704,8 @@ export class SessionHub {
             this.emitSummary(stored);
     }
     emitSummary(stored) {
+        if (this.store.isNativeMissing(stored.id))
+            return;
         const summary = this.decorate(stored);
         for (const listener of this.summaryListeners) {
             try {