cmux 0.3.5 → 0.4.0

package/dist/src/errors.d.ts

@@ -0,0 +1,18 @@
+import type { CmuxErrorDelivery } from "./protocol/common.js";
+export declare class CmuxError extends Error {
+    constructor(message: string);
+}
+export declare class CmuxCommandError extends CmuxError {
+    readonly commandId: unknown;
+    readonly response: unknown;
+    readonly errorCode: string | undefined;
+    readonly delivery: CmuxErrorDelivery | undefined;
+    constructor(message: string, commandId?: unknown, response?: unknown, delivery?: CmuxErrorDelivery);
+    constructor(message: string, commandId?: unknown, response?: unknown, errorCode?: string, delivery?: CmuxErrorDelivery);
+}
+export declare class CmuxConnectionError extends CmuxError {
+}
+export declare class CmuxProtocolError extends CmuxError {
+}
+export declare class CmuxTimeoutError extends CmuxError {
+}

package/dist/src/errors.js

@@ -0,0 +1,29 @@
+export class CmuxError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = new.target.name;
+    }
+}
+export class CmuxCommandError extends CmuxError {
+    commandId;
+    response;
+    errorCode;
+    delivery;
+    constructor(message, commandId, response, errorCode, delivery) {
+        super(message);
+        this.commandId = commandId;
+        this.response = response;
+        const legacyDelivery = delivery === undefined
+            && (errorCode === "known-not-delivered" || errorCode === "ambiguous")
+            ? errorCode
+            : undefined;
+        this.errorCode = legacyDelivery === undefined ? errorCode : undefined;
+        this.delivery = delivery ?? legacyDelivery;
+    }
+}
+export class CmuxConnectionError extends CmuxError {
+}
+export class CmuxProtocolError extends CmuxError {
+}
+export class CmuxTimeoutError extends CmuxError {
+}

package/dist/src/index.d.ts

@@ -0,0 +1,8 @@
+export { CmuxClient, type ClientOptions } from "./node-client.js";
+export { CmuxStream, TERMINAL_KEY_TEXT_MAX_BYTES, type AttachSurfaceOptions, type CmuxClientOptions, type NewBrowserTabOptions, type NewPaneRightOptions, type NewScreenOptions, type NewTabOptions, type NewWorkspaceOptions, type CreateTerminalOptions, type CreateWorkspaceOptions, type CloseWorkspaceOptions, type MoveWorkspaceOptions, type RenameWorkspaceOptions, type ResizeTransactionOptions, type SelectOptions, type SelectTabOptions, type SendOptions, type SplitOptions, type SubscribeOptions, } from "./client.js";
+export * from "./base64.js";
+export * from "./errors.js";
+export * from "./node-transport.js";
+export * from "./protocol/index.js";
+export * from "./transport.js";
+export * from "./websocket-transport.js";

package/dist/src/index.js

@@ -0,0 +1,8 @@
+export { CmuxClient } from "./node-client.js";
+export { CmuxStream, TERMINAL_KEY_TEXT_MAX_BYTES, } from "./client.js";
+export * from "./base64.js";
+export * from "./errors.js";
+export * from "./node-transport.js";
+export * from "./protocol/index.js";
+export * from "./transport.js";
+export * from "./websocket-transport.js";

package/dist/src/node-client.d.ts

@@ -0,0 +1,18 @@
+import { CmuxClient as TransportCmuxClient } from "./client.js";
+import type { Transport } from "./transport.js";
+/** Node.js client configuration, including Unix-socket defaults. */
+export interface ClientOptions {
+    socketPath?: string;
+    session?: string;
+    timeoutMs?: number;
+    allowProtocolV6Attach?: boolean;
+    /** Overrides the default Unix transport. */
+    transport?: Transport;
+    /** Overrides dedicated transports used for subscribe and attach streams. */
+    streamTransportFactory?: () => Transport;
+}
+/** Node.js cmux client with backward-compatible Unix-socket defaults. */
+export declare class CmuxClient extends TransportCmuxClient {
+    readonly socketPath: string;
+    constructor(options?: ClientOptions);
+}

package/dist/src/node-client.js

@@ -0,0 +1,18 @@
+import { CmuxClient as TransportCmuxClient } from "./client.js";
+import { defaultSocketPath, envSocketPath, UnixSocketTransport } from "./node-transport.js";
+/** Node.js cmux client with backward-compatible Unix-socket defaults. */
+export class CmuxClient extends TransportCmuxClient {
+    socketPath;
+    constructor(options = {}) {
+        const socketPath = options.socketPath ?? envSocketPath() ?? defaultSocketPath(options.session ?? "main");
+        const shared = {
+            transport: options.transport ?? new UnixSocketTransport(socketPath),
+            timeoutMs: options.timeoutMs,
+            allowProtocolV6Attach: options.allowProtocolV6Attach,
+            streamTransportFactory: options.streamTransportFactory
+                ?? (options.transport ? undefined : () => new UnixSocketTransport(socketPath)),
+        };
+        super(shared);
+        this.socketPath = socketPath;
+    }
+}

