t3code-cli 0.10.0 → 0.12.0

package/src/cli/terminal/wait.test.ts

@@ -0,0 +1,148 @@
+import "vite-plus/test/config";
+
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import * as Option from "effect/Option";
+import * as Stream from "effect/Stream";
+import { assert, describe, expect, it } from "@effect/vitest";
+import { Command } from "effect/unstable/cli";
+import { fromPartial } from "@total-typescript/shoehorn";
+
+import { T3Application } from "../../application/service.ts";
+import { T3Config } from "../../config/config.ts";
+import * as CliRuntime from "../../cli/runtime/service.ts";
+import { t3CliEnvConfigLayer } from "../../config/env/env.test-utils.ts";
+import { T3Output } from "../output/service.ts";
+import { TerminalCliError } from "./error.ts";
+import { resolveMetadataWait, waitTerminalCommand } from "./wait.ts";
+
+describe("resolveMetadataWait", () => {
+  it("resolves closed immediately when terminal is missing from snapshot", () => {
+    const resolution = resolveMetadataWait(
+      { type: "snapshot", terminals: [] },
+      "closed",
+      "thread-1",
+      "term-1",
+    );
+    expect(resolution).toEqual({
+      kind: "result",
+      value: {
+        threadId: "thread-1",
+        terminalId: "term-1",
+        target: "closed",
+        status: "closed",
+        alreadySatisfied: true,
+        missingTreatedAsClosed: true,
+      },
+    });
+  });
+
+  it("uses the same exited error when terminal is missing from snapshot or removed", () => {
+    const missing = resolveMetadataWait(
+      { type: "snapshot", terminals: [] },
+      "exited",
+      "thread-1",
+      "term-1",
+    );
+    const removed = resolveMetadataWait(
+      { type: "remove", threadId: "thread-1", terminalId: "term-1" },
+      "exited",
+      "thread-1",
+      "term-1",
+    );
+
+    expect(missing?.kind).toBe("fail");
+    expect(removed?.kind).toBe("fail");
+    if (missing?.kind === "fail" && removed?.kind === "fail") {
+      expect(missing.error.message).toBe(removed.error.message);
+      expect(missing.error).toBeInstanceOf(TerminalCliError);
+    }
+  });
+});
+
+describe("waitTerminalCommand", () => {
+  const testLayer = Layer.mergeAll(
+    Layer.succeed(
+      T3Application,
+      fromPartial({
+        getTerminal: () => Effect.die("getTerminal should not be called"),
+        watchTerminalMetadata: () =>
+          Stream.make({
+            type: "snapshot" as const,
+            terminals: [],
+          }),
+      }),
+    ),
+    Layer.succeed(
+      T3Config,
+      fromPartial({
+        resolve: () =>
+          Effect.succeed({
+            url: "ws://localhost",
+            token: "token",
+            source: "config",
+            local: true,
+          }),
+      }),
+    ),
+    Layer.succeed(T3Output, {
+      writeStdout: () => Effect.void,
+      writeStderr: () => Effect.void,
+      printJson: () => Effect.void,
+      printNdjson: () => Effect.void,
+      printInfo: () => Effect.void,
+    }),
+    NodeServices.layer,
+    CliRuntime.layer,
+    t3CliEnvConfigLayer("/tmp/t3cli-test"),
+  );
+
+  it.layer(testLayer)("waitTerminalCommand", (t) => {
+    t.effect("does not require getTerminal before waiting for closed", () =>
+      Effect.gen(function* () {
+        const run = Command.runWith(waitTerminalCommand, { version: "0.0.0-test" });
+        const exit = yield* run([
+          "--thread",
+          "thread-1",
+          "term-1",
+          "--for",
+          "closed",
+          "--format",
+          "json",
+        ]).pipe(Effect.exit);
+        assert.isTrue(Exit.isSuccess(exit));
+      }),
+    );
+
+    t.effect("uses exited error without getTerminal when terminal is already missing", () =>
+      Effect.gen(function* () {
+        const run = Command.runWith(waitTerminalCommand, { version: "0.0.0-test" });
+        const exit = yield* run([
+          "--thread",
+          "thread-1",
+          "term-1",
+          "--for",
+          "exited",
+          "--format",
+          "json",
+        ]).pipe(Effect.exit);
+        assert.isTrue(Exit.isFailure(exit));
+        if (!Exit.isFailure(exit)) {
+          return;
+        }
+        const error = Cause.findErrorOption(exit.cause);
+        assert.isTrue(Option.isSome(error));
+        if (Option.isSome(error)) {
+          assert.instanceOf(error.value, TerminalCliError);
+          assert.equal(
+            error.value.message,
+            "terminal closed before an exited event was observed: term-1",
+          );
+        }
+      }),
+    );
+  });
+});

