tmux-ide 2.9.5 → 2.9.6

package/packages/daemon/dist/terminal/session-runtime/transport-binding.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { TerminalAttachmentSemanticPaneIdSchemaZ, SessionRuntimeSemanticIntentSchemaZ, } from "@tmux-ide/contracts";
+import { WorkspaceIdSchemaZ, TerminalAttachmentSemanticPaneIdSchemaZ, SessionRuntimeSemanticIntentSchemaZ, } from "@tmux-ide/contracts";
 import { SessionRuntimeControllerLeaseError } from "./registry.js";
 const TransportSchemaZ = z.enum(["terminal-attachment", "pane-stream"]);
 const LeaseIdSchemaZ = z.uuid();
@@ -200,12 +200,13 @@ export class SessionRuntimeTransportBinding {
             throw new SessionRuntimeControllerLeaseError("stale-controller-lease", "The interactive transport does not own input authority.");
         this.#binder.registry.assertExecutionHandle(this.#baseHandle, semanticPaneId);
     }
-    openTerminalDelivery(semanticPaneId, offer, onMessage) {
+    openTerminalDelivery(semanticPaneId, offer, onMessage, deliveryWorkspaceName) {
+        const address = WorkspaceIdSchemaZ.parse(deliveryWorkspaceName ?? this.session);
         this.#assertOpen();
         if (!this.#allowedSourcePaneIds.has(semanticPaneId)) {
             throw new SessionRuntimeControllerLeaseError("invalid-source-pane-binding", "The pane is not in the transport's live grant.");
         }
-        return this.#shared.consumer.openTerminalDelivery(this.#deliverySubscriberId, this.#diagnosticRequestId, semanticPaneId, offer, onMessage);
+        return this.#shared.consumer.openTerminalDelivery(this.#deliverySubscriberId, this.#diagnosticRequestId, semanticPaneId, offer, onMessage, address);
     }
     submitIntent(operationId, intentInput) {
         this.#assertOpen();
@@ -215,18 +216,24 @@ export class SessionRuntimeTransportBinding {
         if (!this.#shared.lease) {
             throw new SessionRuntimeControllerLeaseError("stale-controller-lease", "The transport no longer owns controller authority.");
         }
+        const geometryFence = intent.verb === "workspace.pane.resize" || intent.verb === "workspace.window.split.resize"
+            ? this.#captureResizeGeometryFence()
+            : undefined;
         const scopeKey = paneId ?? "session";
-        let handle = this.#intentHandles.get(scopeKey);
+        // Geometry authority is operation-specific; never reuse an input-only handle.
+        let handle = geometryFence ? undefined : this.#intentHandles.get(scopeKey);
         if (!handle) {
             const lease = this.#shared.lease;
             handle = this.#binder.registry.createExecutionHandle(this.#shared.consumer, lease, [...this.#allowedSourcePaneIds], () => {
                 this.#assertIntentScopeOpen();
+                geometryFence?.();
                 assertLiveScope(this.#shared, lease, paneId);
                 if (paneId !== undefined && !this.#allowedSourcePaneIds.has(paneId)) {
                     throw new SessionRuntimeControllerLeaseError("invalid-source-pane-binding", "The pane is outside this transport binding's live grant.");
                 }
-            });
-            this.#intentHandles.set(scopeKey, handle);
+            }, geometryFence);
+            if (!geometryFence)
+                this.#intentHandles.set(scopeKey, handle);
         }
         // Existing viewer transport protocol acknowledges reads without returning contents.
         // Private snapshots are available only through the dedicated automation boundary.
@@ -238,6 +245,29 @@ export class SessionRuntimeTransportBinding {
             return result;
         });
     }
