t3code-cli 0.11.0 → 0.13.0

package/src/config/selection/service.ts

@@ -0,0 +1,29 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+
+import { loadT3CliEnv } from "../env/env.ts";
+import { resolveConfiguredEnvironment } from "./resolve.ts";
+
+export class T3ConfigSelection extends Context.Service<
+  T3ConfigSelection,
+  {
+    readonly getSelectedEnvironment: () => Effect.Effect<string | undefined>;
+  }
+>()("t3cli/T3ConfigSelection") {}
+
+export const layer = Layer.effect(
+  T3ConfigSelection,
+  Effect.gen(function* () {
+    const t3CliEnv = yield* loadT3CliEnv;
+    return {
+      getSelectedEnvironment: () =>
+        Effect.sync(() =>
+          resolveConfiguredEnvironment({
+            t3cliEnv: Option.getOrUndefined(t3CliEnv.t3cliEnv),
+          }),
+        ),
+    };
+  }),
+);

package/src/config/temp-home.test-utils.ts

@@ -0,0 +1,7 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+
+export const makeTempHomeScoped = Effect.fn("makeTempHomeScoped")(function* (prefix: string) {
+  const fs = yield* FileSystem.FileSystem;
+  return yield* fs.makeTempDirectoryScoped({ prefix });
+});

package/src/config/types.ts

@@ -0,0 +1,49 @@
+import type {
+  EncryptedToken,
+  StoredConfigV2File,
+  StoredEnvironmentFile,
+} from "./persist/schema.ts";
+
+export type EncryptedEnvironment = StoredEnvironmentFile;
+
+export type EncryptedConfig = StoredConfigV2File;
+
+export type DecryptedEnvironment = {
+  readonly url: string;
+  readonly local: boolean;
+  readonly token: string;
+};
+
+export type DecryptedConfig = {
+  readonly version: 2;
+  readonly default?: string;
+  readonly environments: Readonly<Record<string, DecryptedEnvironment>>;
+};
+
+export type EnvironmentSummary = {
+  readonly name: string;
+  readonly url: string;
+  readonly local: boolean;
+  readonly default: boolean;
+};
+
+export type ResolvedConfig = {
+  readonly url: string;
+  readonly token: string;
+  readonly source: "env" | "config";
+  readonly local: boolean;
+  readonly environment?: string;
+};
+
+export type UpsertEnvironmentInput = {
+  readonly name: string;
+  readonly url: string;
+  readonly token: string;
+  readonly local: boolean;
+  readonly makeDefault?: boolean;
+};
+
+export type StoredConfig = DecryptedConfig;
+export type StoredEnvironment = DecryptedEnvironment;
+
+export type { EncryptedToken };

package/src/config/url/error.ts

@@ -0,0 +1,8 @@
+import * as Cause from "effect/Cause";
+import * as Schema from "effect/Schema";
+
+export class UrlError extends Schema.TaggedErrorClass<UrlError>()("UrlError", {
+  message: Schema.String,
+  protocol: Schema.optionalKey(Schema.String),
+  cause: Schema.optionalKey(Schema.instanceOf(Cause.IllegalArgumentError)),
+}) {}

package/src/config/url/index.ts

@@ -0,0 +1,7 @@
+export {
+  normalizeHttpBaseUrl,
+  toWebSocketBaseUrl,
+  toHttpEndpointUrl,
+  toWebSocketEndpointUrl,
+} from "./url.ts";
+export { UrlError } from "./error.ts";

package/src/config/url/url.test.ts

@@ -0,0 +1,31 @@
+import "vite-plus/test/config";
+
+import * as Effect from "effect/Effect";
+import { assert, describe, it } from "@effect/vitest";
+
+import { expectFailWithMessage } from "../../effect.test-utils.ts";
+import { UrlError } from "./error.ts";
+import { normalizeHttpBaseUrl, toWebSocketEndpointUrl } from "./url.ts";
+
+describe("normalizeHttpBaseUrl", () => {
+  it.effect("strips query and trailing slash from urls with paths", () =>
+    Effect.gen(function* () {
+      const normalized = yield* normalizeHttpBaseUrl("https://app.example.com/api/?q=1");
+      assert.equal(normalized, "https://app.example.com/api");
+    }),
+  );
+
+  it.effect("maps invalid urls to UrlError", () =>
+    expectFailWithMessage(normalizeHttpBaseUrl("not-a-url"), UrlError, "invalid url"),
+  );
+});
+
+describe("toWebSocketEndpointUrl", () => {
+  it.effect("rejects unsupported protocols with UrlError", () =>
+    expectFailWithMessage(
+      toWebSocketEndpointUrl("ftp://example.com", "/ws"),
+      UrlError,
+      "unsupported server url protocol: ftp:",
+    ),
+  );
+});

