tmux-ide 2.9.4 → 2.9.6

package/packages/daemon/dist/lib/machine-connection-manager.js

@@ -0,0 +1,291 @@
+import { createFleetDialScheduler } from "@tmux-ide/daemon-client/fleet-dial-scheduler";
+import { LOCAL_MACHINE_ID, SavedMachineSchema, SavedMachineRegistrySchema, } from "@tmux-ide/contracts";
+import { createDaemonConnectionOwner, } from "./daemon-connection-owner.js";
+/** Owns independent transport lifetimes; selecting a machine changes only the active route. */
+export function createMachineConnectionManager(dependencies = {
+    createOwner: createDaemonConnectionOwner,
+}) {
+    const machines = new Map();
+    const subscribers = new Set();
+    const selectedObservers = new Set();
+    const lifetime = new AbortController();
+    const scheduler = createFleetDialScheduler();
+    let selectedId = LOCAL_MACHINE_ID;
+    let selectedEpoch = 0;
+    let disposed = false;
+    let stopProfiles = null;
+    const safe = (callback) => {
+        try {
+            callback();
+        }
+        catch {
+            /* Observers cannot own machine lifetime. */
+        }
+    };
+    const publish = () => {
+        for (const listener of subscribers)
+            safe(listener);
+    };
+    const selectedGeneration = (generation) => {
+        for (const listener of selectedObservers)
+            safe(() => listener(generation));
+    };
+    const changed = (machine, generation) => {
+        if (disposed || machine.retired)
+            return;
+        machine.epoch++;
+        for (const listener of machine.listeners)
+            safe(() => listener(generation));
+        if (machine.id === selectedId) {
+            selectedEpoch++;
+            selectedGeneration(generation);
+        }
+        publish();
+    };
+    const observe = (machine, owner) => {
+        if (machine.observingOwner === owner)
+            return;
+        machine.observingOwner = owner;
+        void owner
+            .observe((generation) => {
+            if (machine.owner === owner)
+                changed(machine, generation);
+        })
+            .then((stop) => {
+            if (disposed || machine.retired || machine.owner !== owner)
+                stop();
+            else
+                machine.stopObserver = stop;
+        }, () => {
+            /* Local filesystem watcher failure does not disable catalog polling. */
+        });
+    };
+    const makeMachine = (id, label, profile) => {
+        let settle;
+        const ready = profile
+            ? new Promise((resolve) => {
+                settle = resolve;
+            })
+            : Promise.resolve(true);
+        const owner = dependencies.createOwner();
+        const listeners = new Set();
+        const machine = {
+            id,
+            label,
+            kind: profile ? "ssh" : "local",
+            profile,
+            owner,
+            listeners,
+            epoch: 0,
+            stopObserver: null,
+            observingOwner: null,
+            stopStatus: null,
+            retired: false,
+        };
+        const handle = Object.freeze({
+            id,
+            get label() {
+                return machine.label;
+            },
+            kind: machine.kind,
+            ready,
+            read: () => (disposed || machine.retired ? null : machine.owner.read()),
+            isAlive: (info) => disposed || machine.retired ? Promise.resolve(false) : machine.owner.isAlive(info),
+            endpoint: () => Object.freeze({
+                ...machine.owner.endpoint(),
+                kind: machine.kind,
+                label: machine.profile ? machine.label : null,
+                epoch: machine.epoch,
+                ...(disposed || machine.retired
+                    ? { state: "disconnected", remote: null, localBaseUrl: null }
+                    : {}),
+            }),
+            observe: async (listener) => {
+                if (disposed || machine.retired)
+                    return () => { };
+                if (machine.kind === "local")
+                    observe(machine, machine.owner);
+                listeners.add(listener);
+                return () => {
+                    listeners.delete(listener);
+                };
+            },
+        });
+        Object.assign(machine, { handle });
+        machines.set(id, machine);
+        if (!profile)
+            return machine;
+        // The owner selects SSH synchronously and owns ALL retries, including initial failure.
+        machine.stopStatus = owner.observeConnection(publish);
+        const initializing = owner.initialize(profile.sshTarget, lifetime.signal, {
+            scheduler,
+            expectedEnvironmentId: profile.expectedEnvironmentId,
+            retryDelayMs: dependencies.retryDelayMs,
+        });
+        observe(machine, owner);
+        publish();
+        void initializing.then(() => settle(!disposed && !machine.retired), () => settle(false));
+        return machine;
+    };
+    makeMachine(LOCAL_MACHINE_ID, "Local");
+    const snapshot = () => Object.freeze({
+        selectedMachineId: selectedId,
+        machines: Object.freeze([...machines.values()].map((machine) => Object.freeze({
+            id: machine.id,
+            label: machine.label,
+            kind: machine.kind,
+            state: machine.handle.endpoint().state,
+            ...(machine.profile ? { sshTarget: machine.profile.sshTarget } : {}),
+        }))),
+    });
+    const manager = {
+        snapshot,
+        getMachine: (id) => machines.get(id)?.handle ?? null,
+        subscribe(listener) {
+            if (disposed)
+                return () => { };
+            const local = machines.get(LOCAL_MACHINE_ID);
+            observe(local, local.owner);
+            subscribers.add(listener);
+            return () => {
+                subscribers.delete(listener);
+            };
+        },
+        retry(id) {
+            const machine = machines.get(id);
+            if (disposed || !machine?.profile)
+                return;
+            scheduler.prioritize(machine.profile.sshTarget);
+            void machine.owner.retry();
+        },
+        disconnect(id) {
+            if (disposed)
+                return;
+            machines.get(id)?.owner.disconnect();
+        },
+        select(id) {
+            if (disposed || !machines.has(id))
+                return false;
+            if (selectedId === id)
+                return true;
+            // Revoke old generation bindings while their old machine is still selected.
+            selectedEpoch++;
+            selectedGeneration(null);
+            selectedId = id;
+            const target = machines.get(id)?.profile?.sshTarget;
+            if (target)
+                scheduler.prioritize(target);
+            selectedEpoch++;
+            selectedGeneration(machines.get(id).handle.read()?.instanceId ?? null);
+            publish();
+            return true;
+        },
+        add(input) {
+            if (disposed)
+                throw new Error("Machine authority manager has been disposed");
+            const profile = SavedMachineSchema.parse(input);
+            const existing = machines.get(profile.id);
+            if (existing) {
+                if (existing.profile?.sshTarget !== profile.sshTarget ||
+                    existing.label !== profile.label ||
+                    existing.profile?.expectedEnvironmentId !== profile.expectedEnvironmentId)
+                    throw new Error("Machine identity is already registered");
+                return existing.handle;
+            }
+            SavedMachineRegistrySchema.parse({
+                version: 1,
+                machines: [
+                    ...[...machines.values()].flatMap((machine) => machine.profile ? [machine.profile] : []),
+                    profile,
+                ],
+            });
+            if (!profile.enabled)
+                throw new Error("Disabled machine profiles cannot be connected");
+            const machine = makeMachine(profile.id, profile.label, profile);
+            publish();
+            return machine.handle;
+        },
+        initialize(profiles) {
+            SavedMachineRegistrySchema.parse({ version: 1, machines: profiles });
+            for (const profile of profiles)
+                if (profile.enabled)
+                    manager.add(profile);
+        },
+        reconcile(profiles) {
+            if (disposed)
+                return;
+            const next = SavedMachineRegistrySchema.parse({ version: 1, machines: profiles });
+            const previousSelection = selectedId;
+            for (const machine of [...machines.values()]) {
+                if (!machine.profile)
+                    continue;
+                const profile = next.machines.find((candidate) => candidate.id === machine.id && candidate.enabled);
+                if (profile &&
+                    profile.sshTarget === machine.profile.sshTarget &&
+                    profile.expectedEnvironmentId === machine.profile.expectedEnvironmentId) {
+                    // Labels are presentation metadata, not transport identity. Preserve
+                    // the connected owner and every consumer holding its stable handle.
+                    machine.label = profile.label;
+                    machine.profile = profile;
+                    continue;
+                }
+                if (selectedId === machine.id)
+                    manager.select(LOCAL_MACHINE_ID);
+                machine.retired = true;
+                machine.stopStatus?.();
+                machine.stopObserver?.();
+                for (const listener of machine.listeners)
+                    safe(() => listener(null));
+                machine.owner.dispose();
+                machine.listeners.clear();
+                machines.delete(machine.id);
+            }
+            for (const profile of next.machines)
+                if (profile.enabled)
+                    manager.add(profile);
+            if (machines.has(previousSelection))
+                manager.select(previousSelection);
+            publish();
+        },
+        followProfiles(subscribe) {
+            if (disposed)
+                return;
+            stopProfiles?.();
+            stopProfiles = subscribe(manager.reconcile);
+        },
+        read: () => machines.get(selectedId)?.handle.read() ?? null,
+        isAlive: (info) => machines.get(selectedId)?.handle.isAlive(info) ?? Promise.resolve(false),
+        endpoint: () => Object.freeze({ ...machines.get(selectedId).handle.endpoint(), epoch: selectedEpoch }),
+        async observeSelected(listener) {
+            if (disposed)
+                return () => { };
+            const local = machines.get(LOCAL_MACHINE_ID);
+            observe(local, local.owner);
+            selectedObservers.add(listener);
+            return () => {
+                selectedObservers.delete(listener);
+            };
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            stopProfiles?.();
+            stopProfiles = null;
+            lifetime.abort();
+            selectedEpoch++;
+            selectedGeneration(null);
+            for (const machine of machines.values()) {
+                machine.stopStatus?.();
+                machine.stopObserver?.();
+                machine.stopObserver = null;
+                machine.owner.dispose();
+                machine.listeners.clear();
+            }
+            publish();
+            subscribers.clear();
+            selectedObservers.clear();
+        },
+    };
+    return manager;
+}

