t3code-cli 0.10.0 → 0.12.0

package/src/orchestration/layer.ts

@@ -1,7 +1,6 @@
 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 {
@@ -11,87 +10,46 @@ import {
   type ClientOrchestrationCommand,
   type OrchestrationShellStreamItem,
   type OrchestrationThreadStreamItem,
-} from "#t3tools/contracts";
-import { RpcClientError } from "effect/unstable/rpc";
+} from "@t3tools/contracts";
 
 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";
+import { T3RpcOperations } from "../rpc/operation.ts";
+import { T3Orchestration, type OpenThread, type Orchestration } from "./service.ts";
 
-type RpcRequestError = RpcClientError.RpcClientError | CliRpcRequestError;
-
-const rpcRetrySchedule = Schedule.exponential("100 millis").pipe(
-  Schedule.take(4),
-  Schedule.collectWhile(
-    (metadata: Schedule.Metadata) => metadata.input instanceof RpcClientError.RpcClientError,
-  ),
-);
+export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* () {
+  const rpc = yield* T3RpcOperations;
 
-function runRpc<A>(
-  rpc: T3Rpc["Service"],
-  method: string,
-  f: (client: WsClient) => Effect.Effect<A, RpcRequestError>,
-): Effect.Effect<A, RpcError> {
-  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({
-      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)),
-    }),
-  );
-}
+  const watchShellSequence: Orchestration["watchShellSequence"] = () =>
+    rpc
+      .subscribe(ORCHESTRATION_WS_METHODS.subscribeShell, (client) =>
+        client[ORCHESTRATION_WS_METHODS.subscribeShell]({}),
+      )
+      .pipe(
+        Stream.map((item: OrchestrationShellStreamItem) =>
+          item.kind === "snapshot" ? item.snapshot.snapshotSequence : item.sequence,
+        ),
+      );
 
-function subscribeRpc<A>(
-  rpc: T3Rpc["Service"],
-  method: string,
-  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({
-      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)),
-    }),
-  );
-}
+  const watchThreadItems: Orchestration["watchThreadItems"] = (threadId: string) =>
+    rpc.subscribe(ORCHESTRATION_WS_METHODS.subscribeThread, (client) =>
+      client[ORCHESTRATION_WS_METHODS.subscribeThread]({ threadId: ThreadId.make(threadId) }),
+    );
 
-export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* () {
-  const rpc = yield* T3Rpc;
   const dispatch = Effect.fn("T3OrchestrationLive.dispatch")(function* (
     command: ClientOrchestrationCommand,
   ) {
-    return yield* runRpc(rpc, ORCHESTRATION_WS_METHODS.dispatchCommand, (client) =>
+    return yield* rpc.run(ORCHESTRATION_WS_METHODS.dispatchCommand, (client) =>
       client[ORCHESTRATION_WS_METHODS.dispatchCommand](command),
     );
   });
   const getServerConfig = Effect.fn("T3OrchestrationLive.getServerConfig")(function* () {
-    return yield* runRpc(rpc, WS_METHODS.serverGetConfig, (client) =>
+    return yield* rpc.run(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) =>
+      rpc.subscribe(ORCHESTRATION_WS_METHODS.subscribeShell, (client) =>
         client[ORCHESTRATION_WS_METHODS.subscribeShell]({}),
       ),
     );
@@ -106,12 +64,21 @@ export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* ()
     }
     return value.snapshot;
   });
+  const getArchivedShellSnapshot = Effect.fn("T3OrchestrationLive.getArchivedShellSnapshot")(
+    function* () {
+      return yield* rpc.run(ORCHESTRATION_WS_METHODS.getArchivedShellSnapshot, (client) =>
+        client[ORCHESTRATION_WS_METHODS.getArchivedShellSnapshot]({}),
+      );
+    },
+  );
   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: ThreadId.make(threadId) }),
