tmux-ide 2.9.0-beta.21 → 2.9.0-beta.22

package/packages/daemon/dist/lib/tmux-server-owners.js

@@ -0,0 +1,192 @@
+import { randomUUID } from "node:crypto";
+import { TmuxServerIdSchemaZ, TmuxServerRegistrationRequestSchemaZ, TmuxServerScopeSchemaZ, } from "@tmux-ide/contracts";
+// Admission limits, not performance claims. Discovery is explicit/on-demand.
+export const MAX_TMUX_SERVER_OWNERS = 16;
+export const TmuxServerSelectorSchemaZ = TmuxServerRegistrationRequestSchemaZ.shape.selector;
+export const TmuxServerRegistrationSchemaZ = TmuxServerRegistrationRequestSchemaZ.extend({
+    serverId: TmuxServerIdSchemaZ,
+}).strict();
+export class TmuxServerScopeError extends Error {
+    code;
+    constructor(code) {
+        super(`tmux server ${code}`);
+        this.code = code;
+        this.name = "TmuxServerScopeError";
+    }
+}
+/** One process; no shared mutable tmux authority, runtime cache or retry ledger. */
+export class TmuxServerOwners {
+    options;
+    #entries = new Map();
+    #tail = Promise.resolve();
+    #disposed = false;
+    #disposePromise = null;
+    constructor(options) {
+        this.options = options;
+    }
+    #serial(work) {
+        const run = this.#tail.then(() => {
+            if (this.#disposed)
+                throw new TmuxServerScopeError("disposed");
+            return work();
+        });
+        this.#tail = run.catch(() => undefined);
+        return run;
+    }
+    #descriptor(entry) {
+        return entry.scope
+            ? { ...entry.scope, label: entry.registration.label, state: "online" }
+            : {
+                serverId: entry.registration.serverId,
+                generation: null,
+                label: entry.registration.label,
+                state: "offline",
+            };
+    }
+    list() {
+        return [...this.#entries.values()].map((entry) => this.#descriptor(entry));
+    }
+    registrations() {
+        return [...this.#entries.values()].map((entry) => structuredClone(entry.registration));
+    }
+    #save() {
+        this.options.persist?.(this.registrations());
+    }
+    async #retire(entry) {
+        const owner = entry.owner;
+        entry.owner = null;
+        entry.scope = null;
+        entry.observation = null;
+        if (owner)
+            await owner.dispose();
+    }
+    async #refresh(entry, observed) {
+        const next = observed === undefined ? await this.options.probe(entry.registration.selector) : observed;
+        if (next && entry.observation?.fingerprint === next.fingerprint && entry.observation.valid())
+            return;
+        // Absence revokes command/stream leases without claiming native server death.
+        // Socket recreation also needs a fresh connection authority, even if PID survived.
+        await this.#retire(entry);
+        if (this.#disposed || !next || !next.valid())
+            return;
+        const duplicate = [...this.#entries.values()].find((other) => other !== entry &&
+            other.observation?.fingerprint === next.fingerprint &&
+            other.observation.valid());
+        if (duplicate)
+            return; // Never construct a second owner for a proven live alias.
+        const scope = { serverId: entry.registration.serverId, generation: randomUUID() };
+        let owner;
+        try {
+            owner = await this.options.create(entry.registration, scope, next);
+        }
+        catch {
+            return;
+        } // Registration remains visible/offline; explicit refresh retries.
+        if (this.#disposed || !next.valid()) {
+            await owner.dispose();
+            return;
+        }
+        entry.observation = next;
+        entry.scope = scope;
+        entry.owner = owner;
+    }
+    register(input) {
+        return this.#serial(async () => {
+            const registration = TmuxServerRegistrationSchemaZ.parse({
+                ...input,
+                serverId: input.serverId ?? `tmux-server.${randomUUID().replaceAll("-", "")}`,
+            });
+            const sameSelector = [...this.#entries.values()].find((entry) => JSON.stringify(entry.registration.selector) === JSON.stringify(registration.selector));
+            if (sameSelector) {
+                await this.#refresh(sameSelector);
+                return this.#descriptor(sameSelector);
+            }
+            if (this.#entries.has(registration.serverId))
+                throw new TypeError("Server registration already exists");
+            const observation = await this.options.probe(registration.selector);
+            if (this.#disposed)
+                throw new TmuxServerScopeError("disposed");
+            const alias = observation &&
+                [...this.#entries.values()].find((entry) => entry.observation?.fingerprint === observation.fingerprint && entry.observation.valid());
+            if (alias)
+                return this.#descriptor(alias);
+            if (this.#entries.size >= MAX_TMUX_SERVER_OWNERS)
+                throw new TmuxServerScopeError("capacity");
+            const entry = { registration, observation: null, scope: null, owner: null };
+            this.#entries.set(registration.serverId, entry);
+            try {
+                this.#save();
+            }
+            catch (error) {
+                this.#entries.delete(registration.serverId);
+                throw error;
+            }
+            await this.#refresh(entry, observation);
+            return this.#descriptor(entry);
+        });
+    }
+    /** Adopt the existing default owner rather than creating a duplicate mirror. */
+    adopt(registrationInput, scopeInput, observation, owner) {
+        const registration = TmuxServerRegistrationSchemaZ.parse(registrationInput);
+        const scope = TmuxServerScopeSchemaZ.parse(scopeInput);
+        if (scope.serverId !== registration.serverId || this.#entries.size || this.#disposed)
+            throw new TypeError("Invalid default owner adoption");
+        this.#entries.set(scope.serverId, { registration, scope, observation, owner });
+    }
+    refresh() {
+        return this.#serial(async () => {
+            // Sequential admission bounds subprocess work and avoids alias races.
+            for (const entry of this.#entries.values())
+                await this.#refresh(entry);
+            return this.list();
+        });
+    }
+    current(scopeInput) {
+        const scope = TmuxServerScopeSchemaZ.parse(scopeInput);
+        if (this.#disposed)
+            throw new TmuxServerScopeError("disposed");
+        const entry = this.#entries.get(scope.serverId);
+        if (!entry)
+            throw new TmuxServerScopeError("not-found");
+        if (!entry.scope || !entry.owner)
+            throw new TmuxServerScopeError("offline");
+        if (entry.scope.generation !== scope.generation || !entry.observation?.valid())
+            throw new TmuxServerScopeError("stale-generation");
+        return entry.owner;
+    }
+    async withOwner(scope, work) {
+        const owner = this.current(scope);
+        const result = await work(owner);
+        if (this.current(scope) !== owner)
+            throw new TmuxServerScopeError("stale-generation");
+        return result;
+    }
+    remove(serverId) {
+        return this.#serial(async () => {
+            const entry = this.#entries.get(TmuxServerIdSchemaZ.parse(serverId));
+            if (!entry)
+                throw new TmuxServerScopeError("not-found");
+            this.#entries.delete(serverId);
+            try {
+                this.#save();
+            }
+            catch (error) {
+                this.#entries.set(serverId, entry);
+                throw error;
+            }
+            await this.#retire(entry); // never kill-server or kill-session
+        });
+    }
+    dispose() {
+        if (this.#disposePromise)
+            return this.#disposePromise;
+        this.#disposed = true;
+        this.#disposePromise = (async () => {
+            await this.#tail;
+            const entries = [...this.#entries.values()];
+            this.#entries.clear();
+            await Promise.allSettled(entries.map((entry) => this.#retire(entry)));
+        })();
+        return this.#disposePromise;
+    }
+}

package/packages/daemon/dist/lib/tmux-server-proof.js

@@ -0,0 +1,82 @@
+import { realpathSync, statSync } from "node:fs";
+import { isNamedSocketAuthorityUnbound } from "./tmux-named-socket-fence.js";
+import { createHash } from "node:crypto";
+import { captureUnixSocketIdentity, revalidateUnixSocketIdentity, } from "./unix-socket-authority.js";
+/** Two read-only, no-start queries fence the socket and server incarnation. */
+export function captureTmuxServerProof(run) {
+    const args = ["-N", "display-message", "-p", "#{socket_path}|#{pid}|#{start_time}"];
+    try {
+        const raw = run(args).trimEnd();
+        const match = /^(.*)\|([1-9][0-9]*)\|([1-9][0-9]*)$/u.exec(raw);
+        if (!match || raw.length > 8192)
+            return null;
+        const socket = captureUnixSocketIdentity(match[1]);
+        if (run(args).trimEnd() !== raw)
+            return null;
+        revalidateUnixSocketIdentity(socket);
+        return {
+            version: 1,
+            kind: "live",
+            digest: createHash("sha256")
+                .update(JSON.stringify([socket.path, match[2], match[3]]))
+                .digest("hex"),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function captureTmuxServerProofAsync(run) {
+    const args = ["-N", "display-message", "-p", "#{socket_path}|#{pid}|#{start_time}"];
+    try {
+        const raw = (await run(args)).trimEnd();
+        const match = /^(.*)\|([1-9][0-9]*)\|([1-9][0-9]*)$/u.exec(raw);
+        if (!match || raw.length > 8192)
+            return null;
+        const socket = captureUnixSocketIdentity(match[1]);
+        if ((await run(args)).trimEnd() !== raw)
+            return null;
+        revalidateUnixSocketIdentity(socket);
+        return {
+            version: 1,
+            kind: "live",
+            digest: createHash("sha256")
+                .update(JSON.stringify([socket.path, match[2], match[3]]))
+                .digest("hex"),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** A selector commitment is not evidence of an absent or live server. */
+export function captureUnboundTmuxSelectorProof(authority) {
+    if (!isNamedSocketAuthorityUnbound(authority) || authority.socketSelector.kind !== "name")
+        return null;
+    try {
+        const executable = realpathSync(authority.executablePath);
+        const stat = statSync(executable, { bigint: true });
+        const uid = process.getuid?.();
+        if (uid === undefined || !stat.isFile())
+            return null;
+        return {
+            version: 1,
+            kind: "unbound-name",
+            digest: createHash("sha256")
+                .update(JSON.stringify([
+                "sanitized-tmux-environment-v1",
+                executable,
+                String(stat.dev),
+                String(stat.ino),
+                String(stat.mtimeNs),
+                String(stat.size),
+                uid,
+                authority.socketSelector.name,
+            ]))
+                .digest("hex"),
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/packages/daemon/dist/lib/tmux-server-registration.js

@@ -0,0 +1,85 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { createHash, randomUUID } from "node:crypto";
+import { mkdirSync, readFileSync, renameSync, writeFileSync, realpathSync, unlinkSync, } from "node:fs";
+import { dirname } from "node:path";
+import { z } from "zod";
+import { tmuxClientEnvironment } from "./tmux-client-execution.js";
+import { captureUnixSocketIdentity, revalidateUnixSocketIdentity, } from "./unix-socket-authority.js";
+import { MAX_TMUX_SERVER_OWNERS, TmuxServerRegistrationSchemaZ, } from "./tmux-server-owners.js";
+const exec = promisify(execFile);
+const FileSchema = z
+    .object({
+    version: z.literal(1),
+    servers: z.array(TmuxServerRegistrationSchemaZ).max(MAX_TMUX_SERVER_OWNERS),
+})
+    .strict()
+    .superRefine((file, ctx) => {
+    if (new Set(file.servers.map((server) => server.serverId)).size !== file.servers.length)
+        ctx.addIssue({ code: "custom", message: "Duplicate server registration" });
+});
+export function readTmuxServerRegistrations(path) {
+    try {
+        return FileSchema.parse(JSON.parse(readFileSync(path, "utf8"))).servers;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+export function writeTmuxServerRegistrations(path, registrations) {
+    const file = FileSchema.parse({ version: 1, servers: registrations });
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(temporary, `${JSON.stringify(file, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+        renameSync(temporary, path);
+    }
+    finally {
+        try {
+            unlinkSync(temporary);
+        }
+        catch {
+            /* rename already removed it */
+        }
+    }
+}
+/** Discovery never creates a server, loads configuration, or attaches a client. */
+export function createTmuxServerProbe(executable) {
+    const executablePath = realpathSync(executable);
+    const env = tmuxClientEnvironment(process.env);
+    return async (selector) => {
+        const args = selector.kind === "path" ? ["-S", selector.path] : ["-L", selector.name];
+        const read = async (selection) => (await exec(executablePath, [...selection, "-N", "display-message", "-p", "#{socket_path}|#{pid}|#{start_time}"], { env, encoding: "utf8", timeout: 500, maxBuffer: 8192 })).stdout.trimEnd();
+        try {
+            const first = await read(args);
+            const match = /^(.*)\|([1-9][0-9]*)\|([1-9][0-9]*)$/u.exec(first);
+            if (!match)
+                return null;
+            const socket = captureUnixSocketIdentity(match[1]);
+            if ((await read(["-S", socket.path])) !== first)
+                return null;
+            revalidateUnixSocketIdentity(socket);
+            return {
+                nativeServerIdentity: { pid: match[2], startTime: match[3] },
+                fingerprint: createHash("sha256")
+                    .update(JSON.stringify([socket.path, match[2], match[3]]))
+                    .digest("hex"),
+                authority: { executablePath, socketSelector: { kind: "path", path: socket.path } },
+                valid: () => {
+                    try {
+                        revalidateUnixSocketIdentity(socket);
+                        return true;
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+            };
+        }
+        catch {
+            return null;
+        }
+    };
+}

package/packages/daemon/dist/lib/tmux-server-session-create.js

@@ -0,0 +1,43 @@
+import { WorkspaceSessionCreateArgumentsSchemaZ, } from "@tmux-ide/contracts";
+import { FleetLifecycleAuthority } from "./fleet-lifecycle-authority.js";
+/** Bounded online-server creation. The existing lifecycle owns idempotency and workspace naming. */
+export function createNativeTmuxSessionCreator(options) {
+    let disposed = false;
+    const pending = new Set();
+    const assertOpen = () => {
+        options.assertOpen();
+        if (disposed)
+            throw new Error("Session creation is retired");
+    };
+    const authority = new FleetLifecycleAuthority({
+        daemonInstanceId: options.generation,
+        productVersion: "scoped-owner",
+        startedAt: new Date().toISOString(),
+        registry: options.registry,
+        runTmux(args) {
+            assertOpen();
+            return options.run(args);
+        },
+        readFleet: () => [],
+        ensureChromeUpdater: false,
+    });
+    return {
+        createSession(operationId, input) {
+            assertOpen();
+            const parsed = WorkspaceSessionCreateArgumentsSchemaZ.parse(input);
+            if (parsed.expectedDaemonInstanceId && parsed.expectedDaemonInstanceId !== options.generation)
+                throw new Error("Selected tmux server generation changed");
+            if (pending.size >= 16)
+                throw new Error("Session creation capacity reached");
+            const operation = authority
+                .createSession(operationId, options.generation, parsed)
+                .finally(() => pending.delete(operation));
+            pending.add(operation);
+            return operation;
+        },
+        async dispose() {
+            disposed = true;
+            await Promise.allSettled([...pending]);
+        },
+    };
+}

package/packages/daemon/dist/lib/tmux-server-session-open.js

@@ -0,0 +1,101 @@
+import { randomUUID } from "node:crypto";
+import { WorkspaceCatalogLiveSessionIdSchemaZ } from "@tmux-ide/contracts";
+import { liveSessionIdForNativeIdentity } from "../terminal/protocol/live-session-identity.js";
+import { fleetSessionIdForName } from "../command-center/resources/fleet-catalog.js";
+import { isVisibleFleetSession } from "../command-center/discovery.js";
+import { WorkspacePromotionAuthority } from "./workspace-promotion.js";
+import { shellEscape } from "./shell.js";
+/** Owner-local bounded admission; all native IO must already fence the server generation. */
+export function createNativeTmuxSessionOpener(options) {
+    let disposed = false;
+    let tail = Promise.resolve();
+    const pending = new Map();
+    const assertOpen = () => {
+        options.assertOpen();
+        if (disposed)
+            throw new Error("Session admission is retired");
+    };
+    const open = async (liveSessionId) => {
+        assertOpen();
+        const records = await options.run([
+            "list-sessions",
+            "-F",
+            "#{pid}\t#{session_id}\t#{session_created}\t#{session_name}",
+        ]);
+        const matches = records
+            .trim()
+            .split("\n")
+            .map((line) => line.split("\t"))
+            .filter(([pid, id, created, name]) => pid &&
+            /^\d+$/.test(pid) &&
+            id &&
+            /^\$\d+$/.test(id) &&
+            created &&
+            /^\d+$/.test(created) &&
+            name &&
+            isVisibleFleetSession(name) &&
+            liveSessionIdForNativeIdentity(pid, id, created) === liveSessionId);
+        if (matches.length !== 1)
+            throw new Error("Selected live tmux session is no longer available");
+        const [, nativeSessionId, created, name] = matches[0];
+        // Each command checks the exact native session on the server accepting it.
+        // A name-only validation followed by stamping would cross a session replacement.
+        const run = async (args) => {
+            assertOpen();
+            const sentinel = `tmux-session-stale.${randomUUID()}`;
+            const condition = `#{&&:#{==:#{session_id},${nativeSessionId}},#{==:#{session_created},${created}}}`;
+            const command = args.map((arg) => (arg === ";" ? ";" : shellEscape(arg))).join(" ");
+            const output = await options.run([
+                "if-shell",
+                "-t",
+                nativeSessionId,
+                "-F",
+                condition,
+                command,
+                `display-message -p '${sentinel}'`,
+            ]);
+            assertOpen();
+            if (output.trim() === sentinel)
+                throw new Error("Selected live tmux session changed during admission");
+            return output;
+        };
+        const promotion = new WorkspacePromotionAuthority({
+            daemonInstanceId: options.generation,
+            registry: options.registry,
+            io: { runTmux: run },
+        });
+        try {
+            const result = await promotion.promote({
+                operationId: randomUUID(),
+                expectedDaemonInstanceId: options.generation,
+                intent: { sessionId: fleetSessionIdForName(name) },
+            });
+            await run(["display-message", "-p", "-t", nativeSessionId, "#{session_id}"]);
+            return { workspaceName: result.resource.workspaceName, liveSessionId };
+        }
+        finally {
+            await promotion.dispose();
+        }
+    };
+    return {
+        openSession(liveSessionId) {
+            WorkspaceCatalogLiveSessionIdSchemaZ.parse(liveSessionId);
+            assertOpen();
+            const previous = pending.get(liveSessionId);
+            if (previous)
+                return previous;
+            if (pending.size >= 16)
+                throw new Error("Session admission capacity reached");
+            const operation = tail
+                .then(() => open(liveSessionId))
+                .finally(() => pending.delete(liveSessionId));
+            pending.set(liveSessionId, operation);
+            tail = operation.catch(() => { });
+            return operation;
+        },
+        async dispose() {
+            disposed = true;
+            await tail;
+        },
+    };
+}

package/packages/daemon/dist/lib/tmux-servers-cli.js

@@ -0,0 +1,134 @@
+import { randomUUID } from "node:crypto";
+import { SavedMachineSchema, TmuxServerIdSchemaZ, TmuxServerRegistrationRequestSchemaZ, WorkspaceSessionCreateArgumentsSchemaZ, } from "@tmux-ide/contracts";
+import { createTmuxServerClient, listTmuxServers, registerTmuxServer, removeTmuxServer, TmuxServerClientError, } from "@tmux-ide/daemon-client/tmux-server-client";
+import { canonicalDaemonUrl } from "./canonical-daemon.js";
+import { ensureCanonicalDaemon } from "./canonical-daemon-bootstrap.js";
+import { openSshDaemonTransport } from "./ssh-daemon-transport.js";
+import { loadSavedMachines } from "./saved-machines.js";
+/** Parse before acquiring a transport; invalid input cannot start a daemon. */
+export function parseTmuxServersOperation(options) {
+    const command = options.command ?? "list";
+    if (options.ssh !== undefined)
+        SavedMachineSchema.shape.sshTarget.parse(options.ssh);
+    if (command === "create") {
+        if (options.socketName !== undefined ||
+            options.socketPath !== undefined ||
+            options.label !== undefined)
+            throw new Error("servers create requires a registered server ID and --session-name NAME");
+        return {
+            command,
+            serverId: TmuxServerIdSchemaZ.parse(options.serverId),
+            input: WorkspaceSessionCreateArgumentsSchemaZ.parse({
+                displayName: options.sessionName,
+                ...(options.cwd ? { cwd: options.cwd } : {}),
+            }),
+        };
+    }
+    if (options.sessionName !== undefined || options.cwd !== undefined)
+        throw new Error("--session-name and --dir are only supported by servers create");
+    if (command === "add") {
+        if (options.serverId ||
+            (options.socketName === undefined) === (options.socketPath === undefined))
+            throw new Error("servers add requires exactly one of --socket-name NAME or --socket-path /PATH");
+        return {
+            command,
+            registration: TmuxServerRegistrationRequestSchemaZ.parse({
+                label: options.label ?? options.socketName ?? "Custom server",
+                selector: options.socketName !== undefined
+                    ? { kind: "name", name: options.socketName }
+                    : { kind: "path", path: options.socketPath },
+            }),
+        };
+    }
+    if (options.socketName !== undefined ||
+        options.socketPath !== undefined ||
+        options.label !== undefined)
+        throw new Error("Socket selectors and --name are only supported by servers add");
+    if (command === "list" && options.serverId === undefined)
+        return { command };
+    if (command === "remove" || command === "sessions")
+        return { command, serverId: TmuxServerIdSchemaZ.parse(options.serverId) };
+    throw new Error("Usage: tmux-ide servers list|add|remove <server-id>|sessions <server-id>|create <server-id> --session-name NAME [--ssh HOST] [--json]");
+}
+export async function connectTmuxServersCli(options) {
+    const hostClientId = randomUUID();
+    if (options.ssh !== undefined) {
+        const transport = await openSshDaemonTransport({ alias: options.ssh });
+        try {
+            const expected = loadSavedMachines().machines.find((machine) => machine.sshTarget === options.ssh)?.expectedEnvironmentId;
+            if (expected && transport.daemon.environmentId !== expected)
+                throw new Error("SSH route reached a different environment than the saved profile");
+            return {
+                client: {
+                    baseUrl: transport.baseUrl,
+                    ownerToken: transport.daemon.authToken,
+                    hostClientId,
+                    origin: transport.baseUrl,
+                },
+                dispose: () => transport.dispose(),
+            };
+        }
+        catch (error) {
+            transport.dispose();
+            throw error;
+        }
+    }
+    // Server registration addresses the daemon, not the invoking shell's tmux server.
+    const { candidate } = await ensureCanonicalDaemon({
+        entryPath: options.entryPath,
+        expectedProductVersion: options.expectedProductVersion,
+        tmuxServerIntent: null,
+    });
+    if (!candidate.authToken)
+        throw new Error("Daemon owner authority is unavailable; update the local daemon");
+    const baseUrl = canonicalDaemonUrl("http", candidate.bindHostname, candidate.port);
+    return {
+        client: { baseUrl, ownerToken: candidate.authToken, hostClientId, origin: baseUrl },
+        dispose() { },
+    };
+}
+export async function runTmuxServersCli(options, connect) {
+    const operation = parseTmuxServersOperation(options);
+    const connection = await connect();
+    try {
+        // Probe the versioned resource before writes. An older daemon is unsupported,
+        // never a reason to execute a raw command against a default server.
+        let catalog;
+        try {
+            catalog = await listTmuxServers(connection.client);
+        }
+        catch (error) {
+            if (error instanceof TmuxServerClientError && [404, 405, 426].includes(error.status ?? 0))
+                throw new Error("This daemon does not support tmux server selection; update the selected machine's daemon", { cause: error });
+            throw error;
+        }
+        if (operation.command === "list")
+            return catalog;
+        if (operation.command === "add")
+            return await registerTmuxServer(connection.client, operation.registration);
+        const server = catalog.servers.find((candidate) => candidate.serverId === operation.serverId);
+        if (!server)
+            throw new Error("Selected tmux server is not registered; run tmux-ide servers list");
+        if (operation.command === "remove") {
+            await removeTmuxServer(connection.client, server.serverId);
+            return { removed: true, serverId: server.serverId };
+        }
+        if (server.state !== "online")
+            throw new Error("Selected tmux server is offline; no session operation was attempted");
+        const client = createTmuxServerClient(connection.client, {
+            serverId: server.serverId,
+            generation: server.generation,
+        });
+        try {
+            return operation.command === "create"
+                ? await client.createSession(randomUUID(), operation.input)
+                : await client.sessions();
+        }
+        finally {
+            client.dispose();
+        }
+    }
+    finally {
+        connection.dispose();
+    }
+}