package/packages/daemon/dist/lib/machine-profile.js

@@ -0,0 +1,17 @@
+import { randomUUID } from "node:crypto";
+import { SavedMachineSchema } from "@tmux-ide/contracts";
+/** Labels describe access routes; they never become routing identities. */
+export function ephemeralMachineProfile(alias, existing) {
+    const target = SavedMachineSchema.shape.sshTarget.parse(alias);
+    const base = target.slice(0, 70);
+    const labels = new Set([
+        "local",
+        "this mac",
+        "this machine",
+        ...existing.map((p) => p.label.normalize("NFKC").toLowerCase()),
+    ]);
+    let label = base;
+    for (let suffix = 2; labels.has(label.normalize("NFKC").toLowerCase()); suffix++)
+        label = `${base} (${suffix})`;
+    return SavedMachineSchema.parse({ id: randomUUID(), label, sshTarget: target, enabled: true });
+}

package/packages/daemon/dist/lib/native-split-capability.js

@@ -0,0 +1,82 @@
+import { NativeJournalCapabilitySchemaZ } from "@tmux-ide/contracts";
+import { supportsNativeSplitResize, } from "../terminal/protocol/native-split-resize.js";
+/** Read-only issuance gate, not mutation authorization. No cache survives a
+ * probe: the selected pinned server must report the captured native epoch on
+ * both sides of the exact split capability reply. Runners bound time/output. */
+export function createNativeSplitCapabilityProbe(options) {
+    return async (epoch) => {
+        const observation = options.observation();
+        const current = () => observation !== null &&
+            options.observation() === observation &&
+            observation.nativeServerEpoch === epoch &&
+            observation.ownedOperationTransport &&
+            observation.ownedOperationEpochGuard &&
+            observation.ownedOperationPaneGuard &&
+            observation.ownedOperationSessionGuard;
+        const sameNativeEpoch = async () => {
+            const text = await options.runPinnedTmux(["tmux-ide-events", "-V"]);
+            if (typeof text !== "string" || Buffer.byteLength(text) > 16384)
+                return false;
+            const value = NativeJournalCapabilitySchemaZ.parse(JSON.parse(text));
+            return (value.serverEpoch === epoch &&
+                value.enabled &&
+                value.degraded === 0 &&
+                value.ownedOperationTransport === "direct-wrapper-v1" &&
+                value.ownedOperationEpochGuard === "server-epoch-v1" &&
+                value.ownedOperationPaneGuard === "direct-pane-v1" &&
+                value.ownedOperationSessionGuard === "direct-session-v1");
+        };
+        try {
+            if (!current() || !(await sameNativeEpoch()) || !current())
+                return false;
+            if (!(await supportsNativeSplitResize(options.runPinnedTmux)) || !current())
+                return false;
+            return (await sameNativeEpoch()) && current();
+        }
+        catch {
+            return false;
+        }
+    };
+}
+/** Only an explicit canonical split read activates an otherwise stock owner.
+ * Preflight is read-only; unsupported binaries never reach the enabling reader. */
+export function createNativeSplitReadiness(options) {
+    let pending = null;
+    const prepare = async () => {
+        const observation = options.observation();
+        if (!observation)
+            return false;
+        if (observation.nativeServerEpoch &&
+            observation.ownedOperationSessionGuard &&
+            observation.ownedOperationPaneGuard)
+            return true;
+        const probe = async () => {
+            const text = await options.runPinnedTmux(["tmux-ide-events", "-V"]);
+            if (typeof text !== "string" || Buffer.byteLength(text) > 16384)
+                throw new Error("Invalid capability");
+            const value = NativeJournalCapabilitySchemaZ.parse(JSON.parse(text));
+            if (value.degraded !== 0 ||
+                value.ownedOperationTransport !== "direct-wrapper-v1" ||
+                value.ownedOperationEpochGuard !== "server-epoch-v1" ||
+                value.ownedOperationPaneGuard !== "direct-pane-v1" ||
+                value.ownedOperationSessionGuard !== "direct-session-v1")
+                throw new Error("Unsupported capability");
+            return value.serverEpoch;
+        };
+        try {
+            const epoch = await probe();
+            if (options.observation() !== observation ||
+                !(await supportsNativeSplitResize(options.runPinnedTmux)))
+                return false;
+            if ((await probe()) !== epoch || options.observation() !== observation)
+                return false;
+            return (await observation.activateForSplit(epoch)) && options.observation() === observation;
+        }
+        catch {
+            return false;
+        }
+    };
+    return () => (pending ??= prepare().finally(() => {
+        pending = null;
+    }));
+}

