t3code-cli 0.14.2 → 0.15.0

package/src/cli/threads/settle.ts

@@ -0,0 +1,46 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Command } from "effect/unstable/cli";
+
+import { T3Application } from "../../application/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import { MissingThreadError } from "../error.ts";
+import { extraArgsConfig } from "../extra-args.ts";
+import { formatFlag, threadFlag } from "../flags.ts";
+import { resolveOutputFormat } from "../format/output.ts";
+import { T3Output } from "../output/service.ts";
+import { CliRuntime } from "../runtime/service.ts";
+import { resolveThreadId } from "../scope/index.ts";
+
+export const settleThreadCommand = Command.make(
+  "settle",
+  {
+    thread: threadFlag,
+    format: formatFlag,
+    ...extraArgsConfig,
+  },
+  ({ thread, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
+      const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        scope: t3CliEnv.scope,
+      });
+      if (threadId === undefined) {
+        return yield* Effect.fail(
+          new MissingThreadError({
+            message: "thread id is required: pass --thread or set T3CODE_THREAD_ID",
+          }),
+        );
+      }
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
+      const dispatch = yield* application.settleThread(threadId);
+      if (resolvedFormat === "json") {
+        return yield* output.printJson(dispatch);
+      }
+      return yield* output.printInfo(`thread settled: ${threadId} (sequence ${dispatch.sequence})`);
+    }),
+).pipe(Command.withDescription("settle thread"));

package/src/cli/threads/snooze.ts

@@ -0,0 +1,117 @@
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { Command, Flag } from "effect/unstable/cli";
+import {
+  resolveSnoozePresets,
+  type SnoozePresetId,
+} from "@t3tools/client-runtime/state/thread-settled";
+
+import { T3Application } from "../../application/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import {
+  InvalidFlagCombinationError,
+  InvalidSnoozeUntilError,
+  MissingThreadError,
+  UnavailableSnoozePresetError,
+} from "../error.ts";
+import { extraArgsConfig } from "../extra-args.ts";
+import { formatFlag, threadFlag } from "../flags.ts";
+import { resolveOutputFormat } from "../format/output.ts";
+import { T3Output } from "../output/service.ts";
+import { CliRuntime } from "../runtime/service.ts";
+import { resolveThreadId } from "../scope/index.ts";
+
+const snoozePresetChoices = [
+  "hour",
+  "evening",
+  "tomorrow",
+  "next-week",
+] as const satisfies ReadonlyArray<SnoozePresetId>;
+
+export const snoozeThreadCommand = Command.make(
+  "snooze",
+  {
+    thread: threadFlag,
+    until: Flag.string("until").pipe(Flag.optional),
+    preset: Flag.choice("preset", snoozePresetChoices).pipe(Flag.optional),
+    format: formatFlag,
+    ...extraArgsConfig,
+  },
+  ({ thread, until, preset, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
+      const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        scope: t3CliEnv.scope,
+      });
+      if (threadId === undefined) {
+        return yield* Effect.fail(
+          new MissingThreadError({
+            message: "thread id is required: pass --thread or set T3CODE_THREAD_ID",
+          }),
+        );
+      }
+
+      const untilValue = Option.getOrUndefined(until);
+      const presetValue = Option.getOrUndefined(preset);
+      if (untilValue !== undefined && presetValue !== undefined) {
+        return yield* Effect.fail(
+          new InvalidFlagCombinationError({
+            message: "exactly one of --until or --preset is required",
+          }),
+        );
+      }
+
+      let snoozedUntil: string;
+      if (untilValue !== undefined) {
+        snoozedUntil = yield* Schema.decodeUnknownEffect(Schema.DateTimeUtcFromString)(
+          untilValue,
+        ).pipe(
+          Effect.map(DateTime.formatIso),
+          Effect.mapError(
+            () =>
+              new InvalidSnoozeUntilError({
+                message: `invalid ISO-8601 snooze time: ${untilValue}`,
+                value: untilValue,
+              }),
+          ),
+        );
+      } else if (presetValue !== undefined) {
+        snoozedUntil = yield* resolveSnoozePreset(presetValue);
+      } else {
+        return yield* Effect.fail(
+          new InvalidFlagCombinationError({
+            message: "exactly one of --until or --preset is required",
+          }),
+        );
+      }
+
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
+      const dispatch = yield* application.snoozeThread({ threadId, snoozedUntil });
+      if (resolvedFormat === "json") {
+        return yield* output.printJson(dispatch);
+      }
+      return yield* output.printInfo(
+        `thread snoozed: ${threadId} until ${snoozedUntil} (sequence ${dispatch.sequence})`,
+      );
+    }),
+).pipe(Command.withDescription("snooze thread"));
+
+const resolveSnoozePreset = Effect.fn("resolveSnoozePreset")(function* (presetId: SnoozePresetId) {
+  const now = yield* DateTime.nowAsDate;
+  const preset = resolveSnoozePresets(now).find((candidate) => candidate.id === presetId);
+  if (preset === undefined) {
+    return yield* Effect.fail(
+      new UnavailableSnoozePresetError({
+        message: `snooze preset is not available at this time: ${presetId}`,
+        preset: presetId,
+      }),
+    );
+  }
+  return preset.snoozedUntil;
+});

