make rpc config decoding tolerant and update contracts

.changeset/tolerant-server-config.md

@@ -0,0 +1,5 @@
+---
+"t3code-cli": patch
+---
+
+Keep RPC connections compatible with server config fields the CLI does not use.

package.json

@@ -117,7 +117,7 @@
   "devDependencies": {
     "@changesets/cli": "^2.31.1",
     "@effect/vitest": "catalog:",
-    "@t3tools/client-runtime": "workspace:*",
+    "@t3tools/client-runtime": "link:upstream-t3code/packages/client-runtime",
     "@t3tools/contracts": "workspace:*",
     "@total-typescript/shoehorn": "^0.1.2",
     "@types/node": "^26.1.2",

src/rpc/layer.ts

@@ -1,4 +1,3 @@
-import { RpcSessionFactory } from "@t3tools/client-runtime/rpc";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
@@ -11,6 +10,7 @@ import * as SynchronizedRef from "effect/SynchronizedRef";
 
 import { T3PreparedConnectionProvider } from "../connection/prepared.ts";
 import { RpcError } from "./error.ts";
+import { T3RpcSessionFactory } from "./session.ts";
 import { T3Rpc, type WsClient } from "./service.ts";
 
 const connectionRetrySchedule = Schedule.exponential("100 millis").pipe(
@@ -27,7 +27,7 @@ type Connection = {
 
 export const makeT3RpcLayer = Effect.fn("makeT3RpcLayer")(function* () {
   const preparedConnectionProvider = yield* T3PreparedConnectionProvider;
-  const sessions = yield* RpcSessionFactory;
+  const sessions = yield* T3RpcSessionFactory;
   const parentScope = yield* Scope.Scope;
   const connection = yield* SynchronizedRef.make(Option.none<Connection>());
   const openConnection = Effect.fn("T3RpcLive.openConnection")(function* () {

src/rpc/service.ts

@@ -1,10 +1,11 @@
-import type { RpcSession } from "@t3tools/client-runtime/rpc";
 import * as Context from "effect/Context";
 import type * as Effect from "effect/Effect";
+import type { RpcClient, RpcClientError } from "effect/unstable/rpc";
 
 import type { RpcError } from "./error.ts";
+import type { CliWsRpcGroup } from "./ws-group.ts";
 
-export type WsClient = RpcSession["client"];
+export type WsClient = RpcClient.FromGroup<typeof CliWsRpcGroup, RpcClientError.RpcClientError>;
 
 export type T3RpcService = {
   readonly getClient: Effect.Effect<WsClient, RpcError>;

src/rpc/session.ts

@@ -1,31 +1,51 @@
-import {
-  makeWsRpcProtocolClient,
-  type RpcSession,
-  RpcSessionFactory,
-} from "@t3tools/client-runtime/rpc";
 import {
   ConnectionBlockedError,
   type ConnectionAttemptError,
   ConnectionTransientError,
   type PreparedConnection,
 } from "@t3tools/client-runtime/connection";
 import { WS_METHODS } from "@t3tools/contracts";
+import * as Context from "effect/Context";
 import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Schedule from "effect/Schedule";
+import type * as Scope from "effect/Scope";
 import * as RpcClient from "effect/unstable/rpc/RpcClient";
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
 import * as Socket from "effect/unstable/socket/Socket";
 
+import type { WsClient as CliWsClient } from "./service.ts";
+import type { CliServerConfig } from "./ws-group.ts";
+import { CliWsRpcGroup } from "./ws-group.ts";
+
+interface T3RpcSession {
+  readonly client: CliWsClient;
+  readonly initialConfig: Effect.Effect<CliServerConfig, ConnectionAttemptError>;
+  readonly ready: Effect.Effect<void, ConnectionAttemptError>;
+  readonly probe: Effect.Effect<void, ConnectionAttemptError>;
+  readonly closed: Effect.Effect<never, ConnectionTransientError>;
+}
+
+export class T3RpcSessionFactory extends Context.Service<
+  T3RpcSessionFactory,
+  {
+    readonly connect: (
+      connection: PreparedConnection,
+    ) => Effect.Effect<T3RpcSession, ConnectionAttemptError, Scope.Scope>;
+  }
+>()("t3cli/T3RpcSessionFactory") {}
+
 type SessionRpcError =
-  | Effect.Error<ReturnType<RpcSession["client"][typeof WS_METHODS.serverGetConfig]>>
-  | Effect.Error<ReturnType<RpcSession["client"][typeof WS_METHODS.serverProbe]>>;
+  | Effect.Error<ReturnType<CliWsClient[typeof WS_METHODS.serverGetConfig]>>
+  | Effect.Error<ReturnType<CliWsClient[typeof WS_METHODS.serverProbe]>>;
+
+const makeClient = RpcClient.make(CliWsRpcGroup);
 
 const makeT3RpcSessionFactory = Effect.fn("makeT3RpcSessionFactory")(function* () {
   const webSocketConstructor = yield* Socket.WebSocketConstructor;
 
-  const connect: RpcSessionFactory["Service"]["connect"] = Effect.fnUntraced(function* (
+  const connect: T3RpcSessionFactory["Service"]["connect"] = Effect.fnUntraced(function* (
     connection: PreparedConnection,
   ) {
     yield* Effect.annotateCurrentSpan({
@@ -72,7 +92,7 @@ const makeT3RpcSessionFactory = Effect.fn("makeT3RpcSessionFactory")(function* (
     const protocolContext = yield* Layer.build(protocolLayer).pipe(
       Effect.withSpan("environment.websocket.connect"),
     );
-    const client = yield* makeWsRpcProtocolClient.pipe(Effect.provide(protocolContext));
+    const client = yield* makeClient.pipe(Effect.provide(protocolContext));
     const initialConfig = yield* Effect.cached(
       client[WS_METHODS.serverGetConfig]({}).pipe(
         catchSessionRpcErrors,
@@ -82,7 +102,7 @@ const makeT3RpcSessionFactory = Effect.fn("makeT3RpcSessionFactory")(function* (
     const probe = initialConfig.pipe(
       Effect.flatMap((config) =>
         Effect.gen(function* () {
-          if (config.environment.capabilities.connectionProbe === true) {
+          if (config.environment.capabilities.connectionProbe) {
             return yield* client[WS_METHODS.serverProbe]({});
           }
           return yield* client[WS_METHODS.serverGetConfig]({});
@@ -102,13 +122,13 @@ const makeT3RpcSessionFactory = Effect.fn("makeT3RpcSessionFactory")(function* (
       ),
       probe,
       closed: Deferred.await(disconnected),
-    } satisfies RpcSession;
+    } satisfies T3RpcSession;
   });
 
-  return RpcSessionFactory.of({ connect });
+  return T3RpcSessionFactory.of({ connect });
 });
 
-export const T3RpcSessionFactoryLive = Layer.effect(RpcSessionFactory, makeT3RpcSessionFactory());
+export const T3RpcSessionFactoryLive = Layer.effect(T3RpcSessionFactory, makeT3RpcSessionFactory());
 
 function catchSessionRpcErrors<A, R>(
   effect: Effect.Effect<A, SessionRpcError, R>,

src/rpc/ws-group.ts

@@ -0,0 +1,53 @@
+import {
+  EnvironmentAuthorizationError,
+  KeybindingsConfigError,
+  ServerProviders,
+  ServerSettingsError,
+  WS_METHODS,
+  WsOrchestrationDispatchCommandRpc,
+  WsOrchestrationGetArchivedShellSnapshotRpc,
+  WsOrchestrationSubscribeShellRpc,
+  WsOrchestrationSubscribeThreadRpc,
+  WsServerProbeRpc,
+  WsSubscribeTerminalEventsRpc,
+  WsSubscribeTerminalMetadataRpc,
+  WsTerminalAttachRpc,
+  WsTerminalCloseRpc,
+  WsTerminalOpenRpc,
+  WsTerminalResizeRpc,
+  WsTerminalWriteRpc,
+} from "@t3tools/contracts";
+import * as Schema from "effect/Schema";
+import { Rpc, RpcGroup } from "effect/unstable/rpc";
+
+export const CliServerConfig = Schema.Struct({
+  environment: Schema.Struct({
+    capabilities: Schema.Struct({
+      connectionProbe: Schema.Boolean,
+    }),
+  }),
+  providers: ServerProviders,
+});
+export type CliServerConfig = typeof CliServerConfig.Type;
+
+export const WsServerGetConfigRpc = Rpc.make(WS_METHODS.serverGetConfig, {
+  payload: Schema.Struct({}),
+  success: CliServerConfig,
+  error: Schema.Union([KeybindingsConfigError, ServerSettingsError, EnvironmentAuthorizationError]),
+});
+
+export const CliWsRpcGroup = RpcGroup.make(
+  WsTerminalOpenRpc,
+  WsTerminalAttachRpc,
+  WsTerminalWriteRpc,
+  WsTerminalResizeRpc,
+  WsTerminalCloseRpc,
+  WsSubscribeTerminalEventsRpc,
+  WsSubscribeTerminalMetadataRpc,
+  WsOrchestrationDispatchCommandRpc,
+  WsOrchestrationGetArchivedShellSnapshotRpc,
+  WsOrchestrationSubscribeShellRpc,
+  WsOrchestrationSubscribeThreadRpc,
+  WsServerProbeRpc,
+  WsServerGetConfigRpc,
+);