t3code-cli 0.1.0

package/src/index.ts

@@ -0,0 +1,18 @@
+export { T3Application } from "./application/service.ts";
+export type {
+  SendThreadInput,
+  StartThreadInput,
+  StartThreadPolicy,
+  WaitEvent,
+} from "./application/service.ts";
+export type { ApplicationError } from "./application/error.ts";
+export type {
+  ProjectShell,
+  ServerProvider,
+  ShellSnapshot,
+  ThreadDetail,
+  ThreadMessage,
+  ThreadShell,
+} from "./domain/schema.ts";
+export { NodeEnvironmentLive } from "./environment/layer.ts";
+export { AppLayer, AuthAppLayer } from "./runtime.ts";

package/src/orchestration/layer.ts

@@ -0,0 +1,193 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+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,
+  WS_METHODS,
+} from "../protocol/schema.ts";
+import { RpcError } from "../rpc/error.ts";
+import { T3Rpc, type WsClient } from "../rpc/service.ts";
+import { T3Orchestration, type OpenThread } from "./service.ts";
+
+type ReconnectableRpcError = RpcClientError.RpcClientError | RpcError;
+
+const rpcRetrySchedule = Schedule.exponential("100 millis").pipe(
+  Schedule.take(4),
+  Schedule.collectWhile(
+    (metadata: Schedule.Metadata<unknown, ReconnectableRpcError>) =>
+      metadata.input instanceof RpcClientError.RpcClientError,
+  ),
+);
+
+function runRpc<A>(
+  rpc: T3Rpc["Service"],
+  method: string,
+  f: (client: WsClient) => Effect.Effect<A, ReconnectableRpcError>,
+) {
+  return Effect.gen(function* () {
+    const client = yield* rpc.getClient;
+    return yield* f(client);
+  }).pipe(
+    Effect.tapError((error) =>
+      error instanceof RpcClientError.RpcClientError ? rpc.disconnect : Effect.void,
+    ),
+    Effect.retry(rpcRetrySchedule),
+    Effect.catchTags({
+      RpcClientError: (error) =>
+        Effect.fail(
+          new RpcError({
+            message: error.message,
+            method,
+            cause: error,
+          }),
+        ),
+      RpcError: (error) => Effect.fail(error),
+    }),
+  );
+}
+
+function subscribeRpc<A>(
+  rpc: T3Rpc["Service"],
+  method: string,
+  f: (client: WsClient) => Stream.Stream<A, ReconnectableRpcError>,
+) {
+  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),
+    }),
+  );
+}
+
+export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* () {
+  const rpc = yield* T3Rpc;
+  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),
+      }),
+    );
+  });
+  const getServerConfig = Effect.fn("T3OrchestrationLive.getServerConfig")(function* () {
+    return yield* runRpc(rpc, WS_METHODS.serverGetConfig, (client) =>
+      client[WS_METHODS.serverGetConfig]({}),
+    );
+  });
+  const getShellSnapshot = Effect.fn("T3OrchestrationLive.getShellSnapshot")(function* () {
+    const item = yield* Stream.runHead(
+      subscribeRpc(rpc, ORCHESTRATION_WS_METHODS.subscribeShell, (client) =>
+        client[ORCHESTRATION_WS_METHODS.subscribeShell]({}),
+      ),
+    );
+    const value = Option.getOrUndefined(item);
+    if (value === undefined || value.kind !== "snapshot") {
+      return yield* Effect.fail(
+        new RpcError({
+          message: "server did not return shell snapshot",
+          method: ORCHESTRATION_WS_METHODS.subscribeShell,
+        }),
+      );
+    }
+    return value.snapshot;
+  });
+  const getThreadSnapshot = Effect.fn("T3OrchestrationLive.getThreadSnapshot")(function* (
+    threadId: string,
+  ) {
+    const item = yield* Stream.runHead(
+      subscribeRpc(rpc, ORCHESTRATION_WS_METHODS.subscribeThread, (client) =>
+        client[ORCHESTRATION_WS_METHODS.subscribeThread]({ threadId }),
+      ),
+    );
+    const value = Option.getOrUndefined(item);
+    if (value === undefined || value.kind !== "snapshot") {
+      return yield* Effect.fail(
+        new RpcError({
+          message: `thread ${threadId} not found`,
+          method: ORCHESTRATION_WS_METHODS.subscribeThread,
+        }),
+      );
+    }
+    return value.snapshot.thread;
+  });
+  const watchShellSequence = () =>
+    subscribeRpc(rpc, ORCHESTRATION_WS_METHODS.subscribeShell, (client) =>
+      client[ORCHESTRATION_WS_METHODS.subscribeShell]({}),
+    ).pipe(
+      Stream.map((item: ShellStreamItem) =>
+        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 }),
+    );
+  const openThread = Effect.fn("T3OrchestrationLive.openThread")(function* (threadId: string) {
+    return yield* watchThreadItems(threadId).pipe(
+      Stream.peel(Sink.head<ThreadStreamItem>()),
+      Effect.flatMap(([item, rest]) => {
+        const value = Option.getOrUndefined(item);
+        if (value === undefined || value.kind !== "snapshot") {
+          return Effect.fail(
+            new RpcError({
+              message: `thread ${threadId} not found`,
+              method: ORCHESTRATION_WS_METHODS.subscribeThread,
+            }),
+          );
+        }
+        return Effect.succeed({
+          snapshot: value.snapshot.thread,
+          events: rest.pipe(
+            Stream.filter(
+              (next): next is Extract<ThreadStreamItem, { readonly kind: "event" }> =>
+                next.kind === "event",
+            ),
+            Stream.map((next) => next.event),
+          ),
+        } satisfies OpenThread);
+      }),
+    );
+  });
+
+  return {
+    dispatch,
+    getServerConfig,
+    getShellSnapshot,
+    getThreadSnapshot,
+    watchShellSequence,
+    watchThreadItems,
+    openThread,
+  };
+});
+
+export const T3OrchestrationLive = Layer.effect(T3Orchestration, makeT3Orchestration());