package/src/cli/threads/start.ts

@@ -129,7 +129,12 @@ export const startThreadCommand = Command.make(
 
       const result = yield* application.startThread(input, { until: "visible" });
       if (resolvedFormat === "json") {
-        yield* output.printJson(result);
+        yield* output.printJson({
+          dispatch: result.dispatch,
+          project: result.project,
+          threadId: result.threadId,
+          thread: result.thread,
+        });
       } else {
         yield* output.printInfo(
           formatThreadStartedHuman({

package/src/cli/threads/unpin.ts

@@ -0,0 +1,48 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Command } from "effect/unstable/cli";
+
+import { T3Application } from "../../application/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import { MissingThreadError } from "../error.ts";
+import { extraArgsConfig } from "../extra-args.ts";
+import { formatFlag, threadFlag } from "../flags.ts";
+import { resolveOutputFormat } from "../format/output.ts";
+import { T3Output } from "../output/service.ts";
+import { CliRuntime } from "../runtime/service.ts";
+import { resolveThreadId } from "../scope/index.ts";
+
+export const unpinThreadCommand = Command.make(
+  "unpin",
+  {
+    thread: threadFlag,
+    format: formatFlag,
+    ...extraArgsConfig,
+  },
+  ({ thread, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
+      const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        scope: t3CliEnv.scope,
+      });
+      if (threadId === undefined) {
+        return yield* Effect.fail(
+          new MissingThreadError({
+            message: "thread id is required: pass --thread or set T3CODE_THREAD_ID",
+          }),
+        );
+      }
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
+      const dispatch = yield* application.unpinThread(threadId);
+      if (resolvedFormat === "json") {
+        return yield* output.printJson(dispatch);
+      }
+      return yield* output.printInfo(
+        `thread unpinned: ${threadId} (sequence ${dispatch.sequence})`,
+      );
+    }),
+).pipe(Command.withDescription("unpin thread"));

package/src/cli/threads/unsettle.ts

@@ -0,0 +1,48 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Command } from "effect/unstable/cli";
+
+import { T3Application } from "../../application/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import { MissingThreadError } from "../error.ts";
+import { extraArgsConfig } from "../extra-args.ts";
+import { formatFlag, threadFlag } from "../flags.ts";
+import { resolveOutputFormat } from "../format/output.ts";
+import { T3Output } from "../output/service.ts";
+import { CliRuntime } from "../runtime/service.ts";
+import { resolveThreadId } from "../scope/index.ts";
+
+export const unsettleThreadCommand = Command.make(
+  "unsettle",
+  {
+    thread: threadFlag,
+    format: formatFlag,
+    ...extraArgsConfig,
+  },
+  ({ thread, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
+      const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        scope: t3CliEnv.scope,
+      });
+      if (threadId === undefined) {
+        return yield* Effect.fail(
+          new MissingThreadError({
+            message: "thread id is required: pass --thread or set T3CODE_THREAD_ID",
+          }),
+        );
+      }
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
+      const dispatch = yield* application.unsettleThread(threadId);
+      if (resolvedFormat === "json") {
+        return yield* output.printJson(dispatch);
+      }
+      return yield* output.printInfo(
+        `thread unsettled: ${threadId} (sequence ${dispatch.sequence})`,
+      );
+    }),
+).pipe(Command.withDescription("unsettle thread"));

