overmux 0.0.3 → 0.0.5

package/dist/exports/client.js

@@ -1,9 +1,9 @@
 import "./style.css";
-import { i as overmuxLogoutPath, r as notificationSchema, s as resolveOvermuxReturnTo } from "./notifications-kDp16bU_.js";
+import { a as notificationSchema, c as parseDeepLink, l as resolveOvermuxReturnTo, o as overmuxLogoutPath, r as instanceIdSchema, t as createInstanceIdentity } from "./notifications-BFAD3QQl.js";
 import { z } from "zod";
 import { QueryClient, QueryClientProvider, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-import { Component, createContext, createElement, useCallback, useContext, useEffect, useMemo, useReducer, useRef, useState } from "react";
-import { formatKeyBinding, formatKeyBinding as formatKeyBinding$1, keyBindingSchema, keyBindingSchema as keyBindingSchema$1, matchesKeyBinding, matchesKeyBinding as matchesKeyBinding$1, platformBinding } from "@overmux/keybindings";
+import { Component, createContext, createElement, useCallback, useContext, useEffect, useMemo, useReducer, useRef, useState, useSyncExternalStore } from "react";
+import { formatKeyBinding, keyBindingSchema, matchesKeyBinding, platformBinding } from "@overmux/keybindings";
 import { createPortal } from "react-dom";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 //#region src/internal/shared/background-notifications.ts
@@ -28,7 +28,7 @@ const webSocketCloseCode = {
 const runtimeManifestSchema = z.object({
 	debug: z.boolean(),
 	operations: z.array(z.string().min(1)),
-	protocolVersion: z.literal(9),
+	protocolVersion: z.literal(10),
 	resources: z.array(z.string().min(1)),
 	streams: z.array(z.string().min(1))
 });
@@ -134,7 +134,12 @@ const protocolErrorMessageSchema = z.object({
 	subscriptionId: operationIdSchema.optional(),
 	type: z.literal("error")
 });
+const serverInfoMessageSchema = z.object({
+	type: z.literal("server-info"),
+	instanceId: instanceIdSchema
+}).strict();
 const serverProtocolMessageSchema = z.discriminatedUnion("type", [
+	serverInfoMessageSchema,
 	resourceResultMessageSchema,
 	resourceInvalidatedMessageSchema,
 	streamOpenedMessageSchema,
@@ -315,16 +320,16 @@ const writeClipboardText = async (text) => {
 };
 //#endregion
 //#region src/internal/client/client-definition.ts
-const shortcutBindingSchema = z.union([keyBindingSchema$1, z.array(keyBindingSchema$1).min(2)]);
+const shortcutBindingSchema = z.union([keyBindingSchema, z.array(keyBindingSchema).min(2)]);
 const commandBindingSchema = z.union([shortcutBindingSchema, z.object({
 	binding: shortcutBindingSchema,
 	when: z.object({ media: z.string().trim().min(1) })
 })]);
 const chordPrefixSchema = z.object({
-	binding: keyBindingSchema$1,
+	binding: keyBindingSchema,
 	unmatched: z.literal("replay-to-focused-input")
 });
-const formatShortcutBinding = (binding) => typeof binding === "string" ? formatKeyBinding$1(binding) : binding.map(formatKeyBinding$1).join(" ");
+const formatShortcutBinding = (binding) => typeof binding === "string" ? formatKeyBinding(binding) : binding.map(formatKeyBinding).join(" ");
 const validateBindings = (bindings) => bindings?.forEach((binding) => commandBindingSchema.parse(binding));
 const defineCommandRegistry = () => (commands) => Object.fromEntries(Object.entries(commands).map(([id, command]) => {
 	validateBindings(command.defaultBindings);
@@ -514,60 +519,107 @@ const useOperationById = (id, signal) => {
 const useStreamById = (id, input) => {
 	const { manifest, overmuxServerApi } = useRuntime();
 	const streamAvailable = manifest.streams.includes(id);
-	const [state, setState] = useState({ status: "opening" });
-	const listeners = useMemo(() => /* @__PURE__ */ new Set(), []);
 	const canonicalInput = useCanonicalInput(input);
+	const scope = useMemo(() => ({
+		canonicalInput,
+		id,
+		overmuxServerApi,
+		streamAvailable
+	}), [
+		canonicalInput,
+		id,
+		overmuxServerApi,
+		streamAvailable
+	]);
+	const [state, setState] = useState({
+		scope,
+		status: "opening"
+	});
+	const [listeners] = useState(() => /* @__PURE__ */ new Set());
 	const streamRef = useRef(void 0);
 	useEffect(() => {
 		streamRef.current?.close();
 		streamRef.current = void 0;
-		if (!streamAvailable) {
-			setState({ status: "closed" });
+		if (!scope.streamAvailable) {
+			setState({
+				scope,
+				status: "closed"
+			});
 			return;
 		}
-		setState({ status: "opening" });
-		const stream = overmuxServerApi.openStream({
-			id,
-			input: canonicalInput,
-			onClose: () => setState({ status: "closed" }),
-			onError: (error) => setState({
+		setState({
+			scope,
+			status: "opening"
+		});
+		let active = true;
+		const stream = scope.overmuxServerApi.openStream({
+			id: scope.id,
+			input: scope.canonicalInput,
+			onClose: () => active && setState({
+				scope,
+				status: "closed"
+			}),
+			onError: (error) => active && setState({
+				scope,
 				error,
 				status: "closed"
 			}),
-			onOpen: () => setState({ status: "open" }),
-			onMessage: (message) => listeners.forEach((listener) => listener(message))
+			onOpen: () => active && setState({
+				scope,
+				connectionId: Symbol(scope.id),
+				status: "open"
+			}),
+			onMessage: (message) => active && listeners.forEach((listener) => listener(message))
 		});
-		streamRef.current = stream;
-		return () => {
-			stream.close();
-			if (streamRef.current === stream) streamRef.current = void 0;
+		const connection = {
+			close: () => {
+				if (!active) return;
+				active = false;
+				if (streamRef.current === connection) streamRef.current = void 0;
+				setState({
+					scope,
+					status: "closed"
+				});
+				stream.close();
+			},
+			send: stream.send
 		};
-	}, [
-		canonicalInput,
-		id,
-		listeners,
-		overmuxServerApi,
-		streamAvailable
-	]);
-	const close = useCallback(() => {
-		streamRef.current?.close();
-		streamRef.current = void 0;
-		setState({ status: "closed" });
-	}, []);
-	const send = useCallback((message) => streamRef.current?.send(message) ?? false, []);
-	const subscribe = useCallback((listener) => {
-		listeners.add(listener);
-		return () => listeners.delete(listener);
-	}, [listeners]);
+		streamRef.current = connection;
+		return connection.close;
+	}, [listeners, scope]);
+	const [methods] = useState(() => ({
+		close: () => streamRef.current?.close(),
+		send: (message) => streamRef.current?.send(message) ?? false,
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		}
+	}));
+	if (!streamAvailable) return {
+		...methods,
+		connectionId: void 0,
+		error: /* @__PURE__ */ new Error(`Stream is not available: ${id}`),
+		status: "closed"
+	};
+	if (state.scope !== scope) return {
+		...methods,
+		connectionId: void 0,
+		status: "opening"
+	};
 	return {
-		close,
-		error: streamAvailable ? state.error : /* @__PURE__ */ new Error(`Stream is not available: ${id}`),
-		send,
-		status: streamAvailable ? state.status : "closed",
-		subscribe
+		...methods,
+		connectionId: state.connectionId,
+		error: state.error,
+		status: state.status
 	};
 };
+const undiscoveredInstance = () => void 0;
+const useInstance = () => {
+	const { overmuxServerApi } = useRuntime();
+	return useSyncExternalStore(overmuxServerApi.subscribeInstance, overmuxServerApi.getInstance, undiscoveredInstance);
+};
 const createOvermuxHooks = () => ({
+	useInstance,
 	useOperation: ({ id, signal }) => {
 		return useOperationById(id, signal);
 	},
@@ -614,6 +666,10 @@ const availableName = (names, kind, name) => {
 	return name;
 };
 const createOvermuxServerApi = ({ manifest, transport }) => ({
+	getInstance: transport.getInstance,
+	subscribeInstance: transport.subscribeInstance,
+	getInstanceId: () => transport.getInstance()?.instanceId,
+	getDeepLinkPrefix: () => transport.getInstance()?.deepLinkPrefix,
 	executeOperation: (id, input, signal) => {
 		if (!manifest.operations.includes(id)) throw new Error(`Operation is not available: ${id}`);
 		return transport.invokeOperation({
@@ -731,12 +787,79 @@ const installNotificationForwarding = (transport) => transport.subscribeNotifica
 	if (notification.success) window.overmuxHost?.notifications?.show(notification.data);
 });
 //#endregion
+//#region src/internal/client/host/instance-forwarding.ts
+const installInstanceForwarding = (transport) => {
+	const report = () => {
+		const identity = transport.getInstance();
+		const bridge = window.overmuxHost?.instance;
+		if (!identity || bridge?.version !== 1) return;
+		try {
+			bridge.report({ instanceId: identity.instanceId });
+		} catch (cause) {
+			console.error("Overmux host instance reporting failed", cause);
+		}
+	};
+	const unsubscribe = transport.subscribeInstance(report);
+	report();
+	return unsubscribe;
+};
+//#endregion
+//#region src/internal/client/host/deep-link-navigation.ts
+const defaultNavigate = (route) => window.location.assign(route);
+/**
+* Intercepts overmux:// anchor activation inside the running app, including the
+* temporary anchors created by xterm's default link handler. Without this,
+* browser/PWA clicks dispatch the custom protocol to the OS, which fails in
+* Android PWAs where it is not possible to install an Overmux protocol handler.
+*
+* Validates the original URL and compares its instance ID with authenticated
+* runtime discovery. For same-instance links, preventDefault stops OS dispatch
+* and navigate receives only the local path, query, and fragment. By default,
+* this loads that route on the current origin; a supplied router callback avoids
+* a document reload. Instance IDs are never treated as network hostnames.
+*
+* Valid cross-instance links remain Desktop's responsibility. Browsers/PWAs
+* block unknown or different instances; all hosts block invalid links. Ordinary
+* links and clicks already cancelled by application code are left untouched.
+* Returns cleanup for the document listeners when the runtime unmounts.
+*/
+const installDeepLinkNavigation = ({ getInstance, navigate = defaultNavigate }) => {
+	const onClick = (event) => {
+		if (event.defaultPrevented || event.button > 1) return;
+		const anchor = event.composedPath().find((target) => target instanceof HTMLAnchorElement);
+		if (anchor?.protocol !== "overmux:") return;
+		let link;
+		try {
+			link = parseDeepLink(anchor.getAttribute("href") ?? "");
+		} catch {
+			event.preventDefault();
+			console.warn("Cannot open an invalid Overmux deep link.");
+			return;
+		}
+		if (link.instanceId !== getInstance()?.instanceId) {
+			if (window.overmuxHost?.version !== 1) {
+				event.preventDefault();
+				console.warn("Cannot open an Overmux link to an unknown or different instance in this browser.");
+			}
+			return;
+		}
+		event.preventDefault();
+		navigate(link.route);
+	};
+	document.addEventListener("click", onClick);
+	document.addEventListener("auxclick", onClick);
+	return () => {
+		document.removeEventListener("click", onClick);
+		document.removeEventListener("auxclick", onClick);
+	};
+};
+//#endregion
 //#region src/internal/client/shortcuts.tsx
 const bindingSequence = (binding) => typeof binding === "string" ? [binding] : [...binding];
 const normalizedBinding = (binding) => bindingSequence(binding).map((key) => platformBinding(key));
 const sequenceMatches = (binding, pending, event) => {
 	const sequence = normalizedBinding(binding);
-	return sequence.length > pending.length && pending.every((key, index) => sequence[index] === key) && matchesKeyBinding$1(sequence[pending.length], event);
+	return sequence.length > pending.length && pending.every((key, index) => sequence[index] === key) && matchesKeyBinding(sequence[pending.length], event);
 };
 const isTextInput = (element) => element instanceof HTMLInputElement || element instanceof HTMLSelectElement || element instanceof HTMLTextAreaElement || element instanceof HTMLElement && (element.isContentEditable || element.getAttribute("role") === "textbox");
 const acceptsTextInput = (bindings) => {
@@ -892,7 +1015,7 @@ const ShortcutHost = ({ children, definition, registrations, registrationRevisio
 				if (runShortcut(complete.shortcut, event, registrations)) event.stopPropagation();
 				return;
 			}
-			if (!pending.length) pendingTarget = definition.chordPrefixes?.some((prefix) => matchesKeyBinding$1(prefix.binding, event)) ? selectShortcutInputTarget(inputTargets, document.activeElement) : void 0;
+			if (!pending.length) pendingTarget = definition.chordPrefixes?.some((prefix) => matchesKeyBinding(prefix.binding, event)) ? selectShortcutInputTarget(inputTargets, document.activeElement) : void 0;
 			pending = [...pending, normalizedBinding(matches[0].binding)[pending.length]];
 			pendingEvents = [...pendingEvents, event];
 			event.preventDefault();
@@ -941,6 +1064,12 @@ const createWebSocketTransport = ({ createSocket = () => new WebSocket(socketUrl
 	let reconnectTimer;
 	let socket;
 	let status = "disconnected";
+	let instance;
+	const instanceListeners = /* @__PURE__ */ new Set();
+	const setInstance = (next) => {
+		instance = next;
+		instanceListeners.forEach((listener) => listener());
+	};
 	const diagnosticQueue = [];
 	const requests = /* @__PURE__ */ new Map();
 	const subscriptions = /* @__PURE__ */ new Map();
@@ -954,7 +1083,7 @@ const createWebSocketTransport = ({ createSocket = () => new WebSocket(socketUrl
 		statusListeners.forEach((listener) => listener(status));
 	};
 	const send = (message) => {
-		if (socket?.readyState !== WebSocket.OPEN) return false;
+		if (socket?.readyState !== WebSocket.OPEN || !instance) return false;
 		if (socket.bufferedAmount > maxWebSocketBufferedBytes) {
 			socket.close(1013, "client could not keep up");
 			return false;
@@ -1008,6 +1137,7 @@ const createWebSocketTransport = ({ createSocket = () => new WebSocket(socketUrl
 		requests.clear();
 	};
 	const reportDisconnect = () => {
+		setInstance(void 0);
 		const error = disconnected();
 		rejectRequests(error);
 		subscriptions.forEach(({ onError }) => onError(error));
@@ -1023,15 +1153,8 @@ const createWebSocketTransport = ({ createSocket = () => new WebSocket(socketUrl
 		const next = createSocket();
 		next.binaryType = "arraybuffer";
 		socket = next;
-		next.addEventListener("open", () => {
-			if (socket !== next) return;
-			reconnectDelay = 250;
-			setStatus("connected");
-			flushDiagnostics();
-			restore();
-		});
 		next.addEventListener("message", (event) => {
-			if (socket !== next) return;
+			if (socket !== next || disposed) return;
 			let decoded;
 			try {
 				decoded = decodeProtocolFrame(event.data);
@@ -1049,6 +1172,19 @@ const createWebSocketTransport = ({ createSocket = () => new WebSocket(socketUrl
 				return;
 			}
 			const message = parsed.data;
+			if (message.type === "server-info" && !instance) {
+				setInstance(createInstanceIdentity(message.instanceId));
+				reconnectDelay = 250;
+				setStatus("connected");
+				flushDiagnostics();
+				restore();
+				return;
+			}
+			if (!instance || message.type === "server-info") {
+				reportDisconnect();
+				next.close(1002, "expected server discovery before traffic");
+				return;
+			}
 			if (message.type === "update-available" || message.type === "restarting") lifecycleListeners.forEach((listener) => listener(message));
 			if (message.type === "notification") notificationListeners.forEach((listener) => listener(message));
 			if (message.type === "resource-invalidated") subscriptions.get(message.subscriptionId)?.onInvalidate();
@@ -1102,6 +1238,11 @@ const createWebSocketTransport = ({ createSocket = () => new WebSocket(socketUrl
 		});
 	};
 	return {
+		getInstance: () => instance,
+		subscribeInstance: (listener) => {
+			instanceListeners.add(listener);
+			return () => instanceListeners.delete(listener);
+		},
 		activate: () => {
 			active = true;
 			connect();
@@ -1135,7 +1276,7 @@ const createWebSocketTransport = ({ createSocket = () => new WebSocket(socketUrl
 				streamName
 			};
 			streams.set(streamId, stream);
-			stream.status = socket?.readyState === WebSocket.CONNECTING || send({
+			stream.status = status === "connecting" || send({
 				input,
 				operationId: streamId,
 				streamId,
@@ -1561,7 +1702,43 @@ const UpdatePopover = ({ transport }) => {
 	});
 };
 //#endregion
+//#region src/internal/client/host/environment.ts
+const browserPlatform = (navigator) => {
+	const { userAgent, maxTouchPoints } = navigator;
+	const identity = `${navigator.userAgentData?.platform ?? navigator.platform} ${userAgent}`;
+	if (/iPad|iPhone|iPod/i.test(identity) || /Mac/i.test(identity) && maxTouchPoints > 1) return "ios";
+	if (/Android/i.test(identity)) return "android";
+	if (/Win/i.test(identity)) return "windows";
+	if (/Mac/i.test(identity)) return "macos";
+	return /Linux/i.test(identity) ? "linux" : "unknown";
+};
+const desktopPlatform = (platform) => {
+	if (platform === "darwin") return "macos";
+	if (platform === "win32") return "windows";
+	return platform === "linux" ? "linux" : "unknown";
+};
+const installEnvironmentSelectors = () => {
+	const html = document.documentElement;
+	const host = window.overmuxHost;
+	const desktop = host?.version === 1;
+	const navigator = window.navigator;
+	html.dataset.omPlatform = desktop ? desktopPlatform(host.platform) : browserPlatform(navigator);
+	if (desktop) {
+		html.dataset.omHost = "desktop";
+		return () => {};
+	}
+	const displayMode = window.matchMedia("(display-mode: standalone), (display-mode: minimal-ui), (display-mode: window-controls-overlay)");
+	const updateHost = () => {
+		html.dataset.omHost = displayMode.matches || navigator.standalone === true ? "pwa" : "browser";
+	};
+	updateHost();
+	displayMode.addEventListener("change", updateHost);
+	return () => displayMode.removeEventListener("change", updateHost);
+};
+//#endregion
 //#region src/internal/client/host/overmux-host.tsx
+const disposeEnvironment = typeof window === "undefined" ? void 0 : installEnvironmentSelectors();
+import.meta.hot?.dispose(() => disposeEnvironment?.());
 var RootErrorBoundary = class extends Component {
 	state = {};
 	static getDerivedStateFromError(error) {
@@ -1616,6 +1793,11 @@ const OvermuxRuntime = ({ definition }) => {
 		transport.dispose();
 	}, [transport]);
 	useEffect(() => installNotificationForwarding(transport), [transport]);
+	useEffect(() => installInstanceForwarding(transport), [transport]);
+	useEffect(() => installDeepLinkNavigation({
+		getInstance: transport.getInstance,
+		navigate: definition.navigate
+	}), [transport, definition.navigate]);
 	const refreshCommands = useCallback(() => setRegistrationRevision((revision) => revision + 1), []);
 	const registerCommand = useCallback((registration) => {
 		registrations.add(registration);
@@ -1660,6 +1842,6 @@ const OvermuxHost = ({ definition }) => /* @__PURE__ */ jsx(OvermuxThemeScope, {
 	children: location.pathname === "/_overmux/settings" ? /* @__PURE__ */ jsx(HostedSettingsPage, {}) : location.pathname === "/_overmux/logout" ? /* @__PURE__ */ jsx(HostedLogoutPage, {}) : /* @__PURE__ */ jsx(OvermuxRuntime, { definition })
 });
 //#endregion
-export { OvermuxHost, OvermuxPortal, OvermuxThemeScope, chordPrefixSchema, commandBindingSchema, createOvermuxHooks, defineCommandRegistry, defineOvermuxClient, disableBackgroundNotifications, enableBackgroundNotifications, formatKeyBinding, formatShortcutBinding, keyBindingSchema, matchesKeyBinding, readClipboardText, shortcutBindingSchema, skipToken, useCommand, useCommands, useShortcutInputTarget, writeClipboardText };
+export { OvermuxHost, OvermuxPortal, OvermuxThemeScope, createOvermuxHooks, defineCommandRegistry, defineOvermuxClient, disableBackgroundNotifications, enableBackgroundNotifications, formatShortcutBinding, readClipboardText, skipToken, useCommand, useCommands, useShortcutInputTarget, writeClipboardText };
 
 //# sourceMappingURL=client.js.map