+      rpc.subscribe(ORCHESTRATION_WS_METHODS.subscribeThread, (client) =>
+        client[ORCHESTRATION_WS_METHODS.subscribeThread]({
+          threadId: ThreadId.make(threadId),
+        }),
       ),
     );
     const value = Option.getOrUndefined(item);
@@ -125,18 +92,6 @@ export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* ()
     }
     return value.snapshot.thread;
   });
-  const watchShellSequence = () =>
-    subscribeRpc(rpc, ORCHESTRATION_WS_METHODS.subscribeShell, (client) =>
-      client[ORCHESTRATION_WS_METHODS.subscribeShell]({}),
-    ).pipe(
-      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: ThreadId.make(threadId) }),
-    );
   const openThread = Effect.fn("T3OrchestrationLive.openThread")(function* (threadId: string) {
     return yield* watchThreadItems(threadId).pipe(
       Stream.peel(Sink.head<OrchestrationThreadStreamItem>()),
@@ -168,6 +123,7 @@ export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* ()
     dispatch,
     getServerConfig,
     getShellSnapshot,
+    getArchivedShellSnapshot,
     getThreadSnapshot,
     watchShellSequence,
     watchThreadItems,
@@ -176,11 +132,3 @@ 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

@@ -10,7 +10,7 @@ import type {
   OrchestrationThread,
   OrchestrationThreadStreamItem,
   ServerProviders,
-} from "#t3tools/contracts";
+} from "@t3tools/contracts";
 
 import type { RpcError } from "../rpc/error.ts";
 
@@ -31,6 +31,10 @@ export type Orchestration = {
   ) => Effect.Effect<DispatchResult, OrchestrationError>;
   readonly getServerConfig: () => Effect.Effect<ServerConfigForCli, OrchestrationError>;
   readonly getShellSnapshot: () => Effect.Effect<OrchestrationShellSnapshot, OrchestrationError>;
+  readonly getArchivedShellSnapshot: () => Effect.Effect<
+    OrchestrationShellSnapshot,
+    OrchestrationError
+  >;
   readonly getThreadSnapshot: (
     threadId: string,
   ) => Effect.Effect<OrchestrationThread, OrchestrationError>;

package/src/rpc/error.ts

@@ -5,13 +5,17 @@ import {
   OrchestrationDispatchCommandError,
   OrchestrationGetSnapshotError,
   ServerSettingsError,
-} from "#t3tools/contracts";
+  TerminalCwdError,
+  TerminalHistoryError,
+  TerminalNotRunningError,
+  TerminalSessionLookupError,
+} from "@t3tools/contracts";
 import { HttpClientError } from "effect/unstable/http";
 import { RpcClientError } from "effect/unstable/rpc";
 
 import { AuthTransportError } from "../auth/error.ts";
 import { T3CodeConnectionError } from "../connection/error.ts";
-import { UrlError } from "../config/error.ts";
+import { UrlError } from "../config/url/error.ts";
 
 const RpcErrorCauseSchema = Schema.Union([
   RpcClientError.RpcClientError,
@@ -20,6 +24,10 @@ const RpcErrorCauseSchema = Schema.Union([
   OrchestrationDispatchCommandError,
   OrchestrationGetSnapshotError,
   ServerSettingsError,
+  TerminalCwdError,
+  TerminalHistoryError,
+  TerminalNotRunningError,
+  TerminalSessionLookupError,
   AuthTransportError,
   T3CodeConnectionError,
   HttpClientError.HttpClientErrorSchema,
@@ -27,6 +35,8 @@ const RpcErrorCauseSchema = Schema.Union([
   Schema.instanceOf(Schema.SchemaError),
 ]);
 
+export type RpcKnownCause = Schema.Schema.Type<typeof RpcErrorCauseSchema>;
+
 export class RpcError extends Schema.TaggedErrorClass<RpcError>()("RpcError", {
   message: Schema.String,
   method: Schema.optionalKey(Schema.String),

package/src/rpc/index.ts

@@ -1 +1,5 @@
-export { RpcError, type OrchestrationError } from "./error.ts";
+export { RpcError } from "./error.ts";
+export { makeT3RpcLayer, T3RpcLive } from "./layer.ts";
+export { T3RpcOperations, T3RpcOperationsLive, makeT3RpcOperations } from "./operation.ts";
+export { T3Rpc } from "./service.ts";
+export type { WsClient } from "./service.ts";

package/src/rpc/layer.ts

@@ -12,7 +12,7 @@ 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 { normalizeHttpBaseUrl, toWebSocketEndpointUrl } from "../config/url/url.ts";
 import { CliWsRpcGroup } from "./ws-group.ts";
 import { RpcError } from "./error.ts";
 import { T3Rpc, type WsClient } from "./service.ts";

package/src/rpc/operation.ts

@@ -0,0 +1,83 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Predicate from "effect/Predicate";
+import * as Schedule from "effect/Schedule";
+import * as Stream from "effect/Stream";
+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 const rpcRetrySchedule = Schedule.exponential("100 millis").pipe(
+  Schedule.take(4),
+  Schedule.collectWhile((metadata: Schedule.Metadata) =>
+    Predicate.isTagged(metadata.input, "RpcClientError"),
+  ),
+);
+
+export type T3RpcOperationsService = {
+  readonly run: <A, R>(
+    method: string,
+    operation: (client: WsClient) => Effect.Effect<A, CliRpcOperationError, R>,
+  ) => Effect.Effect<A, RpcError, R>;
+  readonly subscribe: <A>(
+    method: string,
+    operation: (client: WsClient) => Stream.Stream<A, CliRpcOperationError>,
+  ) => Stream.Stream<A, RpcError>;
+};
+
+export class T3RpcOperations extends Context.Service<T3RpcOperations, T3RpcOperationsService>()(
+  "t3cli/T3RpcOperations",
+) {}
+
+export const makeT3RpcOperations = Effect.fn("makeT3RpcOperations")(function* () {
+  const rpc = yield* T3Rpc;
+
+  const run: T3RpcOperationsService["run"] = <A, R>(
+    method: string,
+    operation: (client: WsClient) => Effect.Effect<A, CliRpcOperationError, R>,
+  ): Effect.Effect<A, RpcError, R> =>
+    rpc.getClient.pipe(
+      Effect.flatMap((client) => operation(client)),
+      Effect.tapError((error) =>
+        Predicate.isTagged(error, "RpcClientError") ? rpc.disconnect : Effect.void,
+      ),
+      Effect.retry(rpcRetrySchedule),
+      Effect.mapError((error) =>
+        Predicate.isTagged(error, "RpcError") ? error : toRpcError(error, method),
+      ),
+    );
+
+  const subscribe: T3RpcOperationsService["subscribe"] = <A>(
+    method: string,
+    operation: (client: WsClient) => Stream.Stream<A, CliRpcOperationError>,
+  ): Stream.Stream<A, RpcError> =>
+    Stream.unwrap(rpc.getClient.pipe(Effect.map((client) => operation(client)))).pipe(
+      Stream.tapError((error) =>
+        Predicate.isTagged(error, "RpcClientError") ? rpc.disconnect : Effect.void,
+      ),
+      Stream.retry(rpcRetrySchedule),
+      Stream.mapError((error) =>
+        Predicate.isTagged(error, "RpcError") ? error : toRpcError(error, method),
+      ),
+    );
+
+  return {
+    run,
+    subscribe,
+  } satisfies T3RpcOperationsService;
+});
+
+export const T3RpcOperationsLive = Layer.effect(T3RpcOperations, makeT3RpcOperations());
+
+function toRpcError(error: CliRpcOperationError, method: string): RpcError {
+  return new RpcError({
+    message: error.message,
+    method,
+    cause: error,
+  });
+}

package/src/rpc/ws-group.ts

@@ -6,11 +6,23 @@ import {
   ServerConfig,
   ServerProviders,
   ServerSettingsError,
+  TerminalCwdError,
+  TerminalHistoryError,
+  TerminalNotRunningError,
+  TerminalSessionLookupError,
   WS_METHODS,
+  WsSubscribeTerminalEventsRpc,
+  WsSubscribeTerminalMetadataRpc,
+  WsTerminalAttachRpc,
+  WsTerminalCloseRpc,
+  WsTerminalOpenRpc,
+  WsTerminalResizeRpc,
+  WsTerminalWriteRpc,
   WsOrchestrationDispatchCommandRpc,
+  WsOrchestrationGetArchivedShellSnapshotRpc,
   WsOrchestrationSubscribeShellRpc,
   WsOrchestrationSubscribeThreadRpc,
-} from "#t3tools/contracts";
+} from "@t3tools/contracts";
 import * as Schema from "effect/Schema";
 import { Rpc, RpcGroup } from "effect/unstable/rpc";
 
@@ -29,7 +41,15 @@ export const WsServerGetConfigRpc = Rpc.make(WS_METHODS.serverGetConfig, {
 });
 
 export const CliWsRpcGroup = RpcGroup.make(
+  WsTerminalOpenRpc,
+  WsTerminalAttachRpc,
+  WsTerminalWriteRpc,
+  WsTerminalResizeRpc,
+  WsTerminalCloseRpc,
+  WsSubscribeTerminalEventsRpc,
+  WsSubscribeTerminalMetadataRpc,
   WsOrchestrationDispatchCommandRpc,
+  WsOrchestrationGetArchivedShellSnapshotRpc,
   WsOrchestrationSubscribeShellRpc,
   WsOrchestrationSubscribeThreadRpc,
   WsServerGetConfigRpc,
@@ -40,4 +60,8 @@ export type CliRpcRequestError =
   | KeybindingsConfigError
   | OrchestrationDispatchCommandError
   | OrchestrationGetSnapshotError
+  | TerminalCwdError
+  | TerminalHistoryError
+  | TerminalNotRunningError
+  | TerminalSessionLookupError
   | ServerSettingsError;

package/src/runtime/index.ts

@@ -1,6 +1,8 @@
 export {
   AppLayer,
   AuthAppLayer,
+  BaseAppLayer,
+  BaseAuthAppLayer,
   T3AuthLayer,
   T3AuthPairingLayer,
   T3AuthTransportLayer,
@@ -9,4 +11,3 @@ export {
   T3LocalAuthTokenLayer,
   T3OrchestrationLayer,
 } from "./layer.ts";
-export { NodeEnvironmentLive } from "../environment/layer.ts";

package/src/runtime/layer.test-utils.ts

@@ -0,0 +1,32 @@
+import * as Layer from "effect/Layer";
+
+import * as CliSelection from "../cli/env/selection-layer.ts";
+import * as CliRuntime from "../cli/runtime/service.ts";
+import * as Config from "../config/config.ts";
+import * as Credential from "../config/credential/service.ts";
+import * as CredentialCipherNode from "../config/credential/cipher-node.ts";
+import { ConfigPlatformLayer } from "../config/platform.test-utils.ts";
+import { t3CliEnvConfigLayer } from "../config/env/env.test-utils.ts";
+import * as Keystore from "../config/keystore/service.test-utils.ts";
+
+export function cliConfigRoutingLayerTest(homeDir: string) {
+  const cliRuntimeLayer = CliRuntime.CliRuntime.layerTest({ cwd: homeDir });
+  const configLayer = t3CliEnvConfigLayer(homeDir, { T3CLI_ENV: "home" });
+  const platformEnvLayer = Layer.mergeAll(cliRuntimeLayer, configLayer);
+
+  return Layer.mergeAll(
+    ConfigPlatformLayer,
+    platformEnvLayer,
+    Config.layer.pipe(
+      Layer.provide(Credential.layer),
+      Layer.provide(
+        Layer.mergeAll(
+          platformEnvLayer,
+          CliSelection.layer.pipe(Layer.provide(platformEnvLayer)),
+          CredentialCipherNode.layerNode,
+          Keystore.unavailableKeystoreFactoryLayer,
+        ),
+      ),
+    ),
+  );
+}

package/src/runtime/layer.test.ts

@@ -0,0 +1,66 @@
+import "vite-plus/test/config";
+
+import * as Effect from "effect/Effect";
+import * as Ref from "effect/Ref";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { assert, describe, it } from "@effect/vitest";
+import { Command } from "effect/unstable/cli";
+
+import { cliEnvironmentSetting } from "../cli/env/flag.ts";
+import type { ResolvedConfig } from "../config/types.ts";
+import { T3Config } from "../config/config.ts";
+import { makeTempHomeScoped } from "../config/temp-home.test-utils.ts";
+import { cliConfigRoutingLayerTest } from "./layer.test-utils.ts";
+
+describe("CLI config routing", () => {
+  it.effect(
+    "routes --environment through Command.run to T3Config.resolve ahead of default and T3CLI_ENV",
+    () =>
+      Effect.gen(function* () {
+        return yield* makeTempHomeScoped("t3cli-runtime-");
+      }).pipe(
+        Effect.flatMap((homeDir) => {
+          const testLayer = cliConfigRoutingLayerTest(homeDir);
+          return Effect.gen(function* () {
+            const resolvedRef = yield* Ref.make<ResolvedConfig | undefined>(undefined);
+            const resolveProbeCommand = Command.make("resolve-probe", {}, () =>
+              Effect.gen(function* () {
+                const config = yield* T3Config;
+                const resolved = yield* config.resolve();
+                yield* Ref.set(resolvedRef, resolved);
+              }),
+            ).pipe(Command.withGlobalFlags([cliEnvironmentSetting]));
+            const runResolveProbe = Command.runWith(resolveProbeCommand, { version: "0.0.0-test" });
+
+            yield* Effect.gen(function* () {
+              const config = yield* T3Config;
+              yield* config.upsertEnvironment({
+                name: "home",
+                url: "https://home.example",
+                token: "home-token",
+                local: false,
+              });
+              yield* config.upsertEnvironment({
+                name: "work",
+                url: "https://work.example",
+                token: "work-token",
+                local: false,
+              });
+            }).pipe(Effect.provide(testLayer));
+
+            yield* runResolveProbe(["--environment", "work"]).pipe(Effect.provide(testLayer));
+
+            const resolved = yield* Ref.get(resolvedRef);
+            assert.isDefined(resolved);
+            assert.equal(resolved.source, "config");
+            if (resolved.source === "config") {
+              assert.equal(resolved.environment, "work");
+              assert.equal(resolved.token, "work-token");
+            }
+          });
+        }),
+        Effect.provide(NodeServices.layer),
+        Effect.scoped,
+      ),
+  );
+});

package/src/runtime/layer.ts

@@ -10,15 +10,18 @@ import { T3LocalAuthOriginLive } from "../auth/local-origin.ts";
 import { T3LocalAuthTokenLive } from "../auth/local-token.ts";
 import { T3AuthPairingLive } from "../auth/pairing.ts";
 import { T3AuthTransportLive } from "../auth/transport.ts";
-import { T3ConfigLive } from "../config/layer.ts";
-import { T3Config } from "../config/service.ts";
+import * as Config from "../config/config.ts";
+import * as Credential from "../config/credential/service.ts";
+import * as Selection from "../config/selection/service.ts";
 import { T3CodeConnectionError } from "../connection/error.ts";
 import { T3CodeConnectionProvider, makeT3CodeConnectionProvider } from "../connection/service.ts";
 import { T3OrchestrationLive } from "../orchestration/layer.ts";
 import { T3RpcLive } from "../rpc/layer.ts";
+import { T3RpcOperationsLive } from "../rpc/operation.ts";
 import { NodeSqlClientFactoryLive } from "../sql/node-sqlite-client.ts";
 import { NodeCliPathLayer } from "../cli-path/layer.ts";
 
+export const T3ConfigLayer = Config.layer.pipe(Layer.provide(Credential.layer));
 export const T3AuthTransportLayer = T3AuthTransportLive.pipe(
   Layer.provide(NodeHttpClient.layerUndici),
 );
@@ -32,13 +35,13 @@ export const T3LocalAuthLayer = T3LocalAuthLive.pipe(
 export const T3AuthPairingLayer = T3AuthPairingLive.pipe(Layer.provide(T3AuthTransportLayer));
 export const T3AuthLayer = T3AuthLive.pipe(
   Layer.provide(
-    Layer.mergeAll(T3ConfigLive, T3AuthTransportLayer, T3LocalAuthLayer, T3AuthPairingLayer),
+    Layer.mergeAll(T3ConfigLayer, T3AuthTransportLayer, T3LocalAuthLayer, T3AuthPairingLayer),
   ),
 );
 const T3ConfigConnectionProviderLayer = Layer.effect(
   T3CodeConnectionProvider,
   Effect.gen(function* () {
-    const config = yield* T3Config;
+    const config = yield* Config.T3Config;
     return makeT3CodeConnectionProvider(
       config.resolve().pipe(
         Effect.map((resolved) => ({
@@ -55,7 +58,7 @@ const T3ConfigConnectionProviderLayer = Layer.effect(
       ),
     );
   }),
-).pipe(Layer.provide(T3ConfigLive));
+).pipe(Layer.provide(T3ConfigLayer));
 
 const T3RpcLayer = T3RpcLive.pipe(
   Layer.provide(
@@ -66,16 +69,24 @@ const T3RpcLayer = T3RpcLive.pipe(
     ),
   ),
 );
-export const T3OrchestrationLayer = T3OrchestrationLive.pipe(Layer.provide(T3RpcLayer));
-const T3ApplicationLayer = T3ApplicationLive.pipe(Layer.provide(T3OrchestrationLayer));
-
-export const AuthAppLayer = Layer.mergeAll(T3ConfigLive, T3AuthLayer);
+const T3RpcOperationsLayer = T3RpcOperationsLive.pipe(Layer.provide(T3RpcLayer));
+export const T3OrchestrationLayer = T3OrchestrationLive.pipe(Layer.provide(T3RpcOperationsLayer));
+const T3ApplicationLayer = T3ApplicationLive.pipe(
+  Layer.provide(Layer.mergeAll(T3RpcOperationsLayer, T3OrchestrationLayer)),
+);
 
-export const AppLayer = Layer.mergeAll(
-  T3ConfigLive,
+export const BaseAppLayer = Layer.mergeAll(
+  T3ConfigLayer,
   T3AuthLayer,
   T3RpcLayer,
+  T3RpcOperationsLayer,
   T3OrchestrationLayer,
   T3ApplicationLayer,
   NodeCliPathLayer,
 );
+
+export const BaseAuthAppLayer = Layer.mergeAll(T3ConfigLayer, T3AuthLayer);
+
+export const AuthAppLayer = BaseAuthAppLayer.pipe(Layer.provideMerge(Selection.layer));
+
+export const AppLayer = BaseAppLayer.pipe(Layer.provideMerge(Selection.layer));

package/src/t3tools/index.ts

@@ -1 +1 @@
-export * from "#t3tools/contracts";
+export * from "@t3tools/contracts";

package/src/types/marked-terminal.d.ts

@@ -0,0 +1,11 @@
+declare module "marked-terminal" {
+  import type { MarkedExtension } from "marked";
+
+  export type TerminalRendererOptions = {
+    readonly reflowText?: boolean;
+    readonly showSectionPrefix?: boolean;
+    readonly width?: number;
+  };
+
+  export function markedTerminal(options?: TerminalRendererOptions): MarkedExtension;
+}

package/dist/layout.js

@@ -1,2 +0,0 @@
-import { M as readT3LayoutFromNodeProcess, N as resolveT3BaseDir } from "./shared.js";
-export { readT3LayoutFromNodeProcess, resolveT3BaseDir };

package/dist/scope.js

@@ -1,2 +0,0 @@
-import { Ad as resolveProjectRef, Md as resolveWorktreePath, jd as resolveThreadId, kd as resolveCommandProjectRef } from "./shared.js";
-export { resolveCommandProjectRef, resolveProjectRef, resolveThreadId, resolveWorktreePath };

package/dist/src/cli/output-format.d.ts

@@ -1,9 +0,0 @@
-import type { EnvironmentShape } from "../environment/service.ts";
-export declare const humanJsonFormatChoices: readonly ["auto", "human", "json"];
-export declare const humanNdjsonFormatChoices: readonly ["auto", "human", "ndjson"];
-export declare const humanJsonNdjsonFormatChoices: readonly ["auto", "human", "json", "ndjson"];
-export type HumanJsonFormat = (typeof humanJsonFormatChoices)[number];
-export type HumanNdjsonFormat = (typeof humanNdjsonFormatChoices)[number];
-export type HumanJsonNdjsonFormat = (typeof humanJsonNdjsonFormatChoices)[number];
-export declare function resolveOutputFormat<T extends "json" | "ndjson">(format: "auto" | "human" | T, environment: EnvironmentShape, nonHumanFormat: T): "human" | T;
-export declare function canRenderLiveTerminal(environment: EnvironmentShape): boolean;

package/dist/src/config/layer.d.ts

@@ -1,22 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Layer from "effect/Layer";
-import * as Path from "effect/Path";
-import { Environment } from "../environment/service.ts";
-import { ConfigError } from "./error.ts";
-import { T3Config, type StoredConfig } from "./service.ts";
-export declare const makeT3Config: () => Effect.Effect<{
-    readStored: () => Effect.Effect<{
-        readonly url?: string;
-        readonly token?: string;
-        readonly local?: boolean;
-    }, ConfigError, never>;
-    writeStored: (config: StoredConfig) => Effect.Effect<void, ConfigError, never>;
-    resolve: () => Effect.Effect<{
-        url: string;
-        token: string;
-        source: "config" | "env";
-        local: boolean;
-    }, import("./error.ts").UrlError | ConfigError, never>;
-}, never, Environment | Path.Path | FileSystem.FileSystem>;
-export declare const T3ConfigLive: Layer.Layer<T3Config, never, Environment | Path.Path | FileSystem.FileSystem>;

package/dist/src/config/service.d.ts

@@ -1,22 +0,0 @@
-import * as Context from "effect/Context";
-import type * as Effect from "effect/Effect";
-import type { ConfigError, ConfigServiceError } from "./error.ts";
-export type StoredConfig = {
-    readonly url?: string;
-    readonly token?: string;
-    readonly local?: boolean;
-};
-export type ResolvedConfig = {
-    readonly url: string;
-    readonly token: string;
-    readonly source: "env" | "config";
-    readonly local: boolean;
-};
-declare const T3Config_base: Context.ServiceClass<T3Config, "t3cli/T3Config", {
-    readonly readStored: () => Effect.Effect<StoredConfig, ConfigError>;
-    readonly writeStored: (config: StoredConfig) => Effect.Effect<void, ConfigError>;
-    readonly resolve: () => Effect.Effect<ResolvedConfig, ConfigServiceError>;
-}>;
-export declare class T3Config extends T3Config_base {
-}
-export {};