package/src/cli/threads/unsnooze.ts

@@ -0,0 +1,48 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Command } from "effect/unstable/cli";
+
+import { T3Application } from "../../application/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import { MissingThreadError } from "../error.ts";
+import { extraArgsConfig } from "../extra-args.ts";
+import { formatFlag, threadFlag } from "../flags.ts";
+import { resolveOutputFormat } from "../format/output.ts";
+import { T3Output } from "../output/service.ts";
+import { CliRuntime } from "../runtime/service.ts";
+import { resolveThreadId } from "../scope/index.ts";
+
+export const unsnoozeThreadCommand = Command.make(
+  "unsnooze",
+  {
+    thread: threadFlag,
+    format: formatFlag,
+    ...extraArgsConfig,
+  },
+  ({ thread, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
+      const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        scope: t3CliEnv.scope,
+      });
+      if (threadId === undefined) {
+        return yield* Effect.fail(
+          new MissingThreadError({
+            message: "thread id is required: pass --thread or set T3CODE_THREAD_ID",
+          }),
+        );
+      }
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
+      const dispatch = yield* application.unsnoozeThread(threadId);
+      if (resolvedFormat === "json") {
+        return yield* output.printJson(dispatch);
+      }
+      return yield* output.printInfo(
+        `thread unsnoozed: ${threadId} (sequence ${dispatch.sequence})`,
+      );
+    }),
+).pipe(Command.withDescription("unsnooze thread"));

package/src/connection/prepared.ts

@@ -16,10 +16,20 @@ import { T3CodeConnectionError } from "./error.ts";
 import { T3CodeConnectionProvider } from "./service.ts";
 import type { T3CodeConnection } from "./type.ts";
 
+export interface T3PreparedConnection extends PreparedConnection {
+  readonly httpAuthorization: {
+    readonly _tag: "Bearer";
+    readonly token: string;
+  };
+}
+
 export class T3PreparedConnectionProvider extends Context.Service<
   T3PreparedConnectionProvider,
   {
-    readonly get: Effect.Effect<PreparedConnection, ConnectionAttemptError | T3CodeConnectionError>;
+    readonly get: Effect.Effect<
+      T3PreparedConnection,
+      ConnectionAttemptError | T3CodeConnectionError
+    >;
   }
 >()("t3cli/T3PreparedConnectionProvider") {}
 
@@ -59,7 +69,7 @@ const makePreparedConnection = Effect.fn("makePreparedConnection")(function* (
       label: descriptor.label,
       connectionId: descriptor.environmentId,
     }),