package/src/cli/terminal/wait.ts

@@ -0,0 +1,223 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Stream from "effect/Stream";
+import type { TerminalMetadataStreamEvent, TerminalSummary } from "@t3tools/contracts";
+import { Argument, Command, Flag } from "effect/unstable/cli";
+
+import { T3Application } from "../../application/service.ts";
+import { extraArgsConfig } from "../extra-args.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import { formatFlag, threadFlag } from "../flags.ts";
+import { resolveOutputFormat } from "../format/output.ts";
+import { T3Output } from "../output/service.ts";
+import { TerminalCliError } from "./error.ts";
+import { requireCommandThreadId } from "./scope.ts";
+
+const terminalWaitTargetChoices = ["exited", "closed", "ended"] as const;
+type TerminalWaitTarget = (typeof terminalWaitTargetChoices)[number];
+
+type WaitResult =
+  | {
+      readonly threadId: string;
+      readonly terminalId: string;
+      readonly target: TerminalWaitTarget;
+      readonly status: string;
+      readonly exitCode?: number | null;
+      readonly exitSignal?: number | null;
+      readonly updatedAt?: string;
+      readonly sequence?: number;
+      readonly alreadySatisfied: boolean;
+      readonly missingTreatedAsClosed?: true;
+    }
+  | {
+      readonly threadId: string;
+      readonly terminalId: string;
+      readonly target: TerminalWaitTarget;
+      readonly status: "exited" | "closed";
+      readonly exitCode?: number | null;
+      readonly exitSignal?: number | null;
+      readonly sequence?: number;
+      readonly alreadySatisfied: false;
+    };
+
+type WaitResolution =
+  | { readonly kind: "result"; readonly value: WaitResult }
+  | { readonly kind: "fail"; readonly error: TerminalCliError };
+
+export const waitTerminalCommand = Command.make(
+  "wait",
+  {
+    thread: threadFlag,
+    terminalId: Argument.string("terminal-id"),
+    target: Flag.choice("for", terminalWaitTargetChoices).pipe(Flag.withDefault("exited")),
+    format: formatFlag,
+    ...extraArgsConfig,
+  },
+  ({ thread, terminalId, target, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
+      const output = yield* T3Output;
+      const threadId = yield* requireCommandThreadId({ thread });
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
+
+      const resolution = yield* application.watchTerminalMetadata().pipe(
+        Stream.map((event) => resolveMetadataWait(event, target, threadId, terminalId)),
+        Stream.filter((value): value is WaitResolution => value !== null),
+        Stream.runHead,
+      );
+
+      if (Option.isNone(resolution)) {
+        yield* Effect.fail(
+          new TerminalCliError({
+            message: "terminal wait stream ended unexpectedly",
+            threadId,
+            terminalId,
+          }),
+        );
+      } else if (resolution.value.kind === "fail") {
+        yield* Effect.fail(resolution.value.error);
+      } else {
+        const result = resolution.value.value;
+        if (resolvedFormat === "json") {
+          yield* output.printJson(result);
+        } else {
+          yield* output.printInfo(formatWaitHuman(result));
+        }
+      }
+    }),
+).pipe(Command.withDescription("wait for terminal lifecycle events"));
+
+function terminalClosedBeforeExitError(threadId: string, terminalId: string) {
+  return new TerminalCliError({
+    message: `terminal closed before an exited event was observed: ${terminalId}`,
+    threadId,
+    terminalId,
+  });
+}
+
+export function resolveMetadataWait(
+  event: TerminalMetadataStreamEvent,
+  target: TerminalWaitTarget,
+  threadId: string,
+  terminalId: string,
+): WaitResolution | null {
+  if (event.type === "snapshot") {
+    const terminal = event.terminals.find(
+      (candidate) => candidate.threadId === threadId && candidate.terminalId === terminalId,
+    );
+    if (terminal !== undefined) {
+      if (targetSatisfiedBySummary(target, terminal)) {
+        return {
+          kind: "result",
+          value: {
+            threadId: terminal.threadId,
+            terminalId: terminal.terminalId,
+            target,
+            status: terminal.status,
+            exitCode: terminal.exitCode,
+            exitSignal: terminal.exitSignal,
+            updatedAt: terminal.updatedAt,
+            alreadySatisfied: true,
+          },
+        };
+      }
+      return null;
+    }
+    if (target === "closed" || target === "ended") {
+      return {
+        kind: "result",
+        value: {
+          threadId,
+          terminalId,
+          target,
+          status: "closed",
+          alreadySatisfied: true,
+          missingTreatedAsClosed: true,
+        },
+      };
+    }
+    return {
+      kind: "fail",
+      error: terminalClosedBeforeExitError(threadId, terminalId),
+    };
+  }
+
+  if (event.type === "upsert") {
+    if (event.terminal.threadId !== threadId || event.terminal.terminalId !== terminalId) {
+      return null;
+    }
+    if ((target === "exited" || target === "ended") && event.terminal.status === "exited") {
+      return {
+        kind: "result",
+        value: {
+          threadId,
+          terminalId,
+          target,
+          status: "exited",
+          exitCode: event.terminal.exitCode,
+          exitSignal: event.terminal.exitSignal,
+          alreadySatisfied: false,
+        },
+      };
+    }
+    return null;
+  }
+
+  if (event.threadId !== threadId || event.terminalId !== terminalId) {
+    return null;
+  }
+
+  if (target === "exited") {
+    return {
+      kind: "fail",
+      error: terminalClosedBeforeExitError(threadId, terminalId),
+    };
+  }
+
+  if (target === "closed" || target === "ended") {
+    return {
+      kind: "result",
+      value: {
+        threadId,
+        terminalId,
+        target,
+        status: "closed",
+        alreadySatisfied: false,
+      },
+    };
+  }
+
+  return null;
+}
+
+function targetSatisfiedBySummary(target: TerminalWaitTarget, terminal: TerminalSummary) {
+  if (target === "exited") {
+    return terminal.status === "exited";
+  }
+  if (target === "closed") {
+    return false;
+  }
+  return terminal.status === "exited";
+}
+
+function formatWaitHuman(input: {
+  readonly threadId: string;
+  readonly terminalId: string;
+  readonly status: string;
+  readonly alreadySatisfied: boolean;
+  readonly exitCode?: number | null;
+  readonly exitSignal?: number | null;
+}) {
+  const details = [
+    typeof input.exitCode === "number" ? `code ${input.exitCode}` : null,
+    typeof input.exitSignal === "number" ? `signal ${input.exitSignal}` : null,
+  ]
+    .filter((value): value is string => value !== null)
+    .join(", ");
+  return details.length > 0
+    ? `terminal ${input.status}: ${input.terminalId} (${input.threadId}) ${details}`
+    : `terminal ${input.status}: ${input.terminalId} (${input.threadId})`;
+}