+    #captureResizeGeometryFence() {
+        const assertTransport = () => {
+            this.#assertOpen();
+            if (this.#shared.geometryTransportLeaseIds.at(-1) !== this.#transportLeaseId)
+                throw new SessionRuntimeControllerLeaseError("invalid-client-capability", "The transport does not own the live geometry lease.");
+        };
+        assertTransport();
+        const lease = this.#explicitAuthority
+            ? this.#geometryAuthorityLease
+            : this.requestAuthority("geometry");
+        if (!lease)
+            throw new SessionRuntimeControllerLeaseError("stale-controller-lease", "Geometry authority retired.");
+        const captured = Object.freeze({ ...lease });
+        const authorize = () => {
+            assertTransport();
+            if (!this.#geometryAuthorityLease ||
+                !sameAuthorityLease(captured, this.#geometryAuthorityLease))
+                throw new SessionRuntimeControllerLeaseError("stale-controller-lease", "Geometry authority retired.");
+            this.#shared.consumer.assertGeometryAuthority(captured);
+        };
+        authorize();
+        return authorize;
+    }
     sendInput(semanticPaneId, input, performanceTraceId, causalProbe, onCausalResult) {
         this.assertController(semanticPaneId);
         const lease = this.#shared.lease;

package/packages/daemon/dist/tui/mirror/runtime/application-daemon-authority-owner.js

@@ -1,329 +1,8 @@
-import { createRuntimeConnectionSupervisor, } from "@tmux-ide/daemon-client/connection-supervisor";
-import { fleetReconnectBackoff, } from "@tmux-ide/daemon-client/fleet-dial-scheduler";
-import { watch } from "node:fs";
-import { basename, dirname } from "node:path";
-import { getCanonicalDaemonInfoPath, isCanonicalDaemonAlive, readCanonicalDaemonInfo, } from "../../../lib/canonical-daemon.js";
-import { SshConnectionError, openSshDaemonTransport, probeSshDaemonIdentity, } from "../../../lib/ssh-daemon-transport.js";
+/** TUI telemetry adapter; transport ownership is shared with native clients. */
+import { createDaemonConnectionOwner, } from "../../../lib/daemon-connection-owner.js";
 import { tuiPerfMark } from "./application-performance-log.js";
-const defaults = {
-    readLocal: readCanonicalDaemonInfo,
-    isLocalAlive: isCanonicalDaemonAlive,
-    async observeLocal(listener) {
-        const path = getCanonicalDaemonInfoPath();
-        let stopped = false;
-        let queued = false;
-        const watcher = watch(dirname(path), (_event, file) => {
-            if (stopped || queued || (file !== null && file.toString() !== basename(path)))
-                return;
-            queued = true;
-            queueMicrotask(() => {
-                queued = false;
-                const generation = readCanonicalDaemonInfo()?.instanceId;
-                if (!stopped && generation)
-                    listener(generation);
-            });
-        });
-        watcher.on("error", () => watcher.close());
-        return () => {
-            stopped = true;
-            watcher.close();
-        };
-    },
-    connect: openSshDaemonTransport,
-    verify: probeSshDaemonIdentity,
-};
-function monitorConnection(connection, dependencies, onLost) {
-    const verify = dependencies.verify;
-    if (!verify)
-        return () => { };
-    let stopped = false;
-    let failures = 0;
-    let active = null;
-    let timer = null;
-    const check = async () => {
-        if (stopped)
-            return;
-        const attempt = new AbortController();
-        active = attempt;
-        const deadline = setTimeout(() => attempt.abort(), dependencies.probeTimeoutMs ?? 1500);
-        let valid = false;
-        try {
-            // fetch cancellation bounds response reading as well as establishing the socket.
-            valid = await verify(connection.baseUrl, connection.daemon, attempt.signal);
-        }
-        catch {
-            /* A transient network failure gets one further probe before retirement. */
-        }
-        finally {
-            clearTimeout(deadline);
-            active = null;
-        }
-        if (stopped)
-            return;
-        failures = valid && !attempt.signal.aborted ? 0 : failures + 1;
-        if (failures >= 2) {
-            stopped = true;
-            onLost();
-            return;
-        }
-        timer = setTimeout(() => void check(), dependencies.probeIntervalMs ?? 2000);
-    };
-    timer = setTimeout(() => void check(), dependencies.probeIntervalMs ?? 2000);
-    return () => {
-        stopped = true;
-        if (timer !== null)
-            clearTimeout(timer);
-        active?.abort();
-    };
-}
-/** Owns one machine's authority and its single initial/reconnect lifecycle. */
-export function createApplicationDaemonAuthority(dependencies = defaults) {
-    let kind = "local";
-    let label = null;
-    let state = "ready";
-    let epoch = 0;
-    let connection = null;
-    let descriptor = null;
-    let remote = null;
-    let supervisor = null;
-    let stopped = false;
-    let paused = false;
-    let controlRevision = 0;
-    let diagnostic = {
-        phase: "ready",
-        attempt: 0,
-        nextRetryAt: null,
-        failure: null,
-    };
-    const statusListeners = new Set();
-    const updateStatus = (next) => {
-        diagnostic = Object.freeze(next);
-        tuiPerfMark("machine-connection-status", {
-            machine: label,
-            ...next,
-            instanceId: remote?.instanceId ?? null,
-            pid: remote?.pid ?? null,
-            port: remote?.port ?? null,
-        });
-        for (const listener of statusListeners) {
-            try {
-                listener();
-            }
-            catch {
-                /* UI observers do not own transport lifetime. */
-            }
-        }
-    };
-    let removeParentAbort = null;
-    let rejectInitial = null;
-    const listeners = new Set();
-    const notify = (generation) => {
-        for (const listener of listeners) {
-            try {
-                listener(generation);
-            }
-            catch {
-                /* Observers do not own transport lifetime. */
-            }
-        }
-    };
-    let releaseConnection = null;
-    const retire = () => {
-        const release = releaseConnection;
-        releaseConnection = null;
-        connection = null;
-        descriptor = null;
-        remote = null;
-        state = "disconnected";
-        epoch++;
-        notify(null);
-        release?.();
-    };
-    const dispose = () => {
-        if (stopped)
-            return;
-        stopped = true;
-        controlRevision++;
-        removeParentAbort?.();
-        removeParentAbort = null;
-        rejectInitial?.(new Error("SSH connection cancelled"));
-        rejectInitial = null;
-        if (kind === "ssh")
-            retire();
-        void supervisor?.stop();
-        updateStatus({ phase: "disconnected", attempt: 0, nextRetryAt: null, failure: null });
-        statusListeners.clear();
-    };
-    return {
-        read() {
-            return kind === "local" ? dependencies.readLocal() : descriptor;
-        },
-        async isAlive(info) {
-            if (kind === "local")
-                return dependencies.isLocalAlive(info);
-            return (state === "ready" &&
-                descriptor !== null &&
-                info.instanceId === descriptor.instanceId &&
-                info.startedAt === descriptor.startedAt &&
-                info.port === descriptor.port &&
-                info.bindHostname === descriptor.bindHostname);
-        },
-        endpoint() {
-            return Object.freeze({
-                kind,
-                label,
-                remote,
-                localBaseUrl: connection?.baseUrl ?? null,
-                epoch,
-                state,
-                diagnostic,
-            });
-        },
-        async observe(listener) {
-            if (kind === "local")
-                return dependencies.observeLocal(listener);
-            listeners.add(listener);
-            return () => {
-                listeners.delete(listener);
-            };
-        },
-        observeConnection(listener) {
-            statusListeners.add(listener);
-            return () => {
-                statusListeners.delete(listener);
-            };
-        },
-        disconnect() {
-            if (kind !== "ssh" || stopped)
-                return;
-            paused = true;
-            controlRevision++;
-            rejectInitial?.(new Error("SSH connection cancelled"));
-            rejectInitial = null;
-            retire();
-            void supervisor?.stop();
-            updateStatus({ phase: "disconnected", attempt: 0, nextRetryAt: null, failure: null });
-        },
-        async retry() {
-            if (kind !== "ssh" || stopped || !supervisor)
-                return;
-            const revision = ++controlRevision;
-            paused = true;
-            retire();
-            await supervisor.stop();
-            if (stopped || revision !== controlRevision)
-                return;
-            paused = false;
-            supervisor.start();
-        },
-        async initialize(alias, parentSignal, options = {}) {
-            if (kind !== "local" || stopped)
-                throw new Error("Application machine authority is already selected");
-            kind = "ssh";
-            label = alias;
-            state = "connecting";
-            epoch++;
-            const initial = new Promise((resolve, reject) => {
-                rejectInitial = reject;
-                supervisor = createRuntimeConnectionSupervisor({
-                    retryable: (error) => !(error instanceof SshConnectionError) || error.retryable,
-                    backoffMs: (attempt) => {
-                        const delay = dependencies.retryDelayMs ?? options.retryDelayMs ?? fleetReconnectBackoff(attempt);
-                        if (!stopped && !paused)
-                            updateStatus({
-                                ...diagnostic,
-                                phase: "reconnecting",
-                                attempt,
-                                nextRetryAt: Date.now() + delay,
-                            });
-                        return delay;
-                    },
-                    connect: async ({ signal, attempt }) => {
-                        if (stopped || paused || signal.aborted)
-                            throw new Error("SSH connection cancelled");
-                        state = "connecting";
-                        updateStatus({ phase: "connecting", attempt, nextRetryAt: null, failure: null });
-                        let next;
-                        try {
-                            const connect = () => dependencies.connect({ alias, signal });
-                            next = options.scheduler
-                                ? await options.scheduler.run(alias, signal, connect, (late) => late.dispose())
-                                : await connect();
-                            if (options.expectedEnvironmentId &&
-                                next.daemon.environmentId !== options.expectedEnvironmentId) {
-                                next.dispose();
-                                throw new SshConnectionError("Imported environment identity does not match the authenticated daemon", "identity-mismatch");
-                            }
-                        }
-                        catch (error) {
-                            if (!stopped && !paused) {
-                                state = "disconnected";
-                                updateStatus({
-                                    phase: error instanceof SshConnectionError && !error.retryable
-                                        ? "needs-attention"
-                                        : "reconnecting",
-                                    attempt,
-                                    nextRetryAt: null,
-                                    failure: error instanceof SshConnectionError ? error.code : "unavailable",
-                                });
-                            }
-                            rejectInitial?.(error);
-                            rejectInitial = null;
-                            throw error;
-                        }
-                        if (stopped || paused || signal.aborted) {
-                            next.dispose();
-                            throw new Error("SSH connection cancelled");
-                        }
-                        const endpoint = new URL(next.baseUrl);
-                        remote = Object.freeze({ ...next.daemon });
-                        descriptor = Object.freeze({
-                            ...next.daemon,
-                            bindHostname: "127.0.0.1",
-                            port: Number(endpoint.port),
-                        });
-                        connection = next;
-                        state = "ready";
-                        epoch++;
-                        let close;
-                        const closed = new Promise((done) => {
-                            close = done;
-                        });
-                        let released = false;
-                        let stopMonitor = null;
-                        const release = () => {
-                            if (released)
-                                return;
-                            released = true;
-                            stopMonitor?.();
-                            next.dispose();
-                            close();
-                        };
-                        const lost = () => {
-                            if (!released && connection === next)
-                                retire();
-                        };
-                        releaseConnection = release;
-                        void next.closed.then(lost, lost);
-                        stopMonitor = monitorConnection(next, dependencies, lost);
-                        notify(descriptor.instanceId);
-                        if (!stopped && !paused)
-                            updateStatus({ phase: "ready", attempt: 0, nextRetryAt: null, failure: null });
-                        rejectInitial = null;
-                        resolve();
-                        return { value: next, closed, dispose: release };
-                    },
-                });
-            });
-            const abort = () => dispose();
-            parentSignal?.addEventListener("abort", abort, { once: true });
-            removeParentAbort = () => parentSignal?.removeEventListener("abort", abort);
-            if (parentSignal?.aborted)
-                abort();
-            if (!stopped)
-                supervisor.start();
-            return initial;
-        },
-        dispose,
-    };
+export function createApplicationDaemonAuthority(dependencies) {
+    return createDaemonConnectionOwner(dependencies, (status) => {
+        tuiPerfMark("machine-connection-status", { ...status });
+    });
 }