@tangle-network/sandbox-ui 0.113.7 → 0.115.0

package/dist/use-pty-session-C8cE0adT.js

@@ -0,0 +1,669 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+//#region src/hooks/use-pty-session.ts
+function createEmptyBatch() {
+	return {
+		data: "",
+		waiters: []
+	};
+}
+/**
+* Time we wait for the terminal WebSocket to reach server-confirmed READY
+* before falling back to the HTTP+SSE transport. The cold terminal-WS
+* upgrade can traverse several proxy hops (browser → app worker → sandbox
+* edge → orchestrator dial → host-agent → sidecar) and take a few seconds
+* to establish; the budget must cover the full OPEN → init → ready exchange
+* so the direct WS path wins instead of dropping through to the fallback
+* dial on a cold connect.
+*/
+const WS_READY_TIMEOUT_MS = 1e4;
+/** Convert an http(s) base URL into the matching ws(s) URL. */
+function toWsUrl(apiUrl, sessionId) {
+	try {
+		const base = typeof window !== "undefined" ? window.location.href : void 0;
+		const url = new URL(`${apiUrl}/terminals/${sessionId}/ws`, base);
+		if (url.protocol === "https:") url.protocol = "wss:";
+		else if (url.protocol === "http:") url.protocol = "ws:";
+		else return null;
+		return url.toString();
+	} catch {
+		return null;
+	}
+}
+/**
+* Encode the bearer token as a WebSocket subprotocol identifier.
+*
+* Browsers cannot set the `Authorization` header on a WebSocket
+* upgrade. The naive workaround — putting the token in a query
+* parameter — is a real security risk: query strings are routinely
+* captured in edge-proxy access logs, browser DevTools network
+* panels, referrer headers on internal links, and log-aggregation
+* systems where they may be retained for years. Move the token to
+* `Sec-WebSocket-Protocol` instead, which is a request *header* and
+* is treated like other auth headers by the same systems (i.e. not
+* surfaced in URL-shaped logs).
+*
+* Per RFC 7230 a subprotocol identifier is a `token`, which excludes
+* `+`, `/`, and `=`. Bearer tokens minted by the sandbox API are
+* not guaranteed to satisfy that grammar, so we base64url-encode the
+* value first. The matching server reverses the encoding before
+* validating.
+*
+* The credential is offered alongside {@link TERMINAL_WS_ECHO_SUBPROTOCOL}.
+* A server must never echo `bearer.<…>` — that would put the live credential
+* in a response header — so it selects the marker instead. The marker is
+* required, not decorative: Chrome fails a handshake with "Sent non-empty
+* 'Sec-WebSocket-Protocol' header but no response was received" when the
+* client offered subprotocols and the server selected none, so a
+* credential-only offer can never complete against a correct server.
+*/
+const BEARER_SUBPROTOCOL_PREFIX = "bearer.";
+/**
+* Non-credential subprotocol the server echoes into the 101 to satisfy the
+* client's subprotocol negotiation. Must match the value the backends select
+* (`TERMINAL_WS_ECHO_SUBPROTOCOL` in sandbox-api / the sidecar's
+* `ws-subprotocol-auth`).
+*/
+const TERMINAL_WS_ECHO_SUBPROTOCOL = "tangle.terminal.v1";
+function toBearerSubprotocol(token) {
+	if (typeof btoa === "undefined") return null;
+	let encoded;
+	try {
+		encoded = btoa(token);
+	} catch {
+		return null;
+	}
+	return `${BEARER_SUBPROTOCOL_PREFIX}${encoded.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "")}`;
+}
+const DEFAULT_TERMINAL_COLS = 80;
+const DEFAULT_TERMINAL_ROWS = 24;
+function createTerminalConnectionId() {
+	const cryptoApi = globalThis.crypto;
+	if (cryptoApi && typeof cryptoApi.randomUUID === "function") return `terminal-${cryptoApi.randomUUID()}`;
+	return `terminal-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+function interactiveIdentityKey(incarnationId, control) {
+	if (incarnationId === void 0 && control === void 0) return "plain";
+	if (incarnationId === void 0 || control === void 0) return `incomplete:${incarnationId ?? ""}`;
+	return [
+		incarnationId,
+		control.refDigest,
+		String(control.generation),
+		control.leaseId,
+		control.holderId,
+		control.expiresAt
+	].join("\0");
+}
+/**
+* Manages a PTY session against the sidecar terminal API.
+*
+* Transport:
+*   1. Try the current sidecar WebSocket contract directly:
+*      GET /terminals/:id/ws, then send `{"type":"init",...}`.
+*      - Server → client: BINARY frames carrying PTY output; TEXT frames
+*        carrying lifecycle/control messages.
+*      - Client → server: TEXT frames carrying JSON input/resize messages.
+*   2. If direct WS does not reach server `ready` within
+*      WS_READY_TIMEOUT_MS, or it errors before ready, fall back to the older
+*      terminal contract:
+*      - POST /terminals creates the session.
+*      - GET /terminals/:id/ws tries the older WS transport.
+*      - GET /terminals/:id/stream (SSE for output)
+*      - POST /terminals/:id/input (one batched POST at a time)
+*      - PATCH /terminals/:id (resize)
+*   3. DELETE /terminals/:id closes sessions created by the older REST API.
+*
+* The WS path eliminates the per-keystroke HTTP round-trip that
+* dominates typing latency through edge proxies; the HTTP+SSE path is
+* preserved as a fallback so the hook keeps working against
+* deployments that have not yet shipped the WS endpoint.
+*/
+function usePtySession({ apiUrl, token, onData, connectionId: providedConnectionId, incarnationId, control }) {
+	const [isConnected, setIsConnected] = useState(false);
+	const [error, setError] = useState(null);
+	const sessionIdRef = useRef(null);
+	const connectGenRef = useRef(0);
+	const abortRef = useRef(null);
+	const retryTimerRef = useRef(void 0);
+	const retryCountRef = useRef(0);
+	const mountedRef = useRef(true);
+	const onDataRef = useRef(onData);
+	const tokenRef = useRef(token);
+	const incarnationIdRef = useRef(incarnationId);
+	const controlRef = useRef(control);
+	const exactAttachRequiredRef = useRef(incarnationId !== void 0 || control !== void 0);
+	const connectStreamRef = useRef(null);
+	const reconnectRef = useRef(null);
+	const shouldDeleteSessionRef = useRef(false);
+	const transportReadyRef = useRef(false);
+	const protocolFailureRef = useRef(false);
+	const colsRef = useRef(DEFAULT_TERMINAL_COLS);
+	const rowsRef = useRef(DEFAULT_TERMINAL_ROWS);
+	const wsRef = useRef(null);
+	const pendingWsRef = useRef(null);
+	const geometryPendingRef = useRef(false);
+	const pendingBatchRef = useRef(createEmptyBatch());
+	const drainPromiseRef = useRef(null);
+	const inputAbortRef = useRef(null);
+	const ensureDrainRunningRef = useRef(null);
+	const rejectPendingInput = useCallback((reason) => {
+		const batch = pendingBatchRef.current;
+		if (batch.waiters.length === 0) {
+			pendingBatchRef.current = createEmptyBatch();
+			return;
+		}
+		pendingBatchRef.current = createEmptyBatch();
+		const err = new Error(reason);
+		for (const w of batch.waiters) w.reject(err);
+	}, []);
+	const abortStream = useCallback(() => {
+		if (retryTimerRef.current) {
+			clearTimeout(retryTimerRef.current);
+			retryTimerRef.current = void 0;
+		}
+		if (abortRef.current) {
+			abortRef.current.abort();
+			abortRef.current = null;
+		}
+	}, []);
+	const closeWs = useCallback(() => {
+		const active = wsRef.current;
+		if (active) {
+			wsRef.current = null;
+			try {
+				active.close();
+			} catch {}
+		}
+		const pending = pendingWsRef.current;
+		if (pending) {
+			pendingWsRef.current = null;
+			try {
+				pending.close();
+			} catch {}
+		}
+	}, []);
+	const cleanup = useCallback(() => {
+		abortStream();
+		closeWs();
+		if (inputAbortRef.current) {
+			inputAbortRef.current.abort();
+			inputAbortRef.current = null;
+		}
+		transportReadyRef.current = false;
+		geometryPendingRef.current = false;
+		if (sessionIdRef.current) {
+			const sid = sessionIdRef.current;
+			const shouldDeleteSession = shouldDeleteSessionRef.current;
+			sessionIdRef.current = null;
+			shouldDeleteSessionRef.current = false;
+			if (shouldDeleteSession) fetch(`${apiUrl}/terminals/${sid}`, {
+				method: "DELETE",
+				headers: { Authorization: `Bearer ${tokenRef.current}` },
+				credentials: "include"
+			}).catch(() => {});
+		}
+		rejectPendingInput("Terminal session is not connected");
+		setIsConnected(false);
+	}, [
+		apiUrl,
+		abortStream,
+		closeWs,
+		rejectPendingInput
+	]);
+	const connectWs = useCallback((sessionId, options = {}) => {
+		return new Promise((resolve) => {
+			if (typeof WebSocket === "undefined") {
+				resolve(false);
+				return;
+			}
+			const wsUrl = toWsUrl(apiUrl, sessionId);
+			if (!wsUrl) {
+				resolve(false);
+				return;
+			}
+			const subprotocol = toBearerSubprotocol(tokenRef.current);
+			if (!subprotocol) {
+				resolve(false);
+				return;
+			}
+			let ws;
+			try {
+				ws = new WebSocket(wsUrl, [TERMINAL_WS_ECHO_SUBPROTOCOL, subprotocol]);
+			} catch {
+				resolve(false);
+				return;
+			}
+			ws.binaryType = "arraybuffer";
+			pendingWsRef.current = ws;
+			const isCurrentSocket = () => wsRef.current === ws || pendingWsRef.current === ws;
+			let opened = false;
+			let settled = false;
+			const settle = (ok) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(handshakeTimer);
+				resolve(ok);
+			};
+			const handshakeTimer = setTimeout(() => {
+				try {
+					ws.close();
+				} catch {}
+				settle(false);
+			}, WS_READY_TIMEOUT_MS);
+			const failProtocol = (message) => {
+				protocolFailureRef.current = true;
+				transportReadyRef.current = false;
+				if (wsRef.current === ws) wsRef.current = null;
+				setIsConnected(false);
+				setError(message);
+				rejectPendingInput(message);
+				try {
+					ws.close();
+				} catch {}
+				settle(false);
+			};
+			ws.onopen = () => {
+				opened = true;
+				if (pendingWsRef.current !== ws || !mountedRef.current) {
+					try {
+						ws.close();
+					} catch {}
+					settle(false);
+					return;
+				}
+				pendingWsRef.current = null;
+				if (options.initOnOpen) try {
+					const initIncarnationId = incarnationIdRef.current;
+					const initControl = controlRef.current;
+					if (exactAttachRequiredRef.current && (!initIncarnationId || !initControl)) throw new Error("Interactive terminal identity is incomplete");
+					ws.send(JSON.stringify({
+						type: "init",
+						...initIncarnationId !== void 0 ? { incarnationId: initIncarnationId } : {},
+						...initControl !== void 0 ? { control: initControl } : {},
+						cols: colsRef.current,
+						rows: rowsRef.current
+					}));
+					geometryPendingRef.current = false;
+				} catch {
+					try {
+						ws.close();
+					} catch {}
+					settle(false);
+					return;
+				}
+				if (protocolFailureRef.current) return;
+				wsRef.current = ws;
+			};
+			ws.onmessage = (ev) => {
+				if (!mountedRef.current || !isCurrentSocket()) return;
+				const data = ev.data;
+				let text;
+				if (typeof data === "string") text = data;
+				else if (data instanceof ArrayBuffer) text = new TextDecoder().decode(data);
+				else if (ArrayBuffer.isView(data)) text = new TextDecoder().decode(data);
+				else {
+					data.text().then((t) => {
+						if (mountedRef.current && isCurrentSocket()) onDataRef.current(t);
+					}).catch(() => {});
+					return;
+				}
+				if (typeof data === "string") try {
+					const event = JSON.parse(text);
+					if (event !== null && typeof event === "object" && !Array.isArray(event)) {
+						const controlFrame = event;
+						switch (controlFrame.type) {
+							case "ready":
+								transportReadyRef.current = true;
+								setIsConnected(true);
+								setError(null);
+								retryCountRef.current = 0;
+								settle(true);
+								return;
+							case "error": {
+								const message = typeof controlFrame.message === "string" ? controlFrame.message : "Terminal WebSocket error";
+								if (!transportReadyRef.current) failProtocol(message);
+								else setError(message);
+								return;
+							}
+							case "exit":
+								transportReadyRef.current = false;
+								setIsConnected(false);
+								return;
+							case "rec":
+							case "rec.done": return;
+							default: {
+								const frameType = typeof controlFrame.type === "string" ? controlFrame.type : "<missing type>";
+								failProtocol(`Unknown terminal control frame: ${frameType}`);
+								return;
+							}
+						}
+					}
+				} catch {}
+				if (text) onDataRef.current(text);
+			};
+			ws.onerror = () => {};
+			ws.onclose = () => {
+				if (pendingWsRef.current === ws) pendingWsRef.current = null;
+				const wasActive = wsRef.current === ws;
+				const wasReady = wasActive && transportReadyRef.current;
+				if (wasActive) {
+					wsRef.current = null;
+					transportReadyRef.current = false;
+				}
+				if (!opened) {
+					settle(false);
+					return;
+				}
+				if (!wasReady) {
+					settle(false);
+					return;
+				}
+				if (protocolFailureRef.current || !wasActive || !mountedRef.current) return;
+				setIsConnected(false);
+				if (sessionIdRef.current) retryTimerRef.current = setTimeout(() => {
+					if (mountedRef.current && sessionIdRef.current) {
+						if (shouldDeleteSessionRef.current) connectStreamRef.current?.(sessionIdRef.current);
+						else reconnectRef.current?.();
+					}
+				}, 1e3);
+			};
+		});
+	}, [apiUrl, rejectPendingInput]);
+	const patchGeometry = useCallback(async (sessionId, cols, rows) => {
+		try {
+			const res = await fetch(`${apiUrl}/terminals/${sessionId}`, {
+				method: "PATCH",
+				headers: {
+					Authorization: `Bearer ${tokenRef.current}`,
+					"Content-Type": "application/json"
+				},
+				credentials: "include",
+				body: JSON.stringify({
+					cols,
+					rows
+				})
+			});
+			if (!res.ok) console.error("Failed to resize terminal:", res.status);
+		} catch (err) {
+			console.error("Failed to resize terminal", err);
+		}
+	}, [apiUrl]);
+	const connectStream = useCallback(async (sessionId) => {
+		if (exactAttachRequiredRef.current) throw new Error("Interactive terminal requires an exact WebSocket attachment");
+		abortStream();
+		setError(null);
+		try {
+			const controller = new AbortController();
+			abortRef.current = controller;
+			const streamRes = await fetch(`${apiUrl}/terminals/${sessionId}/stream`, {
+				headers: { Authorization: `Bearer ${tokenRef.current}` },
+				credentials: "include",
+				signal: controller.signal
+			});
+			if (!streamRes.ok || !streamRes.body) {
+				const err = /* @__PURE__ */ new Error(`SSE stream failed: ${streamRes.status}`);
+				err.httpStatus = streamRes.status;
+				throw err;
+			}
+			if (mountedRef.current) {
+				transportReadyRef.current = true;
+				setIsConnected(true);
+				setError(null);
+				retryCountRef.current = 0;
+				ensureDrainRunningRef.current?.();
+				if (geometryPendingRef.current) {
+					geometryPendingRef.current = false;
+					patchGeometry(sessionId, colsRef.current, rowsRef.current);
+				}
+			}
+			const reader = streamRes.body.getReader();
+			const decoder = new TextDecoder();
+			let buffer = "";
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				buffer += decoder.decode(value, { stream: true });
+				const frames = buffer.split("\n\n");
+				buffer = frames.pop() ?? "";
+				for (const frame of frames) {
+					if (!frame.trim()) continue;
+					for (const line of frame.split("\n")) if (line.startsWith("data:")) {
+						const raw = line.slice(5).trim();
+						if (!raw) continue;
+						try {
+							const event = JSON.parse(raw);
+							if (event.type === "data.stdout" || event.type === "data.stderr") {
+								const text = event.properties?.text ?? "";
+								if (text && mountedRef.current) onDataRef.current(text);
+							}
+						} catch {
+							if (mountedRef.current) onDataRef.current(raw);
+						}
+					}
+				}
+			}
+			if (mountedRef.current) {
+				transportReadyRef.current = false;
+				setIsConnected(false);
+				retryTimerRef.current = setTimeout(() => {
+					if (mountedRef.current && sessionIdRef.current) connectStreamRef.current?.(sessionIdRef.current);
+				}, 1e3);
+			}
+		} catch (err) {
+			if (err.name === "AbortError") return;
+			if (mountedRef.current) {
+				const message = err instanceof Error ? err.message : "Stream connection failed";
+				setError(message);
+				transportReadyRef.current = false;
+				setIsConnected(false);
+				const httpStatus = err.httpStatus;
+				if (!(httpStatus !== void 0 && httpStatus >= 400 && httpStatus < 500) && retryCountRef.current < 8) {
+					const delay = Math.min(3e3 * Math.pow(2, retryCountRef.current), 3e4);
+					retryCountRef.current++;
+					retryTimerRef.current = setTimeout(() => {
+						if (mountedRef.current && sessionIdRef.current) connectStreamRef.current?.(sessionIdRef.current);
+					}, delay);
+				}
+			}
+		}
+	}, [
+		apiUrl,
+		abortStream,
+		patchGeometry
+	]);
+	onDataRef.current = onData;
+	tokenRef.current = token;
+	incarnationIdRef.current = incarnationId;
+	controlRef.current = control;
+	exactAttachRequiredRef.current = incarnationId !== void 0 || control !== void 0;
+	connectStreamRef.current = connectStream;
+	const exactIdentityKey = interactiveIdentityKey(incarnationId, control);
+	const connect = useCallback(async () => {
+		cleanup();
+		const myGen = ++connectGenRef.current;
+		protocolFailureRef.current = false;
+		retryCountRef.current = 0;
+		setError(null);
+		if (exactAttachRequiredRef.current && (!incarnationIdRef.current || !controlRef.current)) {
+			setError("Interactive terminal identity is incomplete");
+			return;
+		}
+		try {
+			const connectionId = providedConnectionId ?? createTerminalConnectionId();
+			if (!mountedRef.current) return;
+			sessionIdRef.current = connectionId;
+			shouldDeleteSessionRef.current = false;
+			transportReadyRef.current = false;
+			inputAbortRef.current = new AbortController();
+			const directWsOk = await connectWs(connectionId, { initOnOpen: true });
+			if (!mountedRef.current || connectGenRef.current !== myGen) return;
+			if (protocolFailureRef.current) return;
+			ensureDrainRunningRef.current?.();
+			if (directWsOk) return;
+			if (exactAttachRequiredRef.current) throw new Error("Interactive terminal WebSocket attach failed; exact identity was not accepted");
+			sessionIdRef.current = null;
+			transportReadyRef.current = false;
+			if (inputAbortRef.current) {
+				inputAbortRef.current.abort();
+				inputAbortRef.current = null;
+			}
+			const res = await fetch(`${apiUrl}/terminals`, {
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${tokenRef.current}`,
+					"Content-Type": "application/json"
+				},
+				credentials: "include",
+				body: JSON.stringify({
+					cols: colsRef.current,
+					rows: rowsRef.current
+				})
+			});
+			geometryPendingRef.current = false;
+			if (!res.ok) throw new Error(`Failed to create terminal: ${res.status}`);
+			const body = await res.json();
+			const sessionId = body.data?.sessionId ?? body.sessionId;
+			if (!sessionId) throw new Error("No sessionId in response");
+			if (!mountedRef.current) return;
+			sessionIdRef.current = sessionId;
+			shouldDeleteSessionRef.current = true;
+			transportReadyRef.current = false;
+			inputAbortRef.current = new AbortController();
+			const wsOk = await connectWs(sessionId, { initOnOpen: true });
+			if (!mountedRef.current || connectGenRef.current !== myGen) return;
+			if (protocolFailureRef.current) return;
+			ensureDrainRunningRef.current?.();
+			if (wsOk) return;
+			await connectStream(sessionId);
+		} catch (err) {
+			if (err.name === "AbortError") return;
+			if (mountedRef.current) {
+				const message = err instanceof Error ? err.message : "Terminal connection failed";
+				setError(message);
+				transportReadyRef.current = false;
+				setIsConnected(false);
+			}
+		}
+	}, [
+		apiUrl,
+		providedConnectionId,
+		cleanup,
+		connectWs,
+		connectStream,
+		exactIdentityKey
+	]);
+	reconnectRef.current = connect;
+	const resizeTerminal = useCallback(async (cols, rows) => {
+		if (cols > 0) colsRef.current = cols;
+		if (rows > 0) rowsRef.current = rows;
+		const sid = sessionIdRef.current;
+		if (!sid || cols <= 0 || rows <= 0) return;
+		const ws = wsRef.current;
+		if (ws && ws.readyState === WebSocket.OPEN) try {
+			ws.send(JSON.stringify({
+				type: "resize",
+				cols,
+				rows
+			}));
+			return;
+		} catch (err) {
+			console.warn("Terminal resize over WS failed; falling back to HTTP", err);
+		}
+		if (pendingWsRef.current) {
+			geometryPendingRef.current = true;
+			return;
+		}
+		if (exactAttachRequiredRef.current) throw new Error("Interactive terminal is not attached with its exact identity");
+		await patchGeometry(sid, cols, rows);
+	}, [apiUrl, patchGeometry]);
+	const drainInputQueue = useCallback(async () => {
+		while (pendingBatchRef.current.data.length > 0) {
+			const sid = sessionIdRef.current;
+			if (!sid || !transportReadyRef.current) return;
+			const batch = pendingBatchRef.current;
+			pendingBatchRef.current = createEmptyBatch();
+			const ws = wsRef.current;
+			if (ws && ws.readyState === WebSocket.OPEN) {
+				try {
+					ws.send(JSON.stringify({
+						type: "input",
+						data: batch.data
+					}));
+					for (const w of batch.waiters) w.resolve();
+				} catch (err) {
+					for (const w of batch.waiters) w.reject(err);
+				}
+				continue;
+			}
+			if (exactAttachRequiredRef.current) {
+				for (const w of batch.waiters) w.reject(/* @__PURE__ */ new Error("Interactive terminal is not attached with its exact identity"));
+				continue;
+			}
+			try {
+				const res = await fetch(`${apiUrl}/terminals/${sid}/input`, {
+					method: "POST",
+					headers: {
+						Authorization: `Bearer ${tokenRef.current}`,
+						"Content-Type": "application/json"
+					},
+					credentials: "include",
+					body: JSON.stringify({ data: batch.data }),
+					signal: inputAbortRef.current?.signal
+				});
+				if (!res.ok) {
+					const text = await res.text().catch(() => "");
+					throw new Error(text || `Input failed: ${res.status}`);
+				}
+				for (const w of batch.waiters) w.resolve();
+			} catch (err) {
+				const isAbort = err?.name === "AbortError";
+				const rejection = isAbort ? /* @__PURE__ */ new Error("Terminal session is not connected") : err;
+				if (!isAbort) console.error("Failed to send command", err);
+				for (const w of batch.waiters) w.reject(rejection);
+			}
+		}
+	}, [apiUrl]);
+	const ensureDrainRunning = useCallback(() => {
+		if (drainPromiseRef.current) return;
+		const run = () => drainInputQueue().finally(() => {
+			if (pendingBatchRef.current.data.length > 0 && sessionIdRef.current && transportReadyRef.current) drainPromiseRef.current = run();
+			else drainPromiseRef.current = null;
+		});
+		drainPromiseRef.current = run();
+	}, [drainInputQueue]);
+	ensureDrainRunningRef.current = ensureDrainRunning;
+	const sendCommand = useCallback((command) => {
+		return new Promise((resolve, reject) => {
+			if (command.length === 0) {
+				resolve();
+				return;
+			}
+			if (protocolFailureRef.current) {
+				reject(/* @__PURE__ */ new Error("Terminal protocol failure"));
+				return;
+			}
+			pendingBatchRef.current.data += command;
+			pendingBatchRef.current.waiters.push({
+				resolve,
+				reject
+			});
+			ensureDrainRunning();
+		});
+	}, [ensureDrainRunning]);
+	useEffect(() => {
+		mountedRef.current = true;
+		connect();
+		return () => {
+			mountedRef.current = false;
+			cleanup();
+		};
+	}, [connect, cleanup]);
+	return {
+		isConnected,
+		error,
+		sendCommand,
+		resizeTerminal,
+		reconnect: connect
+	};
+}
+//#endregion
+export { usePtySession as t };