tmux-ide 2.9.12 → 2.9.13

package/packages/daemon/dist/terminal/graphics/native-surface-provider.js

@@ -0,0 +1,275 @@
+import { NativeSurfaceDemand } from "./native-surface-demand.js";
+import { SessionRuntimeGenerationSchemaZ, TerminalSurfaceAuditTokenSchemaZ, TerminalSurfaceOfferSchemaZ, TerminalSurfaceReceiverSchemaZ, TERMINAL_SURFACE_MAX_BYTES, TERMINAL_SURFACE_MAX_OUTSTANDING, TERMINAL_SURFACE_MAX_CONTROL_BYTES, } from "@tmux-ide/contracts";
+/** Internal daemon registration only. Never construct a provider from terminal
+ * content, request-supplied paths, a PID lookup or a loopback address. The native
+ * owner must be authenticated before registration; kernel proof still follows. */
+export class NativeSurfaceProviderRegistry {
+    demand = new NativeSurfaceDemand();
+    generation;
+    #registration = null;
+    #sessions = new Set();
+    #bytes = 0;
+    #frames = 0;
+    #revision = 0;
+    #closed = false;
+    #watchers = new Set();
+    #notificationQueued = false;
+    constructor(generation) {
+        this.generation = SessionRuntimeGenerationSchemaZ.parse(generation);
+    }
+    get revision() {
+        return this.#revision;
+    }
+    get available() {
+        return this.#registration !== null;
+    }
+    watchAvailability(listener) {
+        if (this.#closed || this.#watchers.size >= 256)
+            throw new Error("Native surface availability subscription unavailable");
+        this.#watchers.add(listener);
+        this.#notifyAvailability();
+        return () => this.#watchers.delete(listener);
+    }
+    #notifyAvailability() {
+        if (this.#notificationQueued)
+            return;
+        this.#notificationQueued = true;
+        // Provider registration must finish before a viewer can open its channel.
+        queueMicrotask(() => {
+            this.#notificationQueued = false;
+            for (const listener of [...this.#watchers]) {
+                if (!this.#watchers.has(listener))
+                    continue;
+                try {
+                    listener(this.available);
+                }
+                catch {
+                    this.#watchers.delete(listener);
+                }
+            }
+            if (this.#closed)
+                this.#watchers.clear();
+        });
+    }
+    register(provider) {
+        if (this.#closed)
+            throw new Error("Native surface registry closed");
+        if (this.#registration)
+            throw new Error("Native surface provider already registered");
+        const registration = {
+            provider,
+            auditToken: TerminalSurfaceAuditTokenSchemaZ.parse(provider.auditToken),
+            sessions: new Set(),
+        };
+        this.#registration = registration;
+        this.#revision++;
+        this.#notifyAvailability();
+        return () => {
+            if (this.#registration !== registration)
+                return;
+            this.#registration = null;
+            this.#revision++;
+            // Existing original sockets may still ACK retained GPU storage. Replacing
+            // a provider never redirects those ACKs to the replacement process.
+            for (const session of registration.sessions)
+                session.fallback("unsupported");
+            this.#notifyAvailability();
+        };
+    }
+    open(receiver, panes, send, deliveryNonce) {
+        receiver = TerminalSurfaceReceiverSchemaZ.parse(receiver);
+        const registration = this.#registration;
+        if (!registration || receiver.generation !== this.generation || this.#sessions.size >= 32)
+            return null;
+        const session = new Session(receiver, panes, registration, send, deliveryNonce, (bytes) => {
+            if (this.#frames >= 32 || this.#bytes + bytes > 256 * 1024 * 1024)
+                return false;
+            this.#frames++;
+            this.#bytes += bytes;
+            return true;
+        }, (bytes) => {
+            this.#frames--;
+            this.#bytes -= bytes;
+        }, () => {
+            registration.sessions.delete(session);
+            this.#sessions.delete(session);
+        });
+        registration.sessions.add(session);
+        this.#sessions.add(session);
+        session.start();
+        return session;
+    }
+    close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        this.demand.close();
+        this.#registration = null;
+        this.#revision++;
+        for (const session of [...this.#sessions])
+            session.close();
+        this.#notifyAvailability();
+    }
+}
+class Session {
+    receiver;
+    registration;
+    send;
+    deliveryNonce;
+    reserve;
+    release;
+    disposed;
+    #producer = null;
+    #outstanding = new Map();
+    #bytes = 0;
+    #lastSequence = 0;
+    #stopped = false;
+    #closed = false;
+    #panes;
+    constructor(receiver, panes, registration, send, deliveryNonce, reserve, release, disposed) {
+        this.receiver = receiver;
+        this.registration = registration;
+        this.send = send;
+        this.deliveryNonce = deliveryNonce;
+        this.reserve = reserve;
+        this.release = release;
+        this.disposed = disposed;
+        this.#panes = new Set(panes);
+    }
+    get outstanding() {
+        return this.#outstanding.size;
+    }
+    start() {
+        try {
+            const producer = this.registration.provider.open({
+                receiver: structuredClone(this.receiver),
+                panes: [...this.#panes],
+                offer: (value) => this.#offer(value),
+            });
+            if (this.#stopped || this.#closed) {
+                try {
+                    producer.close();
+                }
+                catch {
+                    /* Registration already revoked this connection. */
+                }
+                this.close();
+                return;
+            }
+            this.#producer = producer;
+            if (!this.#send({
+                type: "terminal-surface-peer",
+                version: 1,
+                generation: this.receiver.generation,
+                connectionNonce: this.receiver.connectionNonce,
+                auditToken: [...this.registration.auditToken],
+            })) {
+                this.close();
+                return;
+            }
+            if (!this.#stopped && !this.#closed)
+                this.#producer?.start();
+        }
+        catch {
+            this.fallback("storage");
+        }
+    }
+    #offer(value) {
+        if (this.#closed || this.#stopped || !this.#producer)
+            return false;
+        const parsed = TerminalSurfaceOfferSchemaZ.safeParse(value);
+        if (!parsed.success)
+            return false;
+        let offer = parsed.data;
+        // A producer's own read-only subscription has a different delivery nonce.
+        // Only the daemon owning the target viewer may bind that nonce. Preserve
+        // canonical revision/hash/incarnation exactly; the receiver verifies them.
+        if (this.deliveryNonce) {
+            const nonce = this.deliveryNonce(offer.pane, offer.generation);
+            if (!nonce)
+                return false;
+            const rebound = TerminalSurfaceOfferSchemaZ.safeParse({ ...offer, deliveryNonce: nonce });
+            if (!rebound.success)
+                return false;
+            offer = rebound.data;
+        }
+        if (offer.generation !== this.receiver.generation ||
+            !this.#panes.has(offer.pane) ||
+            offer.sequence <= this.#lastSequence ||
+            this.#outstanding.size >= TERMINAL_SURFACE_MAX_OUTSTANDING ||
+            this.#bytes + offer.allocationBytes > TERMINAL_SURFACE_MAX_BYTES ||
+            Buffer.byteLength(JSON.stringify(offer)) > TERMINAL_SURFACE_MAX_CONTROL_BYTES ||
+            !this.reserve(offer.allocationBytes))
+            return false;
+        this.#lastSequence = offer.sequence;
+        this.#outstanding.set(offer.sequence, offer.allocationBytes);
+        this.#bytes += offer.allocationBytes;
+        if (this.#send(offer))
+            return !this.#closed && !this.#stopped;
+        this.close();
+        return false;
+    }
+    retire(sequence) {
+        const bytes = this.#outstanding.get(sequence);
+        if (this.#closed || bytes === undefined)
+            return false;
+        this.#outstanding.delete(sequence);
+        this.#bytes -= bytes;
+        this.release(bytes);
+        try {
+            this.#producer?.retire(sequence);
+        }
+        catch {
+            this.fallback("storage");
+        }
+        return true;
+    }
+    fallback(reason) {
+        if (this.#closed || this.#stopped)
+            return;
+        this.#stopped = true;
+        try {
+            this.#producer?.fallback();
+        }
+        catch {
+            /* Native owner cannot authorize new transfers. */
+        }
+        if (!this.#send({
+            type: "terminal-surface-fallback",
+            version: 1,
+            generation: this.receiver.generation,
+            connectionNonce: this.receiver.connectionNonce,
+            reason,
+        }))
+            this.close();
+    }
+    close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        // Closing releases accounting/reference ownership, never grants buffer reuse.
+        // Native receivers retain their own backing/GPU leases after this connection.
+        for (const bytes of this.#outstanding.values())
+            this.release(bytes);
+        this.#outstanding.clear();
+        this.#bytes = 0;
+        try {
+            this.#producer?.close();
+        }
+        catch {
+            /* All daemon-side admissions remain revoked. */
+        }
+        finally {
+            this.#producer = null;
+            this.disposed();
+        }
+    }
+    #send(frame) {
+        try {
+            return this.send(frame);
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/packages/daemon/dist/terminal/graphics/native-surface-viewer.js

@@ -0,0 +1,146 @@
+import { randomUUID } from "node:crypto";
+const MAX_RETAINED = 8;
+/** One terminal socket owns every negotiation and its remaining GPU retirements. */
+export class NativeSurfaceViewer {
+    registry;
+    panes;
+    send;
+    deliveryNonce;
+    #stop = null;
+    #closed = false;
+    #revision = -1;
+    #nonce = null;
+    #used = false;
+    #active = null;
+    #retained = new Map();
+    constructor(registry, panes, send, deliveryNonce) {
+        this.registry = registry;
+        this.panes = panes;
+        this.send = send;
+        this.deliveryNonce = deliveryNonce;
+    }
+    start() {
+        if (this.#closed || this.#stop)
+            return;
+        try {
+            this.#stop = this.registry.watchAvailability((available) => {
+                if (this.#closed || this.#revision === this.registry.revision)
+                    return;
+                this.#revision = this.registry.revision;
+                this.#active?.session.fallback("unsupported");
+                this.#active = null;
+                this.#prune();
+                this.#nonce = available ? randomUUID() : null;
+                this.#used = false;
+                this.#send({
+                    type: "terminal-surface-available",
+                    version: 1,
+                    generation: this.registry.generation,
+                    connectionNonce: this.#nonce,
+                });
+            });
+        }
+        catch {
+            this.#send({
+                type: "terminal-surface-available",
+                version: 1,
+                generation: this.registry.generation,
+                connectionNonce: null,
+            });
+            this.close();
+        }
+    }
+    receive(frame) {
+        if (this.#closed ||
+            frame.generation !== this.registry.generation ||
+            frame.connectionNonce !== this.#nonce)
+            return false;
+        const previous = this.#retained.get(frame.connectionNonce);
+        if (previous)
+            return JSON.stringify(previous.receiver) === JSON.stringify(frame);
+        if (this.#used)
+            return false;
+        this.#used = true;
+        this.#prune();
+        if (this.#retained.size >= MAX_RETAINED) {
+            this.#fallback(frame, "budget");
+            return true;
+        }
+        const session = this.registry.open(frame, this.panes, (control) => this.#send(control), this.deliveryNonce);
+        if (!session) {
+            this.#fallback(frame, "unsupported");
+            return true;
+        }
+        if (this.#closed) {
+            session.close();
+            return true;
+        }
+        const entry = { receiver: frame, session };
+        this.#retained.set(frame.connectionNonce, entry);
+        this.#active = entry;
+        return true;
+    }
+    retire(frame) {
+        if (this.#closed || frame.generation !== this.registry.generation)
+            return false;
+        const entry = this.#retained.get(frame.connectionNonce);
+        if (!entry?.session.retire(frame.sequence))
+            return false;
+        this.#prune();
+        return true;
+    }
+    fallback(frame) {
+        if (this.#closed || frame.generation !== this.registry.generation)
+            return false;
+        const entry = this.#retained.get(frame.connectionNonce);
+        if (!entry)
+            return this.#used && frame.connectionNonce === this.#nonce;
+        entry.session.fallback(frame.reason);
+        if (this.#active === entry)
+            this.#active = null;
+        this.#prune();
+        return true;
+    }
+    #fallback(receiver, reason) {
+        this.#send({
+            type: "terminal-surface-fallback",
+            version: 1,
+            generation: receiver.generation,
+            connectionNonce: receiver.connectionNonce,
+            reason,
+        });
+    }
+    #prune() {
+        for (const [nonce, entry] of this.#retained) {
+            if (entry !== this.#active && entry.session.outstanding === 0) {
+                entry.session.close();
+                this.#retained.delete(nonce);
+            }
+        }
+    }
+    #send(frame) {
+        if (this.#closed)
+            return false;
+        try {
+            if (this.send(frame))
+                return !this.#closed;
+        }
+        catch {
+            /* Revoke a failed sink. */
+        }
+        this.close();
+        return false;
+    }
+    close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        this.#stop?.();
+        this.#stop = null;
+        for (const entry of this.#retained.values())
+            entry.session.close();
+        this.#retained.clear();
+        this.#active = null;
+        this.#nonce = null;
+    }
+}

package/packages/daemon/dist/terminal/mirror/mirror-service.js

@@ -591,6 +591,9 @@ export class MirrorService {
                         }
                     },
                     onNativeClientActivity: () => this.opts.onNativeClientActivity?.(session),
+                    onNativeClientPresence: this.opts.onNativeClientPresence
+                        ? (present) => this.opts.onNativeClientPresence?.(session, present)
+                        : undefined,
                     captureInputWrite: (action, semanticPaneId) => this.opts.captureInputWrite?.(session, action, semanticPaneId),
                     onInputWrite: (action, startedAtMicros, endedAtMicros, pendingBeforeSend) => this.opts.onInputWrite?.(session, action, startedAtMicros, endedAtMicros, pendingBeforeSend),
                     onInputAccepted: (action, acceptedAtMicros, ok) => this.opts.onInputAccepted?.(session, action, acceptedAtMicros, ok),

package/packages/daemon/dist/terminal/mirror/session-channel.js

@@ -184,6 +184,8 @@ export class SessionChannel {
     disposed = false;
     nativeGrid;
     nativeClientProbePending = false;
+    nativeClientProbeDirty = false;
+    nativeClientProbeClosed = false;
     // Native captures fence every geometry event; inventory fences identity only.
     windowAuthorityOrdinal = 0;
     layoutNotificationOrdinals = new Map();
@@ -367,7 +369,7 @@ export class SessionChannel {
         this.io.send("refresh-client -B 'tmux-ide-copy-keys:@*:#{mode-keys}'");
         this.io.send("refresh-client -B 'tmux-ide-pane-history:%*:#{history_size}'");
         this.io.send("refresh-client -B 'tmux-ide-scroll-on-clear:%*:#{scroll-on-clear}'");
-        if (this.opts.onNativeClientActivity) {
+        if (this.opts.onNativeClientActivity || this.opts.onNativeClientPresence) {
             // tmux does not guarantee `%client-attached` is broadcast to an
             // existing control client. A format subscription is the documented,
             // event-driven observation seam; its notification only schedules the
@@ -376,6 +378,8 @@ export class SessionChannel {
         }
         await this.syncNow();
         await this.firstJoin;
+        if (this.opts.onNativeClientPresence)
+            this.probeNativeClientActivity();
     }
     // ── Public surface (semantic ids only) ──────────────────────────────────
     describe() {
@@ -1001,6 +1005,7 @@ export class SessionChannel {
         if (this.disposed)
             return;
         this.disposed = true;
+        this.opts.onNativeClientPresence?.(null);
         this.snapshotActive?.cleanup?.();
         this.snapshotActive?.cancelFence?.();
         this.snapshotActive = null;
@@ -2308,7 +2313,7 @@ export class SessionChannel {
         // Layout changes remain a second honest wake-up: a native resize can arrive
         // before the once-per-second subscription notification. The inventory
         // (not either notification) remains the proof.
-        if (this.opts.onNativeClientActivity &&
+        if ((this.opts.onNativeClientActivity || this.opts.onNativeClientPresence) &&
             (NATIVE_CLIENT_NOTIFICATIONS.has(name) || name === "layout-change")) {
             this.probeNativeClientActivity();
         }
@@ -2492,22 +2497,38 @@ export class SessionChannel {
             this.scheduleSync();
     }
     probeNativeClientActivity() {
-        if (this.nativeClientProbePending || this.disposed)
+        if (this.disposed || this.nativeClientProbeClosed)
+            return;
+        this.opts.onNativeClientPresence?.(null);
+        if (this.nativeClientProbePending) {
+            this.nativeClientProbeDirty ||= this.opts.onNativeClientPresence !== undefined;
             return;
+        }
         this.nativeClientProbePending = true;
+        this.nativeClientProbeDirty = false;
         void this.io
             .request(`list-clients -t "${this.opts.session}" -F "#{client_control_mode}\t#{client_activity}"`)
             .then((lines) => {
-            // The daemon's own mirror is a control-mode client. Only a tmux-owned
-            // attached client (control mode = 0) is honest evidence for yielding
-            // geometry; notification names alone can include our own lifecycle.
-            if (lines.some((line) => /^0\t\d+$/u.test(line.trim()))) {
+            if (this.disposed || this.nativeClientProbeClosed || this.nativeClientProbeDirty)
+                return;
+            // Control-mode clients include our own mirrors. Only complete valid
+            // inventory proves absence; malformed replies must preserve fallback.
+            const valid = lines.every((line) => /^[01]\t\d+$/u.test(line.trim()));
+            const present = lines.some((line) => /^0\t\d+$/u.test(line.trim()));
+            this.opts.onNativeClientPresence?.(present ? true : valid ? false : null);
+            if (present)
                 this.opts.onNativeClientActivity?.();
-            }
         })
-            .catch(() => undefined)
+            .catch(() => {
+            if (!this.disposed && !this.nativeClientProbeClosed)
+                this.opts.onNativeClientPresence?.(null);
+        })
             .finally(() => {
             this.nativeClientProbePending = false;
+            // An attach/detach while the query ran invalidated its answer. Keep one
+            // follow-up request, rather than dropping the event or growing a queue.
+            if (this.nativeClientProbeDirty)
+                this.probeNativeClientActivity();
         });
     }
     releasePendingLayout(windowRuntimeId, syncOrdinal) {
@@ -3401,6 +3422,8 @@ export class SessionChannel {
     onChannelExit() {
         if (this.disposed)
             return;
+        this.nativeClientProbeClosed = true;
+        this.opts.onNativeClientPresence?.(null);
         this.snapshotActive?.cancelFence?.();
         this.snapshotActive = null;
         this.snapshotQueue.clear();