-  } satisfies PreparedConnection;
+  } satisfies T3PreparedConnection;
 });
 
 const makeT3PreparedConnectionProvider = Effect.fn("makeT3PreparedConnectionProvider")(

package/src/orchestration/error.ts

@@ -0,0 +1,10 @@
+import * as Schema from "effect/Schema";
+
+export class ThreadSnapshotRequestError extends Schema.TaggedErrorClass<ThreadSnapshotRequestError>()(
+  "ThreadSnapshotRequestError",
+  {
+    message: Schema.String,
+    threadId: Schema.String,
+    cause: Schema.Defect(),
+  },
+) {}

package/src/orchestration/index.ts

@@ -4,4 +4,5 @@ export {
   type Orchestration,
   type OrchestrationError,
 } from "./service.ts";
+export { ThreadSnapshotRequestError } from "./error.ts";
 export { makeT3Orchestration, T3OrchestrationLive } from "./layer.ts";

package/src/orchestration/layer.ts

@@ -3,6 +3,7 @@ import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
+import { HttpClient } from "effect/unstable/http";
 import {
   ORCHESTRATION_WS_METHODS,
   ThreadId,
@@ -12,14 +13,25 @@ import {
   type OrchestrationShellStreamItem,
   type OrchestrationThreadStreamItem,
 } from "@t3tools/contracts";
+import { environmentEndpointUrl } from "@t3tools/client-runtime/environment";
+import {
+  executeEnvironmentHttpRequest,
+  makeEnvironmentHttpApiClient,
+} from "@t3tools/client-runtime/rpc";
 import { applyShellStreamEvent } from "@t3tools/client-runtime/state/shell";
 
+import { T3PreparedConnectionProvider } from "../connection/prepared.ts";
 import { RpcError } from "../rpc/error.ts";
 import { T3RpcOperations } from "../rpc/operation.ts";
+import { ThreadSnapshotRequestError } from "./error.ts";
 import { T3Orchestration, type OpenThread, type Orchestration } from "./service.ts";
 
+const THREAD_SNAPSHOT_TIMEOUT_MS = 30_000;
+
 export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* () {
   const rpc = yield* T3RpcOperations;
+  const preparedConnectionProvider = yield* T3PreparedConnectionProvider;
+  const httpClient = yield* HttpClient.HttpClient;
 
   const watchShellSnapshots: Orchestration["watchShellSnapshots"] = () =>
     rpc
@@ -133,6 +145,65 @@ export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* ()
     }
     return value.snapshot.thread;
   });