package/packages/daemon/dist/lib/native-tmux-interaction-observer.js

@@ -224,7 +224,9 @@ export class NativeTmuxInteractionObserver {
             this.#state("incompatible");
             return false;
         }
-        if ((this.#capability && this.#capability.serverEpoch !== capability.serverEpoch) ||
+        if ((this.#options.expectedServerEpoch !== undefined &&
+            this.#options.expectedServerEpoch !== capability.serverEpoch) ||
+            (this.#capability && this.#capability.serverEpoch !== capability.serverEpoch) ||
             (this.#cursor && this.#cursor.serverEpoch !== capability.serverEpoch)) {
             this.#state("retired");
             return false;

package/packages/daemon/dist/lib/owner-interaction-observation.js

@@ -14,6 +14,8 @@ export class OwnerInteractionObservation {
     #projector = null;
     #capability = null;
     #start = null;
+    #splitActivation = null;
+    #expectedSplitEpoch;
     #bindings = null;
     #bindingTimer = null;
     #bindingDeadline = null;
@@ -210,8 +212,50 @@ export class OwnerInteractionObservation {
     start() {
         return (this.#start ??= this.#initialize());
     }
+    /** Called only after the canonical split owner's read-only positive preflight.
+     * Ordinary start remains opt-in. A failed lazy reader is never restarted. */
+    activateForSplit(expectedEpoch) {
+        if (this.#disposed || this.#halted || !this.#options.nativeServerIdentity)
+            return Promise.resolve(false);
+        if (this.#selection === "native")
+            return Promise.resolve(this.nativeServerEpoch === expectedEpoch && this.ownedOperationSessionGuard);
+        return (this.#splitActivation ??= this.#activateForSplit(expectedEpoch));
+    }
+    async #activateForSplit(expectedEpoch) {
+        if (this.#selection === "stock") {
+            if (this.#reader)
+                return false;
+            this.#selection = "pending";
+            this.#expectedSplitEpoch = expectedEpoch;
+            this.#start = null; // Default stock start completed without creating a reader.
+        }
+        let timer;
+        try {
+            const completed = await Promise.race([
+                this.start().then(() => true),
+                new Promise((resolve) => {
+                    timer = setTimeout(() => resolve(false), 6_000);
+                }),
+            ]);
+            if (!completed) {
+                this.#halted = true;
+                this.#retireBindings(false);
+                this.#unavailable();
+                void this.#reader?.dispose().catch(() => undefined);
+            }
+            return (completed &&
+                !this.#disposed &&
+                !this.#halted &&
+                this.nativeServerEpoch === expectedEpoch &&
+                this.ownedOperationSessionGuard &&
+                this.ownedOperationPaneGuard);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
     async #initialize() {
-        if (this.#disposed || this.#selection === "stock")
+        if (this.#disposed || this.#halted || this.#selection === "stock")
             return;
         const factory = this.#options.readerFactory ?? ((options) => new NativeTmuxInteractionObserver(options));
         try {
@@ -219,6 +263,7 @@ export class OwnerInteractionObservation {
                 tmuxAuthority: this.#options.tmuxAuthority,
                 nativeServerIdentity: this.#options.nativeServerIdentity,
                 enable: true,
+                expectedServerEpoch: this.#expectedSplitEpoch,
                 onEvent: (event) => this.#event(event),
             });
             await this.#reader.start();
@@ -227,7 +272,7 @@ export class OwnerInteractionObservation {
             if (this.#selection === "native")
                 this.#unavailable();
         }
-        if (this.#disposed)
+        if (this.#disposed || this.#halted)
             return;
         if (this.#selection === "pending") {
             this.#selection = "stock";

package/packages/daemon/dist/lib/pane-widget.js

@@ -35,7 +35,7 @@ export function imageMediaTypeFor(fileName) {
  * which overflows the 2,000-row mirror seed window and would silently break
  * re-detection after every reconnect. The full derivation, including the
  * ~50-column floor below which even a legal marker can be truncated, is the
- * table in apps/desktop-renderer/src/terminal/widgets/WIDGETS.md.
+ * table in docs/guides/pane-widget-protocol.md.
  *
  * Serving image bytes over a daemon route instead — which lifts this entirely —
  * is the documented follow-up.

package/packages/daemon/dist/lib/runtime-trace-writer.js

@@ -0,0 +1,133 @@
+const MAX_RECORD_BYTES = 64 * 1024;
+/** Opt-in diagnostics: one stream buffer, no additional queue or producer backpressure. */
+export function createRuntimeTraceWriter(stream, identity, closeTimeoutMs = 1000) {
+    const counts = {
+        offeredRecords: 0,
+        acceptedRecords: 0,
+        droppedRecords: 0,
+        saturatedDrops: 0,
+        failedDrops: 0,
+        oversizedRecords: 0,
+        constructionFailures: 0,
+        rejectedWrites: 0,
+        writeFailures: 0,
+    };
+    let saturated = false;
+    let failed = false;
+    let closed = false;
+    let closing;
+    let closeFailure;
+    const snapshot = () => ({ ...counts, failed, saturated, writableLength: stream.writableLength });
+    stream.on("drain", () => {
+        if (!failed)
+            saturated = false;
+    });
+    // Retain the error listener through destroy: a late stream error must not escape cleanup.
+    stream.on("error", (error) => {
+        counts.writeFailures++;
+        failed = true;
+        closeFailure?.(error);
+    });
+    return {
+        snapshot,
+        append(build) {
+            if (closed)
+                return;
+            counts.offeredRecords++;
+            if (failed || stream.destroyed) {
+                counts.failedDrops++;
+                counts.droppedRecords++;
+                return;
+            }
+            if (saturated) {
+                counts.saturatedDrops++;
+                counts.droppedRecords++;
+                return;
+            }
+            let line;
+            try {
+                const json = JSON.stringify(build());
+                if (json === undefined)
+                    throw new Error("Trace record is not JSON");
+                line = `${json}\n`;
+                if (Buffer.byteLength(line) > MAX_RECORD_BYTES) {
+                    counts.oversizedRecords++;
+                    counts.droppedRecords++;
+                    return;
+                }
+            }
+            catch {
+                counts.constructionFailures++;
+                counts.droppedRecords++;
+                failed = true;
+                return;
+            }
+            try {
+                saturated = !stream.write(line);
+                counts.acceptedRecords++;
+            }
+            catch {
+                counts.rejectedWrites++;
+                counts.droppedRecords++;
+                failed = true;
+            }
+        },
+        close(incomplete = false) {
+            if (closing)
+                return closing;
+            closed = true;
+            if (incomplete)
+                failed = true;
+            closing = new Promise((resolve, reject) => {
+                let settled = false;
+                const finish = (error) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    clearTimeout(timer);
+                    stream.off("drain", end);
+                    stream.off("close", prematureClose);
+                    closeFailure = undefined;
+                    if (error) {
+                        failed = true;
+                        stream.destroy();
+                        reject(error);
+                    }
+                    else
+                        resolve();
+                };
+                const prematureClose = () => finish(new Error("Runtime trace closed before final summary completion"));
+                const end = () => {
+                    try {
+                        if (stream.destroyed || !stream.writable)
+                            throw new Error("Runtime trace stream unavailable");
+                        const summary = {
+                            version: 1,
+                            type: "performance.daemon-trace.summary",
+                            ...identity,
+                            ...snapshot(),
+                            maxRecordBytes: MAX_RECORD_BYTES,
+                            acceptedRecordsExcludeSummary: true,
+                            shutdownKind: incomplete ? "startup-rollback" : "normal",
+                            ringTailOverwrites: "not-file-loss",
+                        };
+                        stream.end(`${JSON.stringify(summary)}\n`, () => finish(failed ? new Error("Runtime trace recorded failures") : undefined));
+                    }
+                    catch (error) {
+                        finish(error instanceof Error ? error : new Error("Runtime trace end failed"));
+                    }
+                };
+                const timer = setTimeout(() => finish(new Error("Runtime trace close timed out")), closeTimeoutMs);
+                closeFailure = finish;
+                stream.on("close", prematureClose);
+                if (stream.destroyed)
+                    finish(new Error("Runtime trace stream destroyed"));
+                else if (saturated && stream.writableNeedDrain)
+                    stream.once("drain", end);
+                else
+                    end();
+            });
+            return closing;
+        },
+    };
+}

package/packages/daemon/dist/lib/tmux-client-execution.js

@@ -1,7 +1,8 @@
+import { fileURLToPath } from "node:url";
 import { accessSync, constants, realpathSync, statSync } from "node:fs";
-import { delimiter, isAbsolute, join } from "node:path";
+import { delimiter, isAbsolute, join, resolve } from "node:path";
 import { resolveRuntimeNamespace } from "./runtime-namespace.js";
-import { resolveBundledTmux, bundledTmuxResourceEnvironment } from "./bundled-tmux.js";
+import { resolveBundledTmux, bundledTmuxResourceEnvironment, withBundledTmuxResources, } from "./bundled-tmux.js";
 export function resolveTmuxExecutable() {
     if (resolveRuntimeNamespace().development)
         return resolveBundledTmux();
@@ -57,3 +58,37 @@ export function tmuxClientEnvironment(source, executable) {
     }
     return { ...environment, ...bundledTmuxResourceEnvironment(executable) };
 }
+/** Ordinary CLI commands retain PATH selection; bundled tmux fills a missing system client. */
+export function resolveOrdinaryTmuxClient(environment, cwd) {
+    const configured = environment.TMUX_IDE_TMUX_BIN;
+    const candidates = configured
+        ? [configured]
+        : (environment.PATH ?? "/usr/bin:/bin")
+            .split(delimiter)
+            .map((entry) => resolve(cwd instanceof URL ? fileURLToPath(cwd) : (cwd ?? process.cwd()), entry, "tmux"));
+    let executable;
+    for (const candidate of candidates) {
+        try {
+            if (!isAbsolute(candidate))
+                continue;
+            accessSync(candidate, constants.X_OK);
+            const canonical = realpathSync(candidate);
+            if (statSync(canonical).isFile()) {
+                executable = canonical;
+                break;
+            }
+        }
+        catch {
+            /* Try the next ordinary PATH candidate. */
+        }
+    }
+    if (!executable && !configured)
+        executable =
+            resolveBundledTmux([
+                ...(environment.TMUX_IDE_CLI ? [environment.TMUX_IDE_CLI] : []),
+                fileURLToPath(import.meta.url),
+            ]) ?? undefined;
+    if (!executable)
+        throw new Error("tmux_executable_unavailable");
+    return { executable, environment: withBundledTmuxResources(executable, environment) };
+}