package/src/cli/terminal/write.test.ts

@@ -0,0 +1,34 @@
+import "vite-plus/test/config";
+
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Option from "effect/Option";
+import { assert, describe, it } from "@effect/vitest";
+import { Command } from "effect/unstable/cli";
+
+import { InvalidFlagCombinationError } from "../error.ts";
+import { terminalCommandTestLayer } from "./read.test-utils.ts";
+import { writeTerminalCommand } from "./write.ts";
+
+describe("writeTerminalCommand", () => {
+  it.layer(terminalCommandTestLayer)("writeTerminalCommand", (t) => {
+    t.effect("rejects multiple payload sources", () =>
+      Effect.gen(function* () {
+        const run = Command.runWith(writeTerminalCommand, { version: "0.0.0-test" });
+        const exit = yield* run(["--thread", "thread-1", "term-1", "hello", "--stdin"]).pipe(
+          Effect.exit,
+        );
+        assert.isTrue(Exit.isFailure(exit));
+        if (!Exit.isFailure(exit)) {
+          return;
+        }
+        const error = Cause.findErrorOption(exit.cause);
+        assert.isTrue(Option.isSome(error));
+        if (Option.isSome(error)) {
+          assert.instanceOf(error.value, InvalidFlagCombinationError);
+        }
+      }),
+    );
+  });
+});

