t3code-cli 0.1.2 → 0.2.0

package/src/domain/model-config.ts

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

package/src/domain/thread-lifecycle.ts

@@ -1,19 +1,13 @@
-import * as Schema from "effect/Schema";
-
 import {
-  type ThreadDetail,
-  type ThreadEvent,
-  type ThreadMessage,
-  type ThreadShell,
-  ThreadMessageSchema,
-  ThreadMessageSentEventSchema,
-  ThreadSessionSetEventSchema,
-} from "./schema.ts";
-
-const isThreadMessageSentEvent = Schema.is(ThreadMessageSentEventSchema);
-const isThreadSessionSetEvent = Schema.is(ThreadSessionSetEventSchema);
+  OrchestrationMessage,
+  type OrchestrationEvent,
+  type OrchestrationMessage as OrchestrationMessageType,
+  type OrchestrationThread,
+  type OrchestrationThreadShell,
+} from "@t3tools/contracts";
+import * as Schema from "effect/Schema";
 
-export function isThreadActive(thread: ThreadShell | ThreadDetail) {
+export function isThreadActive(thread: OrchestrationThreadShell | OrchestrationThread) {
   return (
     thread.session?.status === "starting" ||
     thread.session?.status === "running" ||
@@ -22,18 +16,18 @@ export function isThreadActive(thread: ThreadShell | ThreadDetail) {
   );
 }
 
-export function threadStatus(thread: ThreadShell | ThreadDetail) {
+export function threadStatus(thread: OrchestrationThreadShell | OrchestrationThread) {
   if (isPendingStart(thread)) {
     return "pending";
   }
   return thread.session?.status ?? thread.latestTurn?.state ?? "unknown";
 }
 
-export function latestAssistantMessage(thread: ThreadDetail) {
+export function latestAssistantMessage(thread: OrchestrationThread) {
   return thread.messages.toReversed().find((message) => message.role === "assistant");
 }
 
-export function isThreadCompleteEnough(thread: ThreadDetail) {
+export function isThreadCompleteEnough(thread: OrchestrationThread) {
   if (thread.session?.status === "error" || thread.session?.status === "interrupted") {
     return true;
   }
@@ -45,16 +39,16 @@ export function isThreadCompleteEnough(thread: ThreadDetail) {
 }
 
 export function applyThreadEvent(
-  current: ThreadDetail,
-  event: ThreadEvent,
-  messages: Map<string, ThreadMessage>,
+  current: OrchestrationThread,
+  event: OrchestrationEvent,
+  messages: Map<string, OrchestrationMessageType>,
 ) {
   const message = messageFromEvent(event, messages);
   if (message !== null) {
     messages.set(messageKey(message), message);
     return { ...current, messages: [...messages.values()] };
   }
-  if (isThreadSessionSetEvent(event)) {
+  if (event.type === "thread.session-set") {
     return {
       ...current,
       session: event.payload.session,
@@ -64,32 +58,32 @@ export function applyThreadEvent(
 }
 
 export function messageFromEvent(
-  event: ThreadEvent,
-  existingMessages: Map<string, ThreadMessage> = new Map(),
-): ThreadMessage | null {
-  if (!isThreadMessageSentEvent(event)) {
+  event: OrchestrationEvent,
+  existingMessages: Map<string, OrchestrationMessageType> = new Map(),
+): OrchestrationMessageType | null {
+  if (event.type !== "thread.message-sent") {
     return null;
   }
   const payload = event.payload;
   const id = payload.messageId;
   const previous = existingMessages.get(id);
   const text = payload.text;
-  return Schema.decodeUnknownSync(ThreadMessageSchema)({
+  return Schema.decodeUnknownSync(OrchestrationMessage)({
     id,
     role: payload.role,
     text: text.length > 0 || previous === undefined ? text : previous.text,
     turnId: payload.turnId,
-    ...(payload.streaming !== undefined ? { streaming: payload.streaming } : {}),
+    streaming: payload.streaming,
     createdAt: payload.createdAt,
     updatedAt: payload.updatedAt,
   });
 }
 
-export function messageKey(message: ThreadMessage) {
-  return message.id ?? message.messageId ?? `${message.role}:${message.createdAt}`;
+export function messageKey(message: OrchestrationMessageType) {
+  return message.id;
 }
 
-function isPendingStart(thread: ThreadShell | ThreadDetail) {
+function isPendingStart(thread: OrchestrationThreadShell | OrchestrationThread) {
   if (thread.session !== null || thread.latestTurn !== null || !("messages" in thread)) {
     return false;
   }

package/src/index.ts

@@ -7,12 +7,12 @@ export type {
 } from "./application/service.ts";
 export type { ApplicationError } from "./application/error.ts";
 export type {
-  ProjectShell,
+  OrchestrationMessage,
+  OrchestrationProjectShell,
+  OrchestrationShellSnapshot,
+  OrchestrationThread,
+  OrchestrationThreadShell,
   ServerProvider,
-  ShellSnapshot,
-  ThreadDetail,
-  ThreadMessage,
-  ThreadShell,
-} from "./domain/schema.ts";
+} from "@t3tools/contracts";
 export { NodeEnvironmentLive } from "./environment/layer.ts";
 export { AppLayer, AuthAppLayer } from "./runtime.ts";

package/src/orchestration/layer.ts

@@ -4,34 +4,35 @@ import * as Option from "effect/Option";
 import * as Schedule from "effect/Schedule";
 import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
-import { RpcClientError } from "effect/unstable/rpc";
-
-import { type ClientOrchestrationCommand } from "../domain/command-schema.ts";
 import {
   ORCHESTRATION_WS_METHODS,
-  type ShellStreamItem,
-  type ThreadStreamItem,
+  ThreadId,
   WS_METHODS,
-} from "../protocol/schema.ts";
+  type ClientOrchestrationCommand,
+  type OrchestrationShellStreamItem,
+  type OrchestrationThreadStreamItem,
+} from "@t3tools/contracts";
+import { RpcClientError } from "effect/unstable/rpc";
+
 import { RpcError } from "../rpc/error.ts";
 import { T3Rpc, type WsClient } from "../rpc/service.ts";
+import type { CliRpcRequestError } from "../rpc/ws-group.ts";
 import { T3Orchestration, type OpenThread } from "./service.ts";
 
-type ReconnectableRpcError = RpcClientError.RpcClientError | RpcError;
+type RpcRequestError = RpcClientError.RpcClientError | CliRpcRequestError;
 
 const rpcRetrySchedule = Schedule.exponential("100 millis").pipe(
   Schedule.take(4),
   Schedule.collectWhile(
-    (metadata: Schedule.Metadata<unknown, ReconnectableRpcError>) =>
-      metadata.input instanceof RpcClientError.RpcClientError,
+    (metadata: Schedule.Metadata) => metadata.input instanceof RpcClientError.RpcClientError,
   ),
 );
 
 function runRpc<A>(
   rpc: T3Rpc["Service"],
   method: string,
-  f: (client: WsClient) => Effect.Effect<A, ReconnectableRpcError>,
-) {
+  f: (client: WsClient) => Effect.Effect<A, RpcRequestError>,
+): Effect.Effect<A, RpcError> {
   return Effect.gen(function* () {
     const client = yield* rpc.getClient;
     return yield* f(client);
@@ -41,15 +42,13 @@ function runRpc<A>(
     ),
     Effect.retry(rpcRetrySchedule),
     Effect.catchTags({
-      RpcClientError: (error) =>
-        Effect.fail(
-          new RpcError({
-            message: error.message,
-            method,
-            cause: error,
-          }),
-        ),
       RpcError: (error) => Effect.fail(error),
+      EnvironmentAuthorizationError: (error) => Effect.fail(toRpcRequestError(error, method)),
+      RpcClientError: (error) => Effect.fail(toRpcRequestError(error, method)),
+      KeybindingsConfigParseError: (error) => Effect.fail(toRpcRequestError(error, method)),
+      OrchestrationDispatchCommandError: (error) => Effect.fail(toRpcRequestError(error, method)),
+      OrchestrationGetSnapshotError: (error) => Effect.fail(toRpcRequestError(error, method)),
+      ServerSettingsError: (error) => Effect.fail(toRpcRequestError(error, method)),
     }),
   );
 }
@@ -57,23 +56,21 @@ function runRpc<A>(
 function subscribeRpc<A>(
   rpc: T3Rpc["Service"],
   method: string,
-  f: (client: WsClient) => Stream.Stream<A, ReconnectableRpcError>,
-) {
+  f: (client: WsClient) => Stream.Stream<A, RpcRequestError>,
+): Stream.Stream<A, RpcError> {
   return Stream.unwrap(Effect.map(rpc.getClient, f)).pipe(
     Stream.tapError((error) =>
       error instanceof RpcClientError.RpcClientError ? rpc.disconnect : Effect.void,
     ),
     Stream.retry(rpcRetrySchedule),
     Stream.catchTags({
-      RpcClientError: (error) =>
-        Stream.fail(
-          new RpcError({
-            message: error.message,
-            method,
-            cause: error,
-          }),
-        ),
       RpcError: (error) => Stream.fail(error),
+      EnvironmentAuthorizationError: (error) => Stream.fail(toRpcRequestError(error, method)),
+      RpcClientError: (error) => Stream.fail(toRpcRequestError(error, method)),
+      KeybindingsConfigParseError: (error) => Stream.fail(toRpcRequestError(error, method)),
+      OrchestrationDispatchCommandError: (error) => Stream.fail(toRpcRequestError(error, method)),
+      OrchestrationGetSnapshotError: (error) => Stream.fail(toRpcRequestError(error, method)),
+      ServerSettingsError: (error) => Stream.fail(toRpcRequestError(error, method)),
     }),
   );
 }
@@ -83,20 +80,8 @@ export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* ()
   const dispatch = Effect.fn("T3OrchestrationLive.dispatch")(function* (
     command: ClientOrchestrationCommand,
   ) {
-    const client = yield* rpc.getClient;
-    return yield* client[ORCHESTRATION_WS_METHODS.dispatchCommand](command).pipe(
-      Effect.tapErrorTag("RpcClientError", () => rpc.disconnect),
-      Effect.catchTags({
-        RpcClientError: (error) =>
-          Effect.fail(
-            new RpcError({
-              message: error.message,
-              method: ORCHESTRATION_WS_METHODS.dispatchCommand,
-              cause: error,
-            }),
-          ),
-        RpcError: (error) => Effect.fail(error),
-      }),
+    return yield* runRpc(rpc, ORCHESTRATION_WS_METHODS.dispatchCommand, (client) =>
+      client[ORCHESTRATION_WS_METHODS.dispatchCommand](command),
     );
   });
   const getServerConfig = Effect.fn("T3OrchestrationLive.getServerConfig")(function* () {
@@ -126,7 +111,7 @@ export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* ()
   ) {
     const item = yield* Stream.runHead(
       subscribeRpc(rpc, ORCHESTRATION_WS_METHODS.subscribeThread, (client) =>
-        client[ORCHESTRATION_WS_METHODS.subscribeThread]({ threadId }),
+        client[ORCHESTRATION_WS_METHODS.subscribeThread]({ threadId: ThreadId.make(threadId) }),
       ),
     );
     const value = Option.getOrUndefined(item);
@@ -144,17 +129,17 @@ export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* ()
     subscribeRpc(rpc, ORCHESTRATION_WS_METHODS.subscribeShell, (client) =>
       client[ORCHESTRATION_WS_METHODS.subscribeShell]({}),
     ).pipe(
-      Stream.map((item: ShellStreamItem) =>
+      Stream.map((item: OrchestrationShellStreamItem) =>
         item.kind === "snapshot" ? item.snapshot.snapshotSequence : item.sequence,
       ),
     );
   const watchThreadItems = (threadId: string) =>
     subscribeRpc(rpc, ORCHESTRATION_WS_METHODS.subscribeThread, (client) =>
-      client[ORCHESTRATION_WS_METHODS.subscribeThread]({ threadId }),
+      client[ORCHESTRATION_WS_METHODS.subscribeThread]({ threadId: ThreadId.make(threadId) }),
     );
   const openThread = Effect.fn("T3OrchestrationLive.openThread")(function* (threadId: string) {
     return yield* watchThreadItems(threadId).pipe(
-      Stream.peel(Sink.head<ThreadStreamItem>()),
+      Stream.peel(Sink.head<OrchestrationThreadStreamItem>()),
       Effect.flatMap(([item, rest]) => {
         const value = Option.getOrUndefined(item);
         if (value === undefined || value.kind !== "snapshot") {
@@ -169,7 +154,7 @@ export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* ()
           snapshot: value.snapshot.thread,
           events: rest.pipe(
             Stream.filter(
-              (next): next is Extract<ThreadStreamItem, { readonly kind: "event" }> =>
+              (next): next is Extract<OrchestrationThreadStreamItem, { readonly kind: "event" }> =>
                 next.kind === "event",
             ),
             Stream.map((next) => next.event),
@@ -191,3 +176,11 @@ export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* ()
 });
 
 export const T3OrchestrationLive = Layer.effect(T3Orchestration, makeT3Orchestration());
+
+function toRpcRequestError(error: RpcRequestError, method: string) {
+  return new RpcError({
+    message: error.message,
+    method,
+    cause: error,
+  });
+}

package/src/orchestration/service.ts

@@ -2,33 +2,42 @@ import * as Context from "effect/Context";
 import type * as Effect from "effect/Effect";
 import type * as Scope from "effect/Scope";
 import type * as Stream from "effect/Stream";
+import type {
+  ClientOrchestrationCommand,
+  DispatchResult,
+  OrchestrationEvent,
+  OrchestrationShellSnapshot,
+  OrchestrationThread,
+  OrchestrationThreadStreamItem,
+  ServerProviders,
+} from "@t3tools/contracts";
 
-import type { ClientOrchestrationCommand, DispatchResult } from "../domain/command-schema.ts";
-import type { ServerConfig, ShellSnapshot, ThreadDetail, ThreadEvent } from "../domain/schema.ts";
 import type { RpcError } from "../rpc/error.ts";
 
 export type OrchestrationError = RpcError;
 
 export type OpenThread = {
-  readonly snapshot: ThreadDetail;
-  readonly events: Stream.Stream<ThreadEvent, OrchestrationError>;
+  readonly snapshot: OrchestrationThread;
+  readonly events: Stream.Stream<OrchestrationEvent, OrchestrationError>;
 };
 
-export type ThreadStreamItem =
-  | { readonly kind: "snapshot"; readonly snapshot: { readonly thread: ThreadDetail } }
-  | { readonly kind: "event"; readonly event: ThreadEvent };
+export type ServerConfigForCli = {
+  readonly providers: ServerProviders;
+};
 
 export type Orchestration = {
   readonly dispatch: (
     command: ClientOrchestrationCommand,
   ) => Effect.Effect<DispatchResult, OrchestrationError>;
-  readonly getServerConfig: () => Effect.Effect<ServerConfig, OrchestrationError>;
-  readonly getShellSnapshot: () => Effect.Effect<ShellSnapshot, OrchestrationError>;
-  readonly getThreadSnapshot: (threadId: string) => Effect.Effect<ThreadDetail, OrchestrationError>;
+  readonly getServerConfig: () => Effect.Effect<ServerConfigForCli, OrchestrationError>;
+  readonly getShellSnapshot: () => Effect.Effect<OrchestrationShellSnapshot, OrchestrationError>;
+  readonly getThreadSnapshot: (
+    threadId: string,
+  ) => Effect.Effect<OrchestrationThread, OrchestrationError>;
   readonly watchShellSequence: () => Stream.Stream<number, OrchestrationError, Scope.Scope>;
   readonly watchThreadItems: (
     threadId: string,
-  ) => Stream.Stream<ThreadStreamItem, OrchestrationError, Scope.Scope>;
+  ) => Stream.Stream<OrchestrationThreadStreamItem, OrchestrationError, Scope.Scope>;
   readonly openThread: (
     threadId: string,
   ) => Effect.Effect<OpenThread, OrchestrationError, Scope.Scope>;

package/src/rpc/error.ts

@@ -1,4 +1,11 @@
 import * as Schema from "effect/Schema";
+import {
+  EnvironmentAuthorizationError,
+  KeybindingsConfigError,
+  OrchestrationDispatchCommandError,
+  OrchestrationGetSnapshotError,
+  ServerSettingsError,
+} from "@t3tools/contracts";
 import { HttpClientError } from "effect/unstable/http";
 import { RpcClientError } from "effect/unstable/rpc";
 
@@ -12,6 +19,11 @@ import { ConfigError, UrlError } from "../config/error.ts";
 
 const RpcErrorCauseSchema = Schema.Union([
   RpcClientError.RpcClientError,
+  EnvironmentAuthorizationError,
+  KeybindingsConfigError,
+  OrchestrationDispatchCommandError,
+  OrchestrationGetSnapshotError,
+  ServerSettingsError,
   AuthConfigError,
   AuthLocalError,
   AuthPairingUrlError,

package/src/rpc/layer.ts

@@ -13,12 +13,12 @@ import * as Socket from "effect/unstable/socket/Socket";
 
 import { T3Auth } from "../auth/service.ts";
 import { T3Config } from "../config/service.ts";
-import { toWebSocketBaseUrl } from "../config/url.ts";
-import { WsRpcGroup } from "../protocol/schema.ts";
+import { toWebSocketEndpointUrl } from "../config/url.ts";
+import { CliWsRpcGroup } from "./ws-group.ts";
 import { RpcError } from "./error.ts";
 import { T3Rpc, type WsClient } from "./service.ts";
 
-const makeClient = RpcClient.make(WsRpcGroup);
+const makeClient = RpcClient.make(CliWsRpcGroup);
 const connectionRetrySchedule = Schedule.exponential("100 millis").pipe(Schedule.take(4));
 
 type Connection = {
@@ -77,7 +77,7 @@ const makeWsUrl = Effect.fn("makeWsUrl")(function* (input: {
 }) {
   const resolved = yield* input.config.resolve();
   const wsToken = yield* input.auth.issueWebSocketToken();
-  const wsUrl = yield* toWebSocketBaseUrl(resolved.url);
+  const wsUrl = yield* toWebSocketEndpointUrl(resolved.url, "/ws");
   const request = HttpClientRequest.get(wsUrl).pipe(
     HttpClientRequest.setUrlParam("wsToken", wsToken.token),
   );

package/src/rpc/service.ts

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

package/src/rpc/ws-group.ts

@@ -0,0 +1,43 @@
+import {
+  EnvironmentAuthorizationError,
+  KeybindingsConfigError,
+  OrchestrationDispatchCommandError,
+  OrchestrationGetSnapshotError,
+  ServerConfig,
+  ServerProviders,
+  ServerSettingsError,
+  WS_METHODS,
+  WsOrchestrationDispatchCommandRpc,
+  WsOrchestrationSubscribeShellRpc,
+  WsOrchestrationSubscribeThreadRpc,
+} from "@t3tools/contracts";
+import * as Schema from "effect/Schema";
+import { Rpc, RpcGroup } from "effect/unstable/rpc";
+
+export const FallbackServerConfig = Schema.Struct({
+  providers: ServerProviders,
+});
+export type FallbackServerConfig = typeof FallbackServerConfig.Type;
+
+export const CliServerConfig = Schema.Union([ServerConfig, FallbackServerConfig]);
+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(
+  WsOrchestrationDispatchCommandRpc,
+  WsOrchestrationSubscribeShellRpc,
+  WsOrchestrationSubscribeThreadRpc,
+  WsServerGetConfigRpc,
+);
+
+export type CliRpcRequestError =
+  | EnvironmentAuthorizationError
+  | KeybindingsConfigError
+  | OrchestrationDispatchCommandError
+  | OrchestrationGetSnapshotError
+  | ServerSettingsError;

package/src/domain/command-schema.ts

@@ -1,82 +0,0 @@
-import * as Schema from "effect/Schema";
-
-import { ModelSelectionSchema } from "./schema.ts";
-
-export const DispatchResultSchema = Schema.Struct({
-  sequence: Schema.Number,
-});
-export type DispatchResult = typeof DispatchResultSchema.Type;
-
-export const ProjectCreateCommandSchema = Schema.Struct({
-  type: Schema.Literal("project.create"),
-  commandId: Schema.String,
-  projectId: Schema.String,
-  title: Schema.String,
-  workspaceRoot: Schema.String,
-  createdAt: Schema.String,
-});
-export type ProjectCreateCommand = typeof ProjectCreateCommandSchema.Type;
-
-export const ThreadCreateCommandSchema = Schema.Struct({
-  type: Schema.Literal("thread.create"),
-  commandId: Schema.String,
-  threadId: Schema.String,
-  projectId: Schema.String,
-  title: Schema.String,
-  modelSelection: ModelSelectionSchema,
-  runtimeMode: Schema.Literal("full-access"),
-  interactionMode: Schema.Literal("default"),
-  branch: Schema.Null,
-  worktreePath: Schema.NullOr(Schema.String),
-  createdAt: Schema.String,
-});
-export type ThreadCreateCommand = typeof ThreadCreateCommandSchema.Type;
-
-export const ThreadTurnStartCommandSchema = Schema.Struct({
-  type: Schema.Literal("thread.turn.start"),
-  commandId: Schema.String,
-  threadId: Schema.String,
-  message: Schema.Struct({
-    messageId: Schema.String,
-    role: Schema.Literal("user"),
-    text: Schema.String,
-    attachments: Schema.Array(Schema.Never),
-  }),
-  modelSelection: Schema.optionalKey(ModelSelectionSchema),
-  titleSeed: Schema.optionalKey(Schema.String),
-  runtimeMode: Schema.Literal("full-access"),
-  interactionMode: Schema.Literal("default"),
-  bootstrap: Schema.optionalKey(
-    Schema.Struct({
-      createThread: Schema.optionalKey(
-        Schema.Struct({
-          projectId: Schema.String,
-          title: Schema.String,
-          modelSelection: ModelSelectionSchema,
-          runtimeMode: Schema.Literal("full-access"),
-          interactionMode: Schema.Literal("default"),
-          branch: Schema.Null,
-          worktreePath: Schema.NullOr(Schema.String),
-          createdAt: Schema.String,
-        }),
-      ),
-    }),
-  ),
-  createdAt: Schema.String,
-});
-export type ThreadTurnStartCommand = typeof ThreadTurnStartCommandSchema.Type;
-
-export const ThreadArchiveCommandSchema = Schema.Struct({
-  type: Schema.Literal("thread.archive"),
-  commandId: Schema.String,
-  threadId: Schema.String,
-});
-export type ThreadArchiveCommand = typeof ThreadArchiveCommandSchema.Type;
-
-export const ClientOrchestrationCommandSchema = Schema.Union([
-  ProjectCreateCommandSchema,
-  ThreadArchiveCommandSchema,
-  ThreadCreateCommandSchema,
-  ThreadTurnStartCommandSchema,
-]);
-export type ClientOrchestrationCommand = typeof ClientOrchestrationCommandSchema.Type;