package/src/orchestration/service.ts

@@ -0,0 +1,39 @@
+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 } 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>;
+};
+
+export type ThreadStreamItem =
+  | { readonly kind: "snapshot"; readonly snapshot: { readonly thread: ThreadDetail } }
+  | { readonly kind: "event"; readonly event: ThreadEvent };
+
+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 watchShellSequence: () => Stream.Stream<number, OrchestrationError, Scope.Scope>;
+  readonly watchThreadItems: (
+    threadId: string,
+  ) => Stream.Stream<ThreadStreamItem, OrchestrationError, Scope.Scope>;
+  readonly openThread: (
+    threadId: string,
+  ) => Effect.Effect<OpenThread, OrchestrationError, Scope.Scope>;
+};
+
+export class T3Orchestration extends Context.Service<T3Orchestration, Orchestration>()(
+  "t3cli/T3Orchestration",
+) {}

package/src/protocol/schema.ts

@@ -0,0 +1,105 @@
+import * as Schema from "effect/Schema";
+import { Rpc, RpcGroup } from "effect/unstable/rpc";
+
+import {
+  ClientOrchestrationCommandSchema,
+  DispatchResultSchema,
+} from "../domain/command-schema.ts";
+import {
+  ProjectShellSchema,
+  ServerConfigSchema,
+  ShellSnapshotSchema,
+  ThreadDetailSchema,
+  ThreadEventSchema,
+  ThreadShellSchema,
+} from "../domain/schema.ts";
+import { RpcError } from "../rpc/error.ts";
+
+export const ORCHESTRATION_WS_METHODS = {
+  dispatchCommand: "orchestration.dispatchCommand",
+  subscribeShell: "orchestration.subscribeShell",
+  subscribeThread: "orchestration.subscribeThread",
+} as const;
+
+export const WS_METHODS = {
+  serverGetConfig: "server.getConfig",
+} as const;
+
+export const ThreadStreamItemSchema = Schema.Union([
+  Schema.Struct({
+    kind: Schema.Literal("snapshot"),
+    snapshot: Schema.Struct({ thread: ThreadDetailSchema }),
+  }),
+  Schema.Struct({
+    kind: Schema.Literal("event"),
+    event: ThreadEventSchema,
+  }),
+]);
+export type ThreadStreamItem = typeof ThreadStreamItemSchema.Type;
+
+export const ShellStreamItemSchema = Schema.Union([
+  Schema.Struct({
+    kind: Schema.Literal("snapshot"),
+    snapshot: ShellSnapshotSchema,
+  }),
+  Schema.Struct({
+    kind: Schema.Literal("project-upserted"),
+    sequence: Schema.Number,
+    project: ProjectShellSchema,
+  }),
+  Schema.Struct({
+    kind: Schema.Literal("project-removed"),
+    sequence: Schema.Number,
+    projectId: Schema.String,
+  }),
+  Schema.Struct({
+    kind: Schema.Literal("thread-upserted"),
+    sequence: Schema.Number,
+    thread: ThreadShellSchema,
+  }),
+  Schema.Struct({
+    kind: Schema.Literal("thread-removed"),
+    sequence: Schema.Number,
+    threadId: Schema.String,
+  }),
+]);
+export type ShellStreamItem = typeof ShellStreamItemSchema.Type;
+
+export const WsOrchestrationDispatchCommandRpc = Rpc.make(
+  ORCHESTRATION_WS_METHODS.dispatchCommand,
+  {
+    payload: ClientOrchestrationCommandSchema,
+    success: DispatchResultSchema,
+    error: RpcError,
+  },
+);
+
+export const WsOrchestrationSubscribeShellRpc = Rpc.make(ORCHESTRATION_WS_METHODS.subscribeShell, {
+  payload: Schema.Struct({}),
+  success: ShellStreamItemSchema,
+  error: RpcError,
+  stream: true,
+});
+
+export const WsOrchestrationSubscribeThreadRpc = Rpc.make(
+  ORCHESTRATION_WS_METHODS.subscribeThread,
+  {
+    payload: Schema.Struct({ threadId: Schema.String }),
+    success: ThreadStreamItemSchema,
+    error: RpcError,
+    stream: true,
+  },
+);
+
+export const WsServerGetConfigRpc = Rpc.make(WS_METHODS.serverGetConfig, {
+  payload: Schema.Struct({}),
+  success: ServerConfigSchema,
+  error: RpcError,
+});
+
+export const WsRpcGroup = RpcGroup.make(
+  WsOrchestrationDispatchCommandRpc,
+  WsOrchestrationSubscribeShellRpc,
+  WsOrchestrationSubscribeThreadRpc,
+  WsServerGetConfigRpc,
+);