package/src/connection/error.ts

@@ -1,9 +1,12 @@
 import * as Schema from "effect/Schema";
 
+import { ConfigError } from "../config/error.ts";
+import { UrlError } from "../config/url/error.ts";
+
 export class T3CodeConnectionError extends Schema.TaggedErrorClass<T3CodeConnectionError>()(
   "T3CodeConnectionError",
   {
     message: Schema.String,
-    cause: Schema.optionalKey(Schema.Unknown),
+    cause: Schema.Union([ConfigError, UrlError]),
   },
 ) {}

package/src/connection/index.ts

@@ -1,6 +1,5 @@
 export { T3CodeConnectionError } from "./error.ts";
 export { T3CodeRpcLayer, makeT3CodeRpcLayer } from "./layer.ts";
-export { T3CodeNodeRpcLayer } from "./node.ts";
 export {
   T3CodeConnectionProvider,
   T3CodeConnectionProviderLive,

package/src/connection/layer.ts

@@ -1,10 +1,13 @@
 import * as Layer from "effect/Layer";
 
-import { T3AuthTransportLive } from "../auth/transport.ts";
+import { T3PreparedConnectionProviderLive } from "./prepared.ts";
 import { T3RpcLive } from "../rpc/layer.ts";
+import { T3RpcSessionFactoryLive } from "../rpc/session.ts";
 
 export function makeT3CodeRpcLayer() {
-  return T3RpcLive.pipe(Layer.provide(T3AuthTransportLive));
+  return T3RpcLive.pipe(
+    Layer.provide(Layer.mergeAll(T3PreparedConnectionProviderLive, T3RpcSessionFactoryLive)),
+  );
 }
 
 export const T3CodeRpcLayer = makeT3CodeRpcLayer();

package/src/connection/prepared.ts

@@ -0,0 +1,83 @@
+import { resolveRemoteWebSocketConnectionUrl } from "@t3tools/client-runtime/authorization";
+import {
+  BearerConnectionTarget,
+  type ConnectionAttemptError,
+  mapRemoteEnvironmentError,
+  type PreparedConnection,
+} from "@t3tools/client-runtime/connection";
+import { fetchRemoteEnvironmentDescriptor } from "@t3tools/client-runtime/environment";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { HttpClient } from "effect/unstable/http";
+
+import { toWebSocketEndpointUrl } from "../config/url/url.ts";
+import { T3CodeConnectionError } from "./error.ts";
+import { T3CodeConnectionProvider } from "./service.ts";
+import type { T3CodeConnection } from "./type.ts";
+
+export class T3PreparedConnectionProvider extends Context.Service<
+  T3PreparedConnectionProvider,
+  {
+    readonly get: Effect.Effect<PreparedConnection, ConnectionAttemptError | T3CodeConnectionError>;
+  }
+>()("t3cli/T3PreparedConnectionProvider") {}
+
+const makePreparedConnection = Effect.fn("makePreparedConnection")(function* (
+  connection: T3CodeConnection,
+) {
+  const httpBaseUrl = connection.origin.url;
+  const wsBaseUrl = yield* toWebSocketEndpointUrl(httpBaseUrl, "/ws").pipe(
+    Effect.mapError(
+      (error) =>
+        new T3CodeConnectionError({
+          message: "failed to resolve websocket endpoint",
+          cause: error,
+        }),
+    ),
+  );
+  const descriptor = yield* fetchRemoteEnvironmentDescriptor({ httpBaseUrl }).pipe(
+    Effect.mapError(mapRemoteEnvironmentError),
+  );
+  const socketUrl = yield* resolveRemoteWebSocketConnectionUrl({
+    httpBaseUrl,
+    wsBaseUrl,
+    bearerToken: connection.auth.token,
+  }).pipe(Effect.mapError(mapRemoteEnvironmentError));
+
+  return {
+    environmentId: descriptor.environmentId,
+    label: descriptor.label,
+    httpBaseUrl,
+    socketUrl,
+    httpAuthorization: {
+      _tag: "Bearer",
+      token: connection.auth.token,
+    },
+    target: new BearerConnectionTarget({
+      environmentId: descriptor.environmentId,
+      label: descriptor.label,
+      connectionId: descriptor.environmentId,
+    }),
+  } satisfies PreparedConnection;
+});
+
+const makeT3PreparedConnectionProvider = Effect.fn("makeT3PreparedConnectionProvider")(
+  function* () {
+    const connectionProvider = yield* T3CodeConnectionProvider;
+    const httpClient = yield* HttpClient.HttpClient;
+    const get = connectionProvider.get.pipe(
+      Effect.flatMap((connection) =>
+        makePreparedConnection(connection).pipe(
+          Effect.provideService(HttpClient.HttpClient, httpClient),
+        ),
+      ),
+    );
+    return T3PreparedConnectionProvider.of({ get });
+  },
+);
+
+export const T3PreparedConnectionProviderLive = Layer.effect(
+  T3PreparedConnectionProvider,
+  makeT3PreparedConnectionProvider(),
+);

package/src/contracts/index.ts

@@ -5,4 +5,4 @@ export type {
   OrchestrationThread,
   OrchestrationThreadShell,
   ServerProvider,
-} from "#t3tools/contracts";
+} from "@t3tools/contracts";