package/src/cli/terminal/write.ts

@@ -0,0 +1,133 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Argument, Command, Flag } from "effect/unstable/cli";
+
+import { extraArgsConfig } from "../extra-args.ts";
+import { formatTerminalWrittenHuman } from "../format/terminal.ts";
+import { T3Application } from "../../application/service.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import { InvalidFlagCombinationError } from "../error.ts";
+import { T3Input } from "../input/service.ts";
+import { formatFlag, threadFlag } from "../flags.ts";
+import { resolveOutputFormat } from "../format/output.ts";
+import { T3Output } from "../output/service.ts";
+import { decodeBase64Payload, decodeHexPayload } from "./encoding.ts";
+import { TerminalCliError } from "./error.ts";
+import { requireCommandThreadId } from "./scope.ts";
+
+export const writeTerminalCommand = Command.make(
+  "write",
+  {
+    thread: threadFlag,
+    terminalId: Argument.string("terminal-id"),
+    data: Argument.string("data").pipe(Argument.optional),
+    stdin: Flag.boolean("stdin"),
+    hex: Flag.string("hex").pipe(Flag.optional),
+    base64: Flag.string("base64").pipe(Flag.optional),
+    quiet: Flag.boolean("quiet"),
+    format: formatFlag,
+    ...extraArgsConfig,
+  },
+  ({ thread, terminalId, data, stdin, hex, base64, quiet, format }) =>
+    Effect.gen(function* () {
+      const output = yield* T3Output;
+      const inputService = yield* T3Input;
+      const application = yield* T3Application;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
+      const threadId = yield* requireCommandThreadId({ thread });
+      const argumentData = Option.getOrUndefined(data);
+      const hexData = Option.getOrUndefined(hex);
+      const base64Data = Option.getOrUndefined(base64);
+      const inputCount = [
+        stdin,
+        argumentData !== undefined,
+        hexData !== undefined,
+        base64Data !== undefined,
+      ].filter(Boolean).length;
+
+      if (inputCount !== 1) {
+        yield* Effect.fail(
+          new InvalidFlagCombinationError({
+            message: "provide exactly one of <data>, --stdin, --hex <data>, or --base64 <data>",
+          }),
+        );
+      }
+
+      const payload =
+        hexData !== undefined
+          ? yield* decodeHexPayloadOrFail(hexData, threadId, terminalId)
+          : base64Data !== undefined
+            ? yield* decodeBase64PayloadOrFail(base64Data, threadId, terminalId)
+            : stdin
+              ? yield* inputService.readStdinBinary()
+              : argumentData!;
+      if (payload.length === 0) {
+        yield* Effect.fail(
+          new TerminalCliError({
+            message: "terminal write payload is empty",
+            threadId,
+            terminalId,
+          }),
+        );
+      }
+
+      yield* application.writeTerminal({
+        terminal: {
+          threadId,
+          terminalId,
+        },
+        data: payload,
+      });
+      if (quiet) {
+        return;
+      }
+      const bytes = Buffer.byteLength(payload, "latin1");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
+      if (resolvedFormat === "json") {
+        yield* output.printJson({
+          threadId,
+          terminalId,
+          bytes,
+          encoding: hexData !== undefined ? "hex" : base64Data !== undefined ? "base64" : "latin1",
+        });
+        return;
+      }
+      yield* output.printInfo(
+        formatTerminalWrittenHuman({
+          terminalId,
+          threadId,
+          bytes,
+        }),
+      );
+    }),
+).pipe(Command.withDescription("write raw data to a terminal"));
+
+function decodeHexPayloadOrFail(value: string, threadId: string, terminalId: string) {
+  const decoded = decodeHexPayload(value);
+  if (decoded === undefined) {
+    return Effect.fail(
+      new TerminalCliError({
+        message: "invalid hex payload",
+        threadId,
+        terminalId,
+      }),
+    );
+  }
+  return Effect.succeed(decoded);
+}
+
+function decodeBase64PayloadOrFail(value: string, threadId: string, terminalId: string) {
+  const decoded = decodeBase64Payload(value);
+  if (decoded === undefined) {
+    return Effect.fail(
+      new TerminalCliError({
+        message: "invalid base64 payload",
+        threadId,
+        terminalId,
+      }),
+    );
+  }
+  return Effect.succeed(decoded);
+}