+  const getThreadDetailSnapshot: Orchestration["getThreadDetailSnapshot"] = Effect.fn(
+    "T3OrchestrationLive.getThreadDetailSnapshot",
+  )(function* (input) {
+    const paginationSupported =
+      input.window === undefined
+        ? true
+        : (yield* getServerConfig()).threadSnapshotPagination === true;
+    const window = paginationSupported ? input.window : undefined;
+    const prepared = yield* preparedConnectionProvider.get.pipe(
+      Effect.mapError(
+        (cause) =>
+          new ThreadSnapshotRequestError({
+            message: "failed to prepare the thread snapshot request",
+            threadId: input.threadId,
+            cause,
+          }),
+      ),
+    );
+    const threadId = ThreadId.make(input.threadId);
+    const requestUrl = environmentEndpointUrl(
+      prepared.httpBaseUrl,
+      `/api/orchestration/threads/${threadId}`,
+    );
+    const client = yield* makeEnvironmentHttpApiClient(prepared.httpBaseUrl).pipe(
+      Effect.provideService(HttpClient.HttpClient, httpClient),
+      Effect.mapError(
+        (cause) =>
+          new ThreadSnapshotRequestError({
+            message: "failed to create the thread snapshot client",
+            threadId: input.threadId,
+            cause,
+          }),
+      ),
+    );
+    return yield* executeEnvironmentHttpRequest(
+      requestUrl,
+      THREAD_SNAPSHOT_TIMEOUT_MS,
+      client.orchestration.threadSnapshot({
+        params: { threadId },
+        payload: {
+          ...(window !== undefined ? { turnLimit: window.turnLimit } : {}),
+          ...(window?.beforeCursor !== undefined ? { beforeCursor: window.beforeCursor } : {}),
+        },
+        headers: {
+          authorization: `Bearer ${prepared.httpAuthorization.token}`,
+        },
+      }),
+    ).pipe(
+      Effect.provideService(HttpClient.HttpClient, httpClient),
+      Effect.mapError(
+        (cause) =>
+          new ThreadSnapshotRequestError({
+            message: "failed to load the thread snapshot",
+            threadId: input.threadId,
+            cause,
+          }),
+      ),
+    );
+  });
   const openThread = Effect.fn("T3OrchestrationLive.openThread")(function* (threadId: string) {
     return yield* watchThreadItems(threadId).pipe(
       Stream.peel(Sink.head<OrchestrationThreadStreamItem>()),
@@ -167,6 +238,7 @@ export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* ()
     getArchivedShellSnapshot,
     searchThreads,
     getThreadSnapshot,
+    getThreadDetailSnapshot,
     watchShellSnapshots,
     watchShellSequence,
     watchThreadItems,

package/src/orchestration/service.ts

@@ -10,22 +10,26 @@ import type {
   OrchestrationSearchThreadsInput,
   OrchestrationSearchThreadsResult,
   OrchestrationThread,
+  OrchestrationThreadDetailSnapshot,
+  OrchestrationThreadDetailWindow,
   OrchestrationThreadStreamItem,
   ServerProviders,
 } from "@t3tools/contracts";
 
+import type { ThreadSnapshotRequestError } from "./error.ts";
 import type { RpcError } from "../rpc/error.ts";
 
-export type OrchestrationError = RpcError;
+export type OrchestrationError = RpcError | ThreadSnapshotRequestError;
 
 export type OpenThread = {
   readonly snapshot: OrchestrationThread;
   readonly events: Stream.Stream<OrchestrationEvent, OrchestrationError>;
 };
 
-export type ServerConfigForCli = {
+export interface ServerConfigForCli {
   readonly providers: ServerProviders;
-};
+  readonly threadSnapshotPagination?: boolean;
+}
 
 export type Orchestration = {
   readonly dispatch: (
@@ -43,6 +47,10 @@ export type Orchestration = {
   readonly getThreadSnapshot: (
     threadId: string,
   ) => Effect.Effect<OrchestrationThread, OrchestrationError>;
+  readonly getThreadDetailSnapshot: (input: {
+    readonly threadId: string;
+    readonly window?: OrchestrationThreadDetailWindow;
+  }) => Effect.Effect<OrchestrationThreadDetailSnapshot, OrchestrationError>;
   readonly watchShellSnapshots: () => Stream.Stream<
     OrchestrationShellSnapshot,
     OrchestrationError,

package/src/rpc/ws-group.ts

@@ -31,6 +31,7 @@ export const CliServerConfig = Schema.Struct({
     }),
   }),
   providers: ServerProviders,
+  threadSnapshotPagination: Schema.optionalKey(Schema.Boolean),
 });
 export type CliServerConfig = typeof CliServerConfig.Type;
 

package/src/runtime/layer.ts

@@ -63,18 +63,23 @@ const T3ConfigConnectionProviderLayer = Layer.effect(
   }),
 ).pipe(Layer.provide(T3ConfigLayer));
 
+const T3PreparedConnectionLayer = T3PreparedConnectionProviderLive.pipe(
+  Layer.provide(Layer.mergeAll(T3ConfigConnectionProviderLayer, NodeHttpClient.layerUndici)),
+);
 const T3RpcLayer = T3RpcLive.pipe(
   Layer.provide(
     Layer.mergeAll(
-      T3PreparedConnectionProviderLive.pipe(
-        Layer.provide(Layer.mergeAll(T3ConfigConnectionProviderLayer, NodeHttpClient.layerUndici)),
-      ),
+      T3PreparedConnectionLayer,
       T3RpcSessionFactoryLive.pipe(Layer.provide(NodeSocket.layerWebSocketConstructor)),
     ),
   ),
 );
 const T3RpcOperationsLayer = T3RpcOperationsLive.pipe(Layer.provide(T3RpcLayer));
-export const T3OrchestrationLayer = T3OrchestrationLive.pipe(Layer.provide(T3RpcOperationsLayer));
+export const T3OrchestrationLayer = T3OrchestrationLive.pipe(
+  Layer.provide(
+    Layer.mergeAll(T3RpcOperationsLayer, T3PreparedConnectionLayer, NodeHttpClient.layerUndici),
+  ),
+);
 export const T3PreviewAutomationLayer = T3PreviewAutomationLive.pipe(
   Layer.provide(T3RpcOperationsLayer),
 );