package/src/domain/error.ts

@@ -55,6 +55,23 @@ export class TerminalLookupError extends Schema.TaggedErrorClass<TerminalLookupE
   },
 ) {}
 
+export class ProjectActionLookupError extends Schema.TaggedErrorClass<ProjectActionLookupError>()(
+  "ProjectActionLookupError",
+  {
+    message: Schema.String,
+    projectId: Schema.String,
+    selector: Schema.String,
+  },
+) {}
+
+export class ProjectActionValidationError extends Schema.TaggedErrorClass<ProjectActionValidationError>()(
+  "ProjectActionValidationError",
+  {
+    message: Schema.String,
+    projectId: Schema.String,
+  },
+) {}
+
 export type DomainError =
   | ProjectLookupError
   | ModelSelectionError
@@ -62,4 +79,6 @@ export type DomainError =
   | ThreadSessionError
   | ThreadLookupError
   | ProjectCreateVisibilityError
-  | TerminalLookupError;
+  | TerminalLookupError
+  | ProjectActionLookupError
+  | ProjectActionValidationError;

package/src/domain/helpers.test.ts

@@ -5,7 +5,7 @@ import * as NodeServices from "@effect/platform-node/NodeServices";
 import { assert, describe, it } from "@effect/vitest";
 import { fromPartial } from "@total-typescript/shoehorn";
 
-import type { OrchestrationShellSnapshot } from "#t3tools/contracts";
+import type { OrchestrationShellSnapshot } from "@t3tools/contracts";
 
 import { resolveProjectScope } from "./helpers.ts";
 

package/src/domain/helpers.ts

@@ -1,6 +1,6 @@
 import * as Effect from "effect/Effect";
 import * as Path from "effect/Path";