package/src/cli/terminal.ts

@@ -0,0 +1,26 @@
+import { Command } from "effect/unstable/cli";
+
+import { attachTerminalCommand } from "./terminal/attach.ts";
+import { createTerminalCommand } from "./terminal/create.ts";
+import { destroyTerminalCommand } from "./terminal/destroy.ts";
+import { listTerminalCommand } from "./terminal/list.ts";
+import { readTerminalCommand } from "./terminal/read.ts";
+import { streamTerminalCommand } from "./terminal/stream.ts";
+import { waitTerminalCommand } from "./terminal/wait.ts";
+import { writeTerminalCommand } from "./terminal/write.ts";
+
+export function createTerminalCommandGroup() {
+  return Command.make("terminal").pipe(
+    Command.withDescription("terminal commands"),
+    Command.withSubcommands([
+      listTerminalCommand,
+      createTerminalCommand,
+      attachTerminalCommand,
+      readTerminalCommand,
+      streamTerminalCommand,
+      waitTerminalCommand,
+      writeTerminalCommand,
+      destroyTerminalCommand,
+    ]),
+  );
+}

package/src/cli/thread.ts

@@ -3,7 +3,11 @@ import { Command } from "effect/unstable/cli";
 import { approveThreadCommand } from "./threads/approve.ts";
 import { archiveThreadCommand } from "./threads/archive.ts";
 import { callbackThreadCommand } from "./threads/callback.ts";
+import { deleteThreadCommand } from "./threads/delete.ts";
+import { interruptThreadCommand } from "./threads/interrupt.ts";
 import { respondThreadCommand } from "./threads/respond.ts";
+import { unarchiveThreadCommand } from "./threads/unarchive.ts";
+import { updateThreadCommand } from "./threads/update.ts";
 
 export function createThreadCommand() {
   return Command.make("thread").pipe(
@@ -12,6 +16,10 @@ export function createThreadCommand() {
       approveThreadCommand,
       respondThreadCommand,
       archiveThreadCommand,
+      interruptThreadCommand,
+      unarchiveThreadCommand,
+      updateThreadCommand,
+      deleteThreadCommand,
       callbackThreadCommand,
     ]),
   );

package/src/cli/threads/approve.ts

@@ -2,12 +2,14 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Command, Flag } from "effect/unstable/cli";
 
+import { extraArgsConfig } from "../extra-args.ts";
 import { formatFlag, threadFlag } from "../flags.ts";
 import { MissingRequestError, MissingThreadError } from "../error.ts";
-import { resolveThreadId } from "../../scope/index.ts";
+import { resolveThreadId } from "../scope/index.ts";
 import { T3Application } from "../../application/service.ts";
-import { Environment } from "../../environment/service.ts";
-import { resolveOutputFormat } from "../output-format.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import { resolveOutputFormat } from "../format/output.ts";
 import { T3Output } from "../output/service.ts";
 
 const approvalDecisionFlag = Flag.choice("decision", ["accept", "decline", "cancel"] as const).pipe(
@@ -26,15 +28,17 @@ export const approveThreadCommand = Command.make(
     request: requestFlag,
     decision: approvalDecisionFlag,
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ thread, request, decision, format }) =>
     Effect.gen(function* () {
       const application = yield* T3Application;
-      const environment = yield* Environment;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
       const threadId = resolveThreadId({
         value: Option.getOrUndefined(thread),
-        env: environment.env,
+        scope: t3CliEnv.scope,
       });
       if (threadId === undefined) {
         return yield* Effect.fail(
@@ -49,13 +53,13 @@ export const approveThreadCommand = Command.make(
           new MissingRequestError({ message: "request id is required: pass --request" }),
         );
       }
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const result = yield* application.approveThread({ threadId, requestId, decision });
       if (resolvedFormat === "json") {
         return yield* output.printJson(result);
       }
       return yield* output.printInfo(
-        `approval submitted: ${result.requestId}\nsequence: ${result.dispatch.sequence}`,
+        `approval submitted: ${result.requestId} (sequence ${result.dispatch.sequence})`,
       );
     }),
 ).pipe(Command.withDescription("respond to a pending approval request"));