feat(sdk): eager DDPSDK connect, drop Meteor fallback from sdk.call/publish/stream

DDPSDK's Connection buffers outgoing messages until the WebSocket
handshake completes, so downstream call sites don't actually need an
isDdpSdkReady gate. Open the socket as soon as getDdpSdk() runs and
drop the Meteor fallback from sdk.call / sdk.publish / the stream
factory.

Pre-authentication, anonymous methods / streams still work (the SDK
queues them and flushes on 'connected'); authenticated methods will
surface a server auth error the same way an unauthenticated Meteor
call would. userIdStore continues to drive loginWithToken so the SDK
becomes authenticated as soon as either session resume or a fresh
login sets a uid.

createNewMeteorStream stays in the file for now (no longer reachable)
— removing it and the Meteor._stream('message') listener is left for
the cleanup pass once Meteor.connection is fully neutralised.

Author: ggazzo

apps/meteor/app/utils/client/lib/SDKClient.ts

@@ -268,9 +268,7 @@ const createStreamManager = () => {
 
 		const stream =
 			streams.get(eventLiteral) ||
-			(isDdpSdkReady()
-				? createNewDdpSdkStream(streamProxy, name as StreamNames, key as StreamKeys<StreamNames>, args)
-				: createNewMeteorStream(name as StreamNames, key as StreamKeys<StreamNames>, args));
+			createNewDdpSdkStream(streamProxy, name as StreamNames, key as StreamKeys<StreamNames>, args);
 
 		const stop = (): void => {
 			streamProxy.off(eventLiteral, proxyCallback);
@@ -322,27 +320,17 @@ const createStreamManager = () => {
 	return { stream, stopAll };
 };
 
-const isDdpSdkReady = (): boolean => {
-	const sdk = getDdpSdk();
-	return sdk.connection.status === 'connected' && Boolean(sdk.account.uid);
-};
-
 export const createSDK = (rest: RestClientInterface) => {
 	const { stream, stopAll } = createStreamManager();
 
 	const publish = (name: string, args: unknown[]) => {
-		if (isDdpSdkReady()) {
-			void getDdpSdk().client.callAsync(`stream-${name}`, ...args);
-			return;
-		}
-		Meteor.call(`stream-${name}`, ...args);
+		// DDPSDK queues writes until the WS handshake completes and reconnects
+		// automatically, so there's no longer a Meteor fallback path here.
+		void getDdpSdk().client.callAsync(`stream-${name}`, ...args);
 	};
 
 	const call = <T extends keyof ServerMethods>(method: T, ...args: Parameters<ServerMethods[T]>): Promise<ReturnType<ServerMethods[T]>> => {
-		if (isDdpSdkReady()) {
-			return getDdpSdk().client.callAsync(method, ...args) as Promise<ReturnType<ServerMethods[T]>>;
-		}
-		return Meteor.callAsync(method, ...args);
+		return getDdpSdk().client.callAsync(method, ...args) as Promise<ReturnType<ServerMethods[T]>>;
 	};
 
 	const disconnect = () => {

apps/meteor/client/lib/sdk/ddpSdk.ts

@@ -4,15 +4,15 @@ import EJSON from 'ejson';
 import { userIdStore } from '../user';
 
 /**
- * Phase 2 scaffolding for migrating the frontend off Meteor.connection onto
- * @rocket.chat/ddp-client.
+ * Primary DDP transport for the frontend, replacing Meteor.connection.
  *
- * The instance is constructed lazily pointing at the current origin. A
- * Zustand subscription on userIdStore keeps the SDK connected +
- * authenticated whenever a user is logged in (covering both session
- * resume and fresh logins) and tears it down on logout. Failures are
- * logged but non-fatal — the Meteor transport remains authoritative
- * while this runs in parallel.
+ * The lazy getter constructs the SDK on first use and eagerly opens the
+ * WebSocket. DDPSDK internally queues outgoing messages until the WS
+ * handshake completes, so sdk.call / sdk.stream / sdk.publish work the
+ * instant the module loads — no `isReady` gate needed at the call sites.
+ *
+ * A userIdStore subscription drives loginWithToken on login (session
+ * resume and fresh logins) and tears the connection down on logout.
  */
 
 const stripTrailingSlash = (value: string): string => (value.endsWith('/') ? value.slice(0, -1) : value);
@@ -47,6 +47,13 @@ export const getDdpSdk = (): DDPSDK => {
 	if (!instance) {
 		instance = DDPSDK.create(computeDdpUrl());
 		applyEjsonEncoding(instance);
+		// Open the socket immediately. DDPSDK queues everything written before
+		// the WS is open and flushes on 'connected', so downstream call sites
+		// don't have to care about timing.
+		void instance.connection.connect().catch((error) => {
+			// eslint-disable-next-line no-console
+			console.warn('[ddpSdk] initial connect failed', error);
+		});
 	}
 	return instance;
 };