package/src/rpc/error.ts

@@ -0,0 +1,31 @@
+import * as Schema from "effect/Schema";
+import { HttpClientError } from "effect/unstable/http";
+import { RpcClientError } from "effect/unstable/rpc";
+
+import {
+  AuthConfigError,
+  AuthLocalError,
+  AuthPairingUrlError,
+  AuthTransportError,
+} from "../auth/error.ts";
+import { ConfigError, UrlError } from "../config/error.ts";
+
+const RpcErrorCauseSchema = Schema.Union([
+  RpcClientError.RpcClientError,
+  AuthConfigError,
+  AuthLocalError,
+  AuthPairingUrlError,
+  AuthTransportError,
+  ConfigError,
+  HttpClientError.HttpClientErrorSchema,
+  UrlError,
+  Schema.instanceOf(Schema.SchemaError),
+]);
+
+export class RpcError extends Schema.TaggedErrorClass<RpcError>()("RpcError", {
+  message: Schema.String,
+  method: Schema.optionalKey(Schema.String),
+  cause: Schema.optionalKey(RpcErrorCauseSchema),
+}) {}
+
+export type OrchestrationError = RpcError;

package/src/rpc/layer.ts

@@ -0,0 +1,99 @@
+import * as Context from "effect/Context";
+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 Schedule from "effect/Schedule";
+import * as Scope from "effect/Scope";
+import * as SynchronizedRef from "effect/SynchronizedRef";
+import * as NodeSocket from "@effect/platform-node/NodeSocket";
+import { HttpClientRequest } from "effect/unstable/http";
+import { RpcClient, RpcSerialization } from "effect/unstable/rpc";
+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 { RpcError } from "./error.ts";
+import { T3Rpc, type WsClient } from "./service.ts";
+
+const makeClient = RpcClient.make(WsRpcGroup);
+const connectionRetrySchedule = Schedule.exponential("100 millis").pipe(Schedule.take(4));
+
+type Connection = {
+  readonly scope: Scope.Closeable;
+  readonly client: WsClient;
+};
+
+export const makeT3RpcLayer = Effect.fn("makeT3RpcLayer")(function* () {
+  const config = yield* T3Config;
+  const auth = yield* T3Auth;
+  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({ auth, config });
+      const protocol = yield* Layer.buildWithScope(makeProtocolLayer(url), scope);
+      const client = yield* makeClient.pipe(
+        Effect.provide(protocol),
+        Effect.provideService(Scope.Scope, scope),
+      );
+      return { scope, client } satisfies Connection;
+    }).pipe(
+      Effect.retry(connectionRetrySchedule),
+      Effect.onError(() => Scope.close(scope, Exit.void)),
+      Effect.mapError((error) => new RpcError({ message: error.message, cause: error })),
+    );
+  });
+
+  const disconnect = Effect.fn("T3RpcLive.disconnect")(function* () {
+    const current = yield* SynchronizedRef.getAndSet(connection, Option.none<Connection>());
+    if (Option.isSome(current)) {
+      yield* Scope.close(current.value.scope, Exit.void);
+    }
+  });
+
+  const getClient = Effect.fn("T3RpcLive.getClient")(function* () {
+    return yield* SynchronizedRef.modifyEffect(connection, (current) => {
+      if (Option.isSome(current)) {
+        return Effect.succeed([current.value.client, current] as const);
+      }
+      return openConnection().pipe(Effect.map((next) => [next.client, Option.some(next)] as const));
+    });
+  });
+
+  return {
+    getClient: getClient(),
+    disconnect: disconnect(),
+    reconnect: disconnect().pipe(Effect.andThen(getClient())),
+  };
+});
+
+const makeWsUrl = Effect.fn("makeWsUrl")(function* (input: {
+  readonly config: T3Config["Service"];
+  readonly auth: T3Auth["Service"];
+}) {
+  const resolved = yield* input.config.resolve();
+  const wsToken = yield* input.auth.issueWebSocketToken();
+  const wsUrl = yield* toWebSocketBaseUrl(resolved.url);
+  const request = HttpClientRequest.get(wsUrl).pipe(
+    HttpClientRequest.setUrlParam("wsToken", wsToken.token),
+  );
+  return Option.getOrThrow(HttpClientRequest.toUrl(request)).toString();
+});
+
+function makeProtocolLayer(url: string) {
+  const socketLayer = Socket.layerWebSocket(url).pipe(
+    Layer.provide(NodeSocket.layerWebSocketConstructor),
+  );
+  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/service.ts

@@ -0,0 +1,16 @@
+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 { RpcError } from "./error.ts";
+
+export type WsClient = RpcClient.FromGroup<typeof WsRpcGroup, RpcClientError.RpcClientError>;
+
+export type T3RpcService = {
+  readonly getClient: Effect.Effect<WsClient, RpcError>;
+  readonly reconnect: Effect.Effect<WsClient, RpcError>;
+  readonly disconnect: Effect.Effect<void>;
+};
+
+export class T3Rpc extends Context.Service<T3Rpc, T3RpcService>()("t3cli/T3Rpc") {}

package/src/runtime.ts

@@ -0,0 +1,28 @@
+import * as Layer from "effect/Layer";
+import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient";
+import * as NodeSocket from "@effect/platform-node/NodeSocket";
+
+import { T3AuthLive } from "./auth/layer.ts";
+import { T3ConfigLive } from "./config/layer.ts";
+import { T3ApplicationLive } from "./application/layer.ts";
+import { T3OrchestrationLive } from "./orchestration/layer.ts";
+import { T3RpcLive } from "./rpc/layer.ts";
+
+const T3AuthLayer = T3AuthLive.pipe(
+  Layer.provide(Layer.mergeAll(T3ConfigLive, NodeHttpClient.layerUndici)),
+);
+const T3RpcLayer = T3RpcLive.pipe(
+  Layer.provide(Layer.mergeAll(T3ConfigLive, T3AuthLayer, NodeSocket.layerWebSocketConstructor)),
+);
+const T3OrchestrationLayer = T3OrchestrationLive.pipe(Layer.provide(T3RpcLayer));
+const T3ApplicationLayer = T3ApplicationLive.pipe(Layer.provide(T3OrchestrationLayer));
+
+export const AuthAppLayer = Layer.mergeAll(T3ConfigLive, T3AuthLayer);
+
+export const AppLayer = Layer.mergeAll(
+  T3ConfigLive,
+  T3AuthLayer,
+  T3RpcLayer,
+  T3OrchestrationLayer,
+  T3ApplicationLayer,
+);

package/src/version/layer.ts

@@ -0,0 +1,25 @@
+import { fileURLToPath } from "node:url";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+
+import { T3Version } from "./service.ts";
+
+declare const T3CLI_VERSION: string;
+
+const PackageJsonSchema = Schema.fromJsonString(Schema.Struct({ version: Schema.String }));
+
+export const T3VersionBundledLive = Layer.sync(T3Version, () => ({ version: T3CLI_VERSION }));
+
+export const T3VersionPackageJsonLive = Layer.effect(
+  T3Version,
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const packageJson = yield* fs.readFileString(
+      fileURLToPath(new URL("../../package.json", import.meta.url)),
+    );
+    const decoded = yield* Schema.decodeUnknownEffect(PackageJsonSchema)(packageJson);
+    return { version: decoded.version };
+  }),
+);

package/src/version/service.ts

@@ -0,0 +1,8 @@
+import * as Context from "effect/Context";
+
+export class T3Version extends Context.Service<
+  T3Version,
+  {
+    readonly version: string;
+  }
+>()("t3cli/T3Version") {}