-import type { OrchestrationProjectShell, OrchestrationShellSnapshot } from "#t3tools/contracts";
+import type { OrchestrationProjectShell, OrchestrationShellSnapshot } from "@t3tools/contracts";
 
 export type ResolvedProjectScope = {
   readonly project: OrchestrationProjectShell;

package/src/domain/model-config.ts

@@ -1,4 +1,4 @@
-import type { ServerProvider } from "#t3tools/contracts";
+import type { ServerProvider } from "@t3tools/contracts";
 
 export function isSelectableProvider(provider: ServerProvider) {
   return provider.status === "ready" && provider.models.length > 0;

package/src/domain/thread-activities.test.ts

@@ -1,6 +1,6 @@
 import "vite-plus/test/config";
 
-import { EventId, TurnId, type OrchestrationThreadActivity } from "#t3tools/contracts";
+import { EventId, TurnId, type OrchestrationThreadActivity } from "@t3tools/contracts";
 import { describe, expect, it } from "vite-plus/test";
 
 import { derivePendingApprovals, derivePendingUserInputs } from "./thread-activities.ts";

package/src/domain/thread-activities.ts

@@ -2,7 +2,7 @@ import {
   ApprovalRequestId,
   type OrchestrationThreadActivity,
   type UserInputQuestion,
-} from "#t3tools/contracts";
+} from "@t3tools/contracts";
 
 export type PendingApproval = {
   readonly requestId: ApprovalRequestId;

package/src/domain/thread-lifecycle.test.ts

@@ -3,7 +3,7 @@ import "vite-plus/test/config";
 import { describe, expect, it } from "vite-plus/test";
 import { fromPartial } from "@total-typescript/shoehorn";
 
-import type { OrchestrationThread } from "#t3tools/contracts";
+import type { OrchestrationThread } from "@t3tools/contracts";
 
 import { isThreadActive, isThreadCompleteEnough } from "./thread-lifecycle.ts";
 

package/src/domain/thread-lifecycle.ts

@@ -5,7 +5,7 @@ import {
   type OrchestrationSession,
   type OrchestrationThread,
   type OrchestrationThreadShell,
-} from "#t3tools/contracts";
+} from "@t3tools/contracts";
 import * as Schema from "effect/Schema";
 
 type SessionStatusForDelete = OrchestrationSession["status"] | "closed";

package/src/effect.test-utils.ts

@@ -0,0 +1,25 @@
+import { assert } from "@effect/vitest";
+import { assertInstanceOf } from "@effect/vitest/utils";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Option from "effect/Option";
+
+export const expectFailWithMessage = <E extends { readonly message: string }, R>(
+  effect: Effect.Effect<unknown, E, R>,
+  ErrorClass: new (...args: never) => E,
+  message: string,
+): Effect.Effect<void, never, R> =>
+  Effect.gen(function* () {
+    const exit = yield* effect.pipe(Effect.exit);
+    if (!Exit.isFailure(exit)) {
+      return yield* Effect.die("expected failure");
+    }
+    const error = Cause.findErrorOption(exit.cause);
+    if (Option.isNone(error)) {
+      return yield* Effect.die("expected failure cause");
+    }
+    assertInstanceOf(error.value, ErrorClass);
+    assert.equal(error.value.message, message);
+    return yield* Effect.void;
+  });

package/src/index.ts

@@ -4,6 +4,6 @@ export type {
   StartThreadInput,
   StartThreadPolicy,
   WaitEvent,
+  ApplicationError,
 } from "./application/index.ts";
-export type { ApplicationError } from "./application/index.ts";
 export { AppLayer, AuthAppLayer } from "./runtime/index.ts";

package/src/{connection/node.ts → node/connection.ts}

@@ -2,7 +2,7 @@ import * as Layer from "effect/Layer";
 import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient";
 import * as NodeSocket from "@effect/platform-node/NodeSocket";
 
-import { T3CodeRpcLayer } from "./layer.ts";
+import { T3CodeRpcLayer } from "../connection/index.ts";
 
 const NodeConnectionPlatformLayer = Layer.mergeAll(
   NodeHttpClient.layerUndici,

package/src/node/index.ts

@@ -1,2 +1 @@
-export { T3CodeNodeRpcLayer } from "../connection/node.ts";
-export { NodeEnvironmentLive } from "../environment/layer.ts";
+export { T3CodeNodeRpcLayer } from "./connection.ts";

package/src/orchestration/index.ts

@@ -5,4 +5,3 @@ export {
   type OrchestrationError,
 } from "./service.ts";
 export { makeT3Orchestration, T3OrchestrationLive } from "./layer.ts";
-export { T3OrchestrationLayer } from "../runtime/layer.ts";

package/src/orchestration/layer.ts

@@ -10,7 +10,7 @@ import {
   type ClientOrchestrationCommand,
   type OrchestrationShellStreamItem,
   type OrchestrationThreadStreamItem,
-} from "#t3tools/contracts";
+} from "@t3tools/contracts";
 
 import { RpcError } from "../rpc/error.ts";
 import { T3RpcOperations } from "../rpc/operation.ts";
@@ -25,7 +25,8 @@ export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* ()
         client[ORCHESTRATION_WS_METHODS.subscribeShell]({}),
       )
       .pipe(
-        Stream.map((item: OrchestrationShellStreamItem) =>
+        Stream.filter((item: OrchestrationShellStreamItem) => item.kind !== "synchronized"),
+        Stream.map((item) =>
           item.kind === "snapshot" ? item.snapshot.snapshotSequence : item.sequence,
         ),
       );

package/src/orchestration/service.ts

@@ -10,7 +10,7 @@ import type {
   OrchestrationThread,
   OrchestrationThreadStreamItem,
   ServerProviders,
-} from "#t3tools/contracts";
+} from "@t3tools/contracts";
 
 import type { RpcError } from "../rpc/error.ts";
 