package/dist/src/node-transport.d.ts

@@ -0,0 +1,27 @@
+import type { Transport, Unsubscribe } from "./transport.js";
+/** Resolves the default Unix socket path for a session. */
+export declare function defaultSocketPath(session?: string): string;
+/** Reads the current or legacy cmux-tui socket environment variable. */
+export declare function envSocketPath(): string | undefined;
+/** Unix-socket JSON-lines transport for Node.js. */
+export declare class UnixSocketTransport implements Transport {
+    readonly socketPath: string;
+    private readonly socket;
+    private readonly pending;
+    private readonly messageHandlers;
+    private readonly closeHandlers;
+    private readonly errorHandlers;
+    private buffer;
+    private connected;
+    private closed;
+    constructor(socketPath: string);
+    send(json: string): void;
+    onMessage(handler: (json: string) => void): Unsubscribe;
+    onClose(handler: () => void): Unsubscribe;
+    onError(handler: (error: Error) => void): Unsubscribe;
+    close(): void;
+    private write;
+    private receive;
+    private fail;
+    private finish;
+}

package/dist/src/node-transport.js

@@ -0,0 +1,99 @@
+import * as net from "node:net";
+import * as os from "node:os";
+import * as path from "node:path";
+import { CmuxConnectionError } from "./errors.js";
+/** Resolves the default Unix socket path for a session. */
+export function defaultSocketPath(session = "main") {
+    const base = process.env.TMPDIR || os.tmpdir();
+    return path.join(base, `cmux-tui-${process.getuid?.() ?? 0}`, `${session}.sock`);
+}
+/** Reads the current or legacy cmux-tui socket environment variable. */
+export function envSocketPath() {
+    return process.env.CMUX_TUI_SOCKET || process.env.CMUX_MUX_SOCKET;
+}
+/** Unix-socket JSON-lines transport for Node.js. */
+export class UnixSocketTransport {
+    socketPath;
+    socket;
+    pending = [];
+    messageHandlers = new Set();
+    closeHandlers = new Set();
+    errorHandlers = new Set();
+    buffer = "";
+    connected = false;
+    closed = false;
+    constructor(socketPath) {
+        this.socketPath = socketPath;
+        this.socket = net.createConnection({ path: socketPath });
+        this.socket.setEncoding("utf8");
+        this.socket.on("connect", () => {
+            this.connected = true;
+            while (this.pending.length > 0)
+                this.write(this.pending.shift());
+        });
+        this.socket.on("data", (chunk) => this.receive(chunk));
+        this.socket.on("error", (error) => {
+            const prefix = this.connected ? "socket error" : `cannot connect to session socket ${this.socketPath}`;
+            this.fail(new CmuxConnectionError(`${prefix}: ${error.message}`));
+        });
+        this.socket.on("close", () => this.finish());
+    }
+    send(json) {
+        if (this.closed)
+            throw new CmuxConnectionError("session socket closed");
+        if (this.connected)
+            this.write(json);
+        else
+            this.pending.push(json);
+    }
+    onMessage(handler) {
+        this.messageHandlers.add(handler);
+        return () => this.messageHandlers.delete(handler);
+    }
+    onClose(handler) {
+        this.closeHandlers.add(handler);
+        if (this.closed)
+            queueMicrotask(handler);
+        return () => this.closeHandlers.delete(handler);
+    }
+    onError(handler) {
+        this.errorHandlers.add(handler);
+        return () => this.errorHandlers.delete(handler);
+    }
+    close() {
+        if (!this.closed)
+            this.socket.destroy();
+    }
+    write(json) {
+        this.socket.write(`${json}\n`, "utf8", (error) => {
+            if (error)
+                this.fail(new CmuxConnectionError(`socket write failed: ${error.message}`));
+        });
+    }
+    receive(chunk) {
+        this.buffer += chunk;
+        for (;;) {
+            const index = this.buffer.indexOf("\n");
+            if (index < 0)
+                return;
+            const line = this.buffer.slice(0, index);
+            this.buffer = this.buffer.slice(index + 1);
+            if (line.trim() === "")
+                continue;
+            for (const handler of this.messageHandlers)
+                handler(line);
+        }
+    }
+    fail(error) {
+        for (const handler of this.errorHandlers)
+            handler(error);
+    }
+    finish() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.pending.length = 0;
+        for (const handler of this.closeHandlers)
+            handler();
+    }
+}