@vibecook/ghosttea-react 0.11.0 → 0.12.0

package/dist/runtime.js

@@ -1,9 +1,10 @@
+import { terminalLinkUrl } from "@vibecook/ghosttea-protocol";
 import { ControlClient } from "@vibecook/ghosttea";
 import { DEFAULT_ROUTED_PROTOCOL_LIMITS, PROTOCOL_MAJOR, PROTOCOL_MINOR, SESSION_SCROLLBACK_PROTOCOL_MINOR, STRUCTURED_ERROR_PROTOCOL_MINOR, isRoutedSessionAttachGrant, isRoutedTerminalOpenTicket, isValidScrollbackBytes, } from "@vibecook/ghosttea-protocol";
 import { FRAME_MAGIC, FrameFlag } from "@vibecook/ghosttea-frame";
 import { FrameResyncController } from "./frame-resync.js";
 import { initialRoutedActivation, reduceRoutedActivation, } from "./routed-activation.js";
-import { RoutedControlTransport } from "./routed-control.js";
+import { RoutedControlTransport, } from "./routed-control.js";
 const MAX_BROWSER_TIMEOUT_MS = 2_147_483_647;
 function routedConnectionRefusalIsRecoverable(refusal) {
     return refusal.retryable || refusal.code === "GRANT_GENERATION_ROLLBACK" || refusal.code === "GRANT_NONCE_REPLAYED";
@@ -101,10 +102,16 @@ export class GhostteaTerminalRuntime extends EventTarget {
     #configSnapshot;
     #configProtocolSupported = false;
     #metadataTimers = new Map();
+    #metadataRefreshes = new Map();
+    #metadataRefreshPending = new Set();
+    #sessionGenerationByHandle = new Map();
+    #appliedRoutedExitEvents = new Set();
+    #sessionGeneration = 0;
     #resync;
     #performanceRequestId = 1;
     #performanceRequests = new Map();
     #counterRequests = new Map();
+    #linksByHandle = new Map();
     #disposed = false;
     constructor(options) {
         super();
@@ -119,6 +126,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
             options.transport === "routed"
                 ? new RoutedControlTransport({
                     ...(options.websocketFactory === undefined ? {} : { socketFactory: options.websocketFactory }),
+                    acceptExtensionMessages: options.host.onExtensionMessage !== undefined,
                     emit: (event) => this.#handleRoutedControlEvent(event),
                 })
                 : undefined;
@@ -149,6 +157,10 @@ export class GhostteaTerminalRuntime extends EventTarget {
             else if (data.type === "clipboard-write") {
                 this.#platform.writeClipboard(data.text);
             }
+            else if (data.type === "link-targets") {
+                this.#linksByHandle.set(data.sessionHandle, data.links.filter((link) => terminalLinkUrl(link.uri) !== null));
+                this.dispatchEvent(new CustomEvent("link-targets", { detail: { sessionHandle: data.sessionHandle } }));
+            }
             else if (data.type === "scrollbar-state") {
                 this.#scrollbarByHandle.set(data.sessionHandle, data.scrollbar);
                 this.dispatchEvent(new CustomEvent("scrollbar-state", {
@@ -162,6 +174,8 @@ export class GhostteaTerminalRuntime extends EventTarget {
                 this.#resync.complete(data.sessionHandle);
             }
             else if (data.type === "frame-committed") {
+                if (this.#routedHost?.getSession)
+                    this.#scheduleMetadataRefresh(data.sessionHandle);
                 this.#recordCommittedFrame(data.sessionHandle, data.fullSnapshot);
             }
             else if (data.type === "catalog-pressure") {
@@ -282,22 +296,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
         this.#control = new ControlClient(ports.control);
         this.#control.addEventListener("session-exited", (event) => {
             const detail = event.detail;
-            const handle = this.#handleBySessionId.get(detail.sessionId);
-            const session = handle ? this.#sessionByHandle.get(handle) : undefined;
-            if (!handle || !session)
-                return;
-            this.#cancelMetadataRefresh(handle);
-            const exited = {
-                ...session,
-                exited: true,
-                exitCode: detail.exitCode,
-                exitSignal: detail.exitSignal,
-                requestedTermination: detail.requestedTermination,
-                exitOutcome: detail.exitOutcome,
-            };
-            this.#sessionByHandle.set(handle, exited);
-            this.dispatchEvent(new CustomEvent("session-metadata", { detail: exited }));
-            this.dispatchEvent(new CustomEvent("session-exited", { detail }));
+            this.#applySessionExited(detail);
         });
         this.#control.addEventListener("events-lost", () => {
             // The daemon dropped events faster than this client drained them. Any
@@ -307,14 +306,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
         });
         this.#control.addEventListener("session-activity-changed", (event) => {
             const detail = event.detail;
-            const handle = this.#handleBySessionId.get(detail.sessionId);
-            const session = handle ? this.#sessionByHandle.get(handle) : undefined;
-            if (!handle || !session || session.exited)
-                return;
-            const updated = { ...session, activity: detail.activity };
-            this.#sessionByHandle.set(handle, updated);
-            this.dispatchEvent(new CustomEvent("session-activity", { detail }));
-            this.dispatchEvent(new CustomEvent("session-metadata", { detail: updated }));
+            this.#applySessionActivity(detail);
         });
         this.#control.addEventListener("control-changed", (event) => {
             const detail = event.detail;
@@ -464,54 +456,196 @@ export class GhostteaTerminalRuntime extends EventTarget {
         if (this.#frameFlowControlEnabled)
             this.#frames?.postMessage({ type: "frame-credit", bytes });
     }
+    #bumpSessionGeneration(sessionHandle) {
+        this.#sessionGeneration += 1;
+        this.#sessionGenerationByHandle.set(sessionHandle, this.#sessionGeneration);
+        return this.#sessionGeneration;
+    }
+    #applySessionExited(detail) {
+        const handle = this.#handleBySessionId.get(detail.sessionId);
+        const session = handle ? this.#sessionByHandle.get(handle) : undefined;
+        if (!handle || !session)
+            return;
+        this.#cancelMetadataRefresh(handle);
+        const exited = {
+            ...session,
+            exited: true,
+            exitCode: detail.exitCode,
+            exitSignal: detail.exitSignal,
+            requestedTermination: detail.requestedTermination,
+            exitOutcome: detail.exitOutcome,
+        };
+        this.#sessionByHandle.set(handle, exited);
+        this.#bumpSessionGeneration(handle);
+        this.dispatchEvent(new CustomEvent("session-metadata", { detail: exited }));
+        this.dispatchEvent(new CustomEvent("session-exited", { detail }));
+    }
+    #applySessionActivity(detail) {
+        const handle = this.#handleBySessionId.get(detail.sessionId);
+        const session = handle ? this.#sessionByHandle.get(handle) : undefined;
+        if (!handle || !session || session.exited)
+            return;
+        const updated = { ...session, activity: detail.activity };
+        this.#sessionByHandle.set(handle, updated);
+        this.#bumpSessionGeneration(handle);
+        this.dispatchEvent(new CustomEvent("session-activity", { detail }));
+        this.dispatchEvent(new CustomEvent("session-metadata", { detail: updated }));
+    }
+    #applyRoutedSessionSummary(sessionHandle, next, expectedGeneration) {
+        const previous = this.#sessionByHandle.get(sessionHandle);
+        if (!previous ||
+            previous.exited ||
+            previous.id !== next.id ||
+            next.handle !== sessionHandle ||
+            this.#handleBySessionId.get(next.id) !== sessionHandle ||
+            (expectedGeneration !== undefined && this.#sessionGenerationByHandle.get(sessionHandle) !== expectedGeneration)) {
+            return false;
+        }
+        this.#sessionByHandle.set(sessionHandle, next);
+        this.#bumpSessionGeneration(sessionHandle);
+        if (previous.title !== next.title ||
+            previous.cwd !== next.cwd ||
+            previous.exited !== next.exited ||
+            !sameSessionActivity(previous.activity, next.activity)) {
+            this.dispatchEvent(new CustomEvent("session-metadata", { detail: next }));
+        }
+        return true;
+    }
     #scheduleMetadataRefresh(sessionHandle) {
         const scheduledSession = this.#sessionByHandle.get(sessionHandle);
         if (!scheduledSession || scheduledSession.exited)
             return;
+        if (this.#routedHost?.getSession && this.#metadataRefreshes.has(sessionHandle)) {
+            this.#metadataRefreshPending.add(sessionHandle);
+            return;
+        }
         if (this.#metadataTimers.has(sessionHandle))
             return;
         const timer = window.setTimeout(() => {
             this.#metadataTimers.delete(sessionHandle);
             const session = this.#sessionByHandle.get(sessionHandle);
-            if (!session || session.exited || !this.#control)
+            if (!session || session.exited)
                 return;
-            void this.#control
-                .request({ type: "get-session", sessionId: session.id })
-                .then((response) => {
-                if (response.type !== "session")
-                    return;
-                const previous = this.#sessionByHandle.get(sessionHandle);
-                if (!previous || previous.id !== response.session.id || previous.exited)
-                    return;
-                this.#sessionByHandle.set(sessionHandle, response.session);
-                if (previous.title !== response.session.title ||
-                    previous.cwd !== response.session.cwd ||
-                    previous.exited !== response.session.exited ||
-                    !sameSessionActivity(previous.activity, response.session.activity)) {
-                    this.dispatchEvent(new CustomEvent("session-metadata", { detail: response.session }));
-                }
-            })
-                .catch((error) => {
-                const current = this.#sessionByHandle.get(sessionHandle);
-                if (!current || current.exited || this.#disposed)
-                    return;
-                console.warn("[terminal-runtime] session metadata refresh failed", error);
-            });
+            if (this.#control) {
+                void this.#control
+                    .request({ type: "get-session", sessionId: session.id })
+                    .then((response) => {
+                    if (response.type !== "session")
+                        return;
+                    const previous = this.#sessionByHandle.get(sessionHandle);
+                    if (!previous || previous.id !== response.session.id || previous.exited)
+                        return;
+                    this.#sessionByHandle.set(sessionHandle, response.session);
+                    if (previous.title !== response.session.title ||
+                        previous.cwd !== response.session.cwd ||
+                        previous.exited !== response.session.exited ||
+                        !sameSessionActivity(previous.activity, response.session.activity)) {
+                        this.dispatchEvent(new CustomEvent("session-metadata", { detail: response.session }));
+                    }
+                })
+                    .catch((error) => {
+                    const current = this.#sessionByHandle.get(sessionHandle);
+                    if (!current || current.exited || this.#disposed)
+                        return;
+                    console.warn("[terminal-runtime] session metadata refresh failed", error);
+                });
+                return;
+            }
+            if (this.#routedHost?.getSession)
+                this.#startRoutedMetadataRefresh(sessionHandle, session);
         }, 200);
         this.#metadataTimers.set(sessionHandle, timer);
     }
+    #startRoutedMetadataRefresh(sessionHandle, session) {
+        const host = this.#routedHost;
+        const getSession = host?.getSession;
+        if (!host || !getSession || this.#disposed)
+            return;
+        if (this.#metadataRefreshes.has(sessionHandle)) {
+            this.#metadataRefreshPending.add(sessionHandle);
+            return;
+        }
+        const expectedGeneration = this.#sessionGenerationByHandle.get(sessionHandle);
+        const refresh = Promise.resolve()
+            .then(() => getSession.call(host, session.id))
+            .then((next) => {
+            if (next === null)
+                return;
+            this.#applyRoutedSessionSummary(sessionHandle, next, expectedGeneration);
+        })
+            .catch((error) => {
+            const current = this.#sessionByHandle.get(sessionHandle);
+            if (!current || current.exited || this.#disposed)
+                return;
+            console.warn("[terminal-runtime] session metadata refresh failed", error);
+        })
+            .finally(() => {
+            if (this.#metadataRefreshes.get(sessionHandle) !== refresh)
+                return;
+            this.#metadataRefreshes.delete(sessionHandle);
+            if (!this.#metadataRefreshPending.delete(sessionHandle) || this.#disposed)
+                return;
+            const current = this.#sessionByHandle.get(sessionHandle);
+            if (current && !current.exited)
+                this.#scheduleMetadataRefresh(sessionHandle);
+        });
+        this.#metadataRefreshes.set(sessionHandle, refresh);
+    }
     #cancelMetadataRefresh(sessionHandle) {
         const timer = this.#metadataTimers.get(sessionHandle);
         if (timer !== undefined)
             window.clearTimeout(timer);
         this.#metadataTimers.delete(sessionHandle);
+        this.#metadataRefreshPending.delete(sessionHandle);
     }
     sessionMetadata(sessionHandle) {
         return this.#sessionByHandle.get(sessionHandle);
     }
     registerSession(session) {
+        const previous = this.#sessionByHandle.get(session.handle);
+        if (!previous || previous.id !== session.id || !previous.exited || !session.exited) {
+            this.#appliedRoutedExitEvents.delete(session.handle);
+        }
         this.#sessionByHandle.set(session.handle, session);
         this.#handleBySessionId.set(session.id, session.handle);
+        this.#bumpSessionGeneration(session.handle);
+    }
+    applySessionEvent(event) {
+        if (this.#disposed)
+            return;
+        if (event.type === "updated") {
+            const handle = this.#handleBySessionId.get(event.session.id);
+            if (handle)
+                this.#applyRoutedSessionSummary(handle, event.session);
+            return;
+        }
+        if (event.type === "activity-changed") {
+            this.#applySessionActivity({
+                requestId: 0,
+                type: "session-activity-changed",
+                sessionId: event.sessionId,
+                activity: event.activity,
+            });
+            return;
+        }
+        if (event.type === "exited") {
+            const handle = this.#handleBySessionId.get(event.sessionId);
+            const current = handle ? this.#sessionByHandle.get(handle) : undefined;
+            if (!handle || !current || this.#appliedRoutedExitEvents.has(handle))
+                return;
+            this.#appliedRoutedExitEvents.add(handle);
+            this.#applySessionExited({
+                requestId: 0,
+                type: "session-exited",
+                sessionId: event.sessionId,
+                exitCode: event.exitCode,
+                exitSignal: event.exitSignal,
+                requestedTermination: event.requestedTermination,
+                exitOutcome: event.exitOutcome,
+            });
+            return;
+        }
+        this.unregisterSession(event.sessionId);
     }
     #queueFrameSubscriptionSync() {
         const frames = this.#frames;
@@ -1186,6 +1320,18 @@ export class GhostteaTerminalRuntime extends EventTarget {
     #handleRoutedControlEvent(event) {
         if (this.#disposed)
             return;
+        if (event.type === "extension-message") {
+            const host = this.#routedHost;
+            if (!host?.onExtensionMessage)
+                return;
+            try {
+                host.onExtensionMessage(event.message, event.context);
+            }
+            catch (error) {
+                console.error("[terminal-runtime] routed extension handler failed", error);
+            }
+            return;
+        }
         if (event.type === "transport-ready") {
             const deadline = event.accepted.protocolLimits.activationAttachDeadlineMs;
             this.#routedAttachDeadlineByCell.set(event.cellBootId, deadline);
@@ -1664,6 +1810,29 @@ export class GhostteaTerminalRuntime extends EventTarget {
         this.#routedByActivation.delete(entry.state.activationId);
         this.#routedGeometry.delete(sessionId);
     }
+    /**
+     * Detach one of our views and let the seat go with it.
+     *
+     * The daemon clears the resize controller when its holder detaches, but a
+     * local session announces control only through the legacy `control-changed`
+     * frame, which cannot say "no controller": the clear never reaches this
+     * client, and a pane that remounts (a split re-parents its surface) would
+     * see its own previous incarnation on the record forever and never claim.
+     * Our own detach is the one clear this client can predict, so the record is
+     * cleared here at the same revision and the session's remaining views get
+     * their one look at the empty seat (§4.2.3).
+     */
+    #detachView(sessionId, viewId) {
+        this.#control?.notify({ type: "detach-session", sessionId, viewId });
+        const control = this.#controlBySession.get(sessionId);
+        if (!control?.controller || control.controller.viewId !== viewId)
+            return;
+        this.#controlBySession.set(sessionId, { controller: null, revision: control.revision });
+        for (const other of this.#viewIdsForSession(sessionId)) {
+            if (other !== viewId)
+                this.#maybeReclaim(other);
+        }
+    }
     #createMountLease(mounted) {
         let disposed = false;
         return {
@@ -1689,7 +1858,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
                         if (this.#routedHost)
                             this.#releaseRoutedView(mounted.sessionId, mounted.viewId);
                         else
-                            this.#control?.notify({ type: "detach-session", sessionId: mounted.sessionId, viewId: mounted.viewId });
+                            this.#detachView(mounted.sessionId, mounted.viewId);
                         this.#views.delete(mounted.viewId);
                         this.#focusByView.delete(mounted.viewId);
                     }
@@ -2129,6 +2298,16 @@ export class GhostteaTerminalRuntime extends EventTarget {
     setEffects(sessionHandle, effects, surfaceId) {
         this.#postWorker({ type: "effects", sessionHandle, ...(surfaceId ? { surfaceId } : {}), effects });
     }
+    links(sessionHandle) {
+        return this.#platform.openExternal
+            ? (this.#linksByHandle.get(sessionHandle) ?? []).filter((link) => link.explicit || this.#configSnapshot?.renderer.linkUrl !== false)
+            : [];
+    }
+    async openLink(uri) {
+        const url = terminalLinkUrl(uri);
+        if (url)
+            await this.#platform.openExternal?.(url);
+    }
     setSelection(sessionHandle, selection, surfaceId) {
         this.#postWorker({ type: "selection", sessionHandle, ...(surfaceId ? { surfaceId } : {}), selection });
     }
@@ -2229,9 +2408,12 @@ export class GhostteaTerminalRuntime extends EventTarget {
             }
             return;
         }
-        // The legacy protocol has no release verb. Clearing the local epoch still
-        // closes every resize path immediately; a later explicit claim can renew it.
-        view.controlEpoch = undefined;
+        // The legacy protocol has no release verb, so the daemon keeps this view
+        // seated. Dropping the request is what closes every resize path; the epoch
+        // stays, because it is still the seat's truth and a later explicit claim
+        // resumes on it. Clearing it here would leave the view with the record in
+        // its own name and no epoch: the funnel's one-claim-per-attachment guard
+        // refuses that claim, and a pane hidden by a zoom never resizes again.
     }
     setViewInputPolicy(viewId, readWrite) {
         const view = this.#views.get(viewId);
@@ -2340,6 +2522,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
         this.#sessionMountReferences.delete(handle);
         const subscriptionChanged = this.#subscribedSessionHandles.delete(handle);
         this.#cancelMetadataRefresh(handle);
+        this.#linksByHandle.delete(handle);
         this.#mouseTrackingByHandle.delete(handle);
         this.#scrollbarByHandle.delete(handle);
         for (const mounted of [...this.#mountedEntries]) {
@@ -2354,7 +2537,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
                 this.#postWorker({ type: "unmount", surfaceId: mounted.viewId });
                 this.#mountGenerationBySurface.delete(mounted.viewId);
                 if (detachViews)
-                    this.#control?.notify({ type: "detach-session", sessionId: mounted.sessionId, viewId: mounted.viewId });
+                    this.#detachView(mounted.sessionId, mounted.viewId);
                 this.#views.delete(mounted.viewId);
                 this.#focusByView.delete(mounted.viewId);
             }
@@ -2365,12 +2548,14 @@ export class GhostteaTerminalRuntime extends EventTarget {
             if (view.sessionId === sessionId) {
                 view.pendingInput.length = 0;
                 if (detachViews)
-                    this.#control?.notify({ type: "detach-session", sessionId, viewId });
+                    this.#detachView(sessionId, viewId);
                 this.#views.delete(viewId);
                 this.#focusByView.delete(viewId);
             }
         }
         this.#sessionByHandle.delete(handle);
+        this.#sessionGenerationByHandle.delete(handle);
+        this.#appliedRoutedExitEvents.delete(handle);
         this.#handleBySessionId.delete(sessionId);
         this.#remoteSessions.delete(sessionId);
         this.#controlBySession.delete(sessionId);
@@ -2452,6 +2637,10 @@ export class GhostteaTerminalRuntime extends EventTarget {
         for (const timer of this.#metadataTimers.values())
             window.clearTimeout(timer);
         this.#metadataTimers.clear();
+        this.#metadataRefreshPending.clear();
+        this.#metadataRefreshes.clear();
+        this.#sessionGenerationByHandle.clear();
+        this.#appliedRoutedExitEvents.clear();
         this.#resync.dispose();
         for (const request of this.#performanceRequests.values()) {
             window.clearTimeout(request.timer);
@@ -2469,6 +2658,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
         this.#recoveredSessions.clear();
         this.#focusByView.clear();
         this.#mountGenerationBySurface.clear();
+        this.#linksByHandle.clear();
         this.#mouseTrackingByHandle.clear();
         this.#scrollbarByHandle.clear();
         this.#subscribedSessionHandles.clear();