package/src/rpc/error.ts

@@ -1,21 +1,19 @@
-import * as Schema from "effect/Schema";
+import {
+  ConnectionBlockedError,
+  ConnectionTransientError,
+} from "@t3tools/client-runtime/connection";
 import {
   EnvironmentAuthorizationError,
   KeybindingsConfigError,
   OrchestrationDispatchCommandError,
   OrchestrationGetSnapshotError,
   ServerSettingsError,
-  TerminalCwdError,
-  TerminalHistoryError,
-  TerminalNotRunningError,
-  TerminalSessionLookupError,
-} from "#t3tools/contracts";
-import { HttpClientError } from "effect/unstable/http";
+  TerminalError,
+} from "@t3tools/contracts";
+import * as Schema from "effect/Schema";
 import { RpcClientError } from "effect/unstable/rpc";
 
-import { AuthTransportError } from "../auth/error.ts";
 import { T3CodeConnectionError } from "../connection/error.ts";
-import { UrlError } from "../config/error.ts";
 
 const RpcErrorCauseSchema = Schema.Union([
   RpcClientError.RpcClientError,
@@ -24,15 +22,10 @@ const RpcErrorCauseSchema = Schema.Union([
   OrchestrationDispatchCommandError,
   OrchestrationGetSnapshotError,
   ServerSettingsError,
-  TerminalCwdError,
-  TerminalHistoryError,
-  TerminalNotRunningError,
-  TerminalSessionLookupError,
-  AuthTransportError,
+  TerminalError,
+  ConnectionBlockedError,
+  ConnectionTransientError,
   T3CodeConnectionError,
-  HttpClientError.HttpClientErrorSchema,
-  UrlError,
-  Schema.instanceOf(Schema.SchemaError),
 ]);
 
 export type RpcKnownCause = Schema.Schema.Type<typeof RpcErrorCauseSchema>;

package/src/rpc/layer.ts

@@ -3,22 +3,22 @@ import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 import * as Schedule from "effect/Schedule";
 import * as Scope from "effect/Scope";
 import * as SynchronizedRef from "effect/SynchronizedRef";
-import { HttpClientRequest } from "effect/unstable/http";
-import { RpcClient, RpcSerialization } from "effect/unstable/rpc";
-import * as Socket from "effect/unstable/socket/Socket";
 
-import { T3AuthTransport } from "../auth/transport.ts";
-import { T3CodeConnectionProvider } from "../connection/service.ts";
-import { normalizeHttpBaseUrl, toWebSocketEndpointUrl } from "../config/url.ts";
-import { CliWsRpcGroup } from "./ws-group.ts";
+import { T3PreparedConnectionProvider } from "../connection/prepared.ts";
 import { RpcError } from "./error.ts";
+import { T3RpcSessionFactory } from "./session.ts";
 import { T3Rpc, type WsClient } from "./service.ts";
 
-const makeClient = RpcClient.make(CliWsRpcGroup);
-const connectionRetrySchedule = Schedule.exponential("100 millis").pipe(Schedule.take(4));
+const connectionRetrySchedule = Schedule.exponential("100 millis").pipe(
+  Schedule.take(4),
+  Schedule.collectWhile((metadata: Schedule.Metadata) =>
+    Predicate.isTagged(metadata.input, "ConnectionTransientError"),
+  ),
+);
 
 type Connection = {
   readonly scope: Scope.Closeable;
@@ -26,23 +26,19 @@ type Connection = {
 };
 
 export const makeT3RpcLayer = Effect.fn("makeT3RpcLayer")(function* () {
-  const connectionProvider = yield* T3CodeConnectionProvider;
-  const authTransport = yield* T3AuthTransport;
-  const webSocketConstructor = yield* Socket.WebSocketConstructor;
+  const preparedConnectionProvider = yield* T3PreparedConnectionProvider;
+  const sessions = yield* T3RpcSessionFactory;
   const parentScope = yield* Scope.Scope;
   const connection = yield* SynchronizedRef.make(Option.none<Connection>());
   const openConnection = Effect.fn("T3RpcLive.openConnection")(function* () {
     const scope = yield* Scope.fork(parentScope);
     return yield* Effect.gen(function* () {
-      const url = yield* makeWsUrl({ authTransport, connectionProvider });
-      const protocol = yield* Layer.buildWithScope(
-        makeProtocolLayer(url, webSocketConstructor),
-        scope,
-      );
-      const client = yield* makeClient.pipe(
-        Effect.provide(protocol),
-        Effect.provideService(Scope.Scope, scope),
-      );
+      const prepared = yield* preparedConnectionProvider.get;
+      const session = yield* sessions
+        .connect(prepared)
+        .pipe(Effect.provideService(Scope.Scope, scope));
+      yield* session.ready;
+      const client: WsClient = session.client;
       return { scope, client } satisfies Connection;
     }).pipe(
       Effect.retry(connectionRetrySchedule),
@@ -74,36 +70,6 @@ export const makeT3RpcLayer = Effect.fn("makeT3RpcLayer")(function* () {
   };
 });
 
-const makeWsUrl = Effect.fn("makeWsUrl")(function* (input: {
-  readonly authTransport: T3AuthTransport["Service"];
-  readonly connectionProvider: T3CodeConnectionProvider["Service"];
-}) {
-  const connection = yield* input.connectionProvider.get;
-  const origin = yield* normalizeHttpBaseUrl(connection.origin.url);
-  const wsTicket = yield* input.authTransport.issueWebSocketTicket({
-    url: origin,
-    token: connection.auth.token,
-  });
-  const wsUrl = yield* toWebSocketEndpointUrl(origin, "/ws");
-  const request = HttpClientRequest.get(wsUrl).pipe(
-    HttpClientRequest.setUrlParam("wsTicket", wsTicket.ticket),
-  );
-  return Option.getOrThrow(HttpClientRequest.toUrl(request)).toString();
-});
-
-function makeProtocolLayer(
-  url: string,
-  webSocketConstructor: Socket.WebSocketConstructor["Service"],
-) {
-  const socketLayer = Socket.layerWebSocket(url).pipe(
-    Layer.provide(Layer.succeed(Socket.WebSocketConstructor, webSocketConstructor)),
-  );
-  return RpcClient.layerProtocolSocket({ retryTransientErrors: true }).pipe(
-    Layer.provide(socketLayer),
-    Layer.provide(RpcSerialization.layerJson),
-  );
-}
-
 export const T3RpcLive = Layer.effectContext(
   makeT3RpcLayer().pipe(Effect.map((rpc) => Context.make(T3Rpc, rpc))),
 );

package/src/rpc/operation.ts

@@ -1,3 +1,11 @@
+import type {
+  EnvironmentAuthorizationError,
+  KeybindingsConfigError,
+  OrchestrationDispatchCommandError,
+  OrchestrationGetSnapshotError,
+  ServerSettingsError,
+  TerminalError,
+} from "@t3tools/contracts";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
@@ -8,9 +16,15 @@ import { RpcClientError } from "effect/unstable/rpc";
 
 import { RpcError } from "./error.ts";
 import { T3Rpc, type WsClient } from "./service.ts";
-import type { CliRpcRequestError } from "./ws-group.ts";
 
-export type CliRpcOperationError = CliRpcRequestError | RpcClientError.RpcClientError;
+export type CliRpcOperationError =
+  | EnvironmentAuthorizationError
+  | KeybindingsConfigError
+  | OrchestrationDispatchCommandError
+  | OrchestrationGetSnapshotError
+  | RpcClientError.RpcClientError
+  | ServerSettingsError
+  | TerminalError;
 
 export const rpcRetrySchedule = Schedule.exponential("100 millis").pipe(
   Schedule.take(4),

package/src/rpc/service.ts

@@ -1,8 +1,9 @@
 import * as Context from "effect/Context";
 import type * as Effect from "effect/Effect";
 import type { RpcClient, RpcClientError } from "effect/unstable/rpc";
-import type { CliWsRpcGroup } from "./ws-group.ts";
+
 import type { RpcError } from "./error.ts";
+import type { CliWsRpcGroup } from "./ws-group.ts";
 
 export type WsClient = RpcClient.FromGroup<typeof CliWsRpcGroup, RpcClientError.RpcClientError>;