t3code-cli 0.11.0 → 0.13.0

package/src/cli/projects/delete.ts

@@ -1,13 +1,15 @@
 import * as Effect from "effect/Effect";
 import { Command } from "effect/unstable/cli";
 
-import { requireDestructiveConfirmation } from "../confirm.ts";
+import { extraArgsConfig } from "../extra-args.ts";
+import { requireDestructiveConfirmation } from "../interaction/confirm.ts";
 import { forceFlag, formatFlag, projectFlag, yesFlag } from "../flags.ts";
-import { formatProjectDeletedHuman } from "../project-format.ts";
+import { formatProjectDeletedHuman } from "../format/project.ts";
 import { requireCommandProjectRef } from "../require.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";
 
 export const deleteProjectCommand = Command.make(
@@ -17,24 +19,23 @@ export const deleteProjectCommand = Command.make(
     force: forceFlag,
     yes: yesFlag,
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ project, force, yes, 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 projectRef = yield* requireCommandProjectRef({
-        project,
-        env: environment.env,
-        cwd: environment.cwd,
-      });
+      const projectRef = yield* requireCommandProjectRef({ project });
       const resolvedProject = yield* application.resolveProject(projectRef);
       yield* requireDestructiveConfirmation({
         message: `Delete project ${resolvedProject.title} (${resolvedProject.id})?`,
         yes,
-        environment,
+        cliRuntime,
+        t3CliEnv,
       });
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const result = yield* application.deleteProject({
         projectId: resolvedProject.id,
         ...(force ? { force: true } : {}),

package/src/cli/require.ts

@@ -1,21 +1,23 @@
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 
-import { T3Config } from "../config/service.ts";
+import { T3Config } from "../config/config.ts";
+import { loadT3CliEnv } from "../config/env/env.ts";
+import { CliRuntime } from "../cli/runtime/service.ts";
 import { ProjectLookupError } from "../domain/error.ts";
-import { resolveCommandProjectRef } from "../scope/index.ts";
+import { resolveCommandProjectRef } from "./scope/index.ts";
 
 export const requireCommandProjectRef = Effect.fn("requireCommandProjectRef")(function* (input: {
   readonly project: Option.Option<string>;
-  readonly env: Readonly<Record<string, string | undefined>>;
-  readonly cwd: string;
 }) {
+  const cliRuntime = yield* CliRuntime;
+  const t3CliEnv = yield* loadT3CliEnv;
   const config = yield* T3Config;
   const resolved = yield* config.resolve();
   const ref = resolveCommandProjectRef({
     value: Option.getOrUndefined(input.project),
-    env: input.env,
-    cwd: input.cwd,
+    scope: t3CliEnv.scope,
+    cwd: cliRuntime.cwd,
     isLocal: resolved.local,
   });
   if (ref === undefined) {
@@ -23,7 +25,7 @@ export const requireCommandProjectRef = Effect.fn("requireCommandProjectRef")(fu
       new ProjectLookupError({
         message:
           "project is required: pass --project, set T3CODE_PROJECT_ROOT / T3CODE_PROJECT_ID, or use local auth",
-        ref: input.cwd,
+        ref: cliRuntime.cwd,
       }),
     );
   }

package/src/cli/runtime/index.ts

@@ -0,0 +1 @@
+export { CliRuntime, layer } from "./service.ts";

package/src/cli/runtime/service.ts

@@ -0,0 +1,28 @@
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+
+export class CliRuntime extends Context.Service<
+  CliRuntime,
+  {
+    readonly cwd: string;
+    readonly stdoutIsTTY: boolean;
+    readonly stderrIsTTY: boolean;
+  }
+>()("t3cli/CliRuntime") {
+  static layerTest = (input?: {
+    readonly cwd?: string;
+    readonly stdoutIsTTY?: boolean;
+    readonly stderrIsTTY?: boolean;
+  }) =>
+    Layer.succeed(CliRuntime, {
+      cwd: input?.cwd ?? process.cwd(),
+      stdoutIsTTY: input?.stdoutIsTTY ?? false,
+      stderrIsTTY: input?.stderrIsTTY ?? false,
+    });
+}
+
+export const layer = Layer.succeed(CliRuntime, {
+  cwd: process.cwd(),
+  stdoutIsTTY: process.stdout.isTTY ?? false,
+  stderrIsTTY: process.stderr.isTTY ?? false,
+});

package/src/{scope → cli/scope}/resolve.ts

@@ -1,15 +1,17 @@
+import type { T3CliEnvScope } from "../../config/env/env.ts";
+
 export function resolveProjectRef(input: {
   readonly value: string | undefined;
-  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly scope: T3CliEnvScope;
 }): string | undefined {
   if (input.value !== undefined && input.value.length > 0) {
     return input.value;
   }
-  const fromRoot = input.env.T3CODE_PROJECT_ROOT;
+  const fromRoot = input.scope.t3codeProjectRoot;
   if (fromRoot !== undefined && fromRoot.length > 0) {
     return fromRoot;
   }
-  const fromId = input.env.T3CODE_PROJECT_ID;
+  const fromId = input.scope.t3codeProjectId;
   if (fromId !== undefined && fromId.length > 0) {
     return fromId;
   }
@@ -18,11 +20,11 @@ export function resolveProjectRef(input: {
 
 export function resolveCommandProjectRef(input: {
   readonly value: string | undefined;
-  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly scope: T3CliEnvScope;
   readonly cwd: string;
   readonly isLocal?: boolean;
 }): string | undefined {
-  const explicit = resolveProjectRef({ value: input.value, env: input.env });
+  const explicit = resolveProjectRef({ value: input.value, scope: input.scope });
   if (explicit !== undefined) {
     return explicit;
   }
@@ -34,13 +36,13 @@ export function resolveCommandProjectRef(input: {
 
 export function resolveWorktreePath(input: {
   readonly value: string | undefined;
-  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly scope: T3CliEnvScope;
   readonly inferred?: string;
 }): string | undefined {
   if (input.value !== undefined && input.value.length > 0) {
     return input.value;
   }
-  const fromEnv = input.env.T3CODE_WORKTREE_PATH;
+  const fromEnv = input.scope.t3codeWorktreePath;
   if (fromEnv !== undefined && fromEnv.length > 0) {
     return fromEnv;
   }
@@ -49,12 +51,12 @@ export function resolveWorktreePath(input: {
 
 export function resolveThreadId(input: {
   readonly value: string | undefined;
-  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly scope: T3CliEnvScope;
 }): string | undefined {
   if (input.value !== undefined && input.value.length > 0) {
     return input.value;
   }
-  const fromEnv = input.env.T3CODE_THREAD_ID;
+  const fromEnv = input.scope.t3codeThreadId;
   if (fromEnv !== undefined && fromEnv.length > 0) {
     return fromEnv;
   }

package/src/cli/terminal/attach.ts

@@ -2,7 +2,7 @@ import * as Effect from "effect/Effect";
 import { Argument, Command } from "effect/unstable/cli";
 
 import { T3Application } from "../../application/service.ts";
-import { Environment } from "../../environment/service.ts";
+import { extraArgsConfig } from "../extra-args.ts";
 import { threadFlag } from "../flags.ts";
 import { requireCommandThreadId } from "./scope.ts";
 import { runAttachedTerminalSession, toTerminalAttachTarget } from "./shared.ts";
@@ -12,15 +12,12 @@ export const attachTerminalCommand = Command.make(
   {
     thread: threadFlag,
     terminalId: Argument.string("terminal-id"),
+    ...extraArgsConfig,
   },
   ({ thread, terminalId }) =>
     Effect.gen(function* () {
       const application = yield* T3Application;
-      const environment = yield* Environment;
-      const threadId = yield* requireCommandThreadId({
-        thread,
-        env: environment.env,
-      });
+      const threadId = yield* requireCommandThreadId({ thread });
       const terminal = yield* application.getTerminal({
         threadId,
         terminalId,

package/src/cli/terminal/create.ts

@@ -2,11 +2,13 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Argument, Command, Flag } from "effect/unstable/cli";
 
-import { formatTerminalCreatedHuman } from "../terminal-format.ts";
+import { extraArgsConfig } from "../extra-args.ts";
+import { formatTerminalCreatedHuman } from "../format/terminal.ts";
 import { T3Application } from "../../application/service.ts";
-import { Environment } from "../../environment/service.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
 import { formatFlag, threadFlag } from "../flags.ts";
-import { resolveOutputFormat } from "../output-format.ts";
+import { resolveOutputFormat } from "../format/output.ts";
 import { T3Output } from "../output/service.ts";
 import { requireCommandThreadId } from "./scope.ts";
 import { runAttachedTerminalSession, snapshotToTerminalAttachTarget } from "./shared.ts";
@@ -19,16 +21,15 @@ export const createTerminalCommand = Command.make(
     id: Flag.string("id").pipe(Flag.optional),
     attach: Flag.boolean("attach"),
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ thread, command, id, attach, 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 = yield* requireCommandThreadId({
-        thread,
-        env: environment.env,
-      });
+      const threadId = yield* requireCommandThreadId({ thread });
       const terminalId = Option.getOrUndefined(id);
       const commandValue = Option.getOrUndefined(command);
       const snapshot = yield* application.createTerminal({
@@ -44,7 +45,7 @@ export const createTerminalCommand = Command.make(
         return;
       }
 
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       if (resolvedFormat === "json") {
         yield* output.printJson(snapshot);
       } else {

package/src/cli/terminal/destroy.ts

@@ -1,12 +1,14 @@
 import * as Effect from "effect/Effect";
 import { Argument, Command, Flag } from "effect/unstable/cli";
 
-import { requireDestructiveConfirmation } from "../confirm.ts";
-import { formatTerminalDestroyedHuman } from "../terminal-format.ts";
+import { extraArgsConfig } from "../extra-args.ts";
+import { requireDestructiveConfirmation } from "../interaction/confirm.ts";
+import { formatTerminalDestroyedHuman } from "../format/terminal.ts";
 import { T3Application } from "../../application/service.ts";
-import { Environment } from "../../environment/service.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
 import { formatFlag, threadFlag, yesFlag } from "../flags.ts";
-import { resolveOutputFormat } from "../output-format.ts";
+import { resolveOutputFormat } from "../format/output.ts";
 import { T3Output } from "../output/service.ts";
 import { requireCommandThreadId } from "./scope.ts";
 
@@ -18,20 +20,20 @@ export const destroyTerminalCommand = Command.make(
     quiet: Flag.boolean("quiet"),
     yes: yesFlag,
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ thread, terminalId, quiet, yes, 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 = yield* requireCommandThreadId({
-        thread,
-        env: environment.env,
-      });
+      const threadId = yield* requireCommandThreadId({ thread });
       yield* requireDestructiveConfirmation({
         message: `Destroy terminal ${terminalId} in thread ${threadId} and delete its history?`,
         yes,
-        environment,
+        cliRuntime,
+        t3CliEnv,
       });
       const terminal = {
         threadId,
@@ -41,7 +43,7 @@ export const destroyTerminalCommand = Command.make(
       if (quiet) {
         return;
       }
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       if (resolvedFormat === "json") {
         yield* output.printJson({
           threadId: terminal.threadId,

package/src/cli/terminal/list.ts

@@ -1,11 +1,13 @@
 import * as Effect from "effect/Effect";
 import { Command } from "effect/unstable/cli";
 
-import { formatTerminalListHuman } from "../terminal-format.ts";
+import { extraArgsConfig } from "../extra-args.ts";
+import { formatTerminalListHuman } from "../format/terminal.ts";
 import { T3Application } from "../../application/service.ts";
-import { Environment } from "../../environment/service.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
 import { formatFlag, threadFlag } from "../flags.ts";
-import { resolveOutputFormat } from "../output-format.ts";
+import { resolveOutputFormat } from "../format/output.ts";
 import { T3Output } from "../output/service.ts";
 import { requireCommandThreadId } from "./scope.ts";
 
@@ -14,17 +16,16 @@ export const listTerminalCommand = Command.make(
   {
     thread: threadFlag,
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ thread, 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 = yield* requireCommandThreadId({
-        thread,
-        env: environment.env,
-      });
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const threadId = yield* requireCommandThreadId({ thread });
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const terminals = yield* application.listTerminals(threadId);
       if (resolvedFormat === "json") {
         yield* output.printJson(terminals);

package/src/cli/terminal/read.test-utils.ts

@@ -0,0 +1,48 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+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 { T3Input } from "../input/service.ts";
+import { T3Output } from "../output/service.ts";
+
+export const terminalCommandTestLayer = Layer.mergeAll(
+  Layer.succeed(
+    T3Application,
+    fromPartial({
+      getTerminal: () => Effect.die("getTerminal should not be called"),
+      attachTerminal: () => Effect.die("attachTerminal should not be called"),
+      writeTerminal: () => Effect.die("writeTerminal should not be called"),
+    }),
+  ),
+  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,
+  }),
+  Layer.succeed(T3Input, {
+    readStdin: () => Effect.die("readStdin should not be called"),
+    readStdinBinary: () => Effect.die("readStdinBinary should not be called"),
+  }),
+  NodeServices.layer,
+  CliRuntime.layer,
+  t3CliEnvConfigLayer("/tmp/t3cli-test"),
+);

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

@@ -0,0 +1,35 @@
+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 { readTerminalCommand } from "./read.ts";
+import { terminalCommandTestLayer } from "./read.test-utils.ts";
+
+describe("readTerminalCommand", () => {
+  it.layer(terminalCommandTestLayer)("readTerminalCommand", (t) => {
+    t.effect("rejects --from-sequence without --follow", () =>
+      Effect.gen(function* () {
+        const run = Command.runWith(readTerminalCommand, { version: "0.0.0-test" });
+        const exit = yield* run(["--thread", "thread-1", "term-1", "--from-sequence", "1"]).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);
+          assert.equal(error.value.message, "--from-sequence requires --follow");
+        }
+      }),
+    );
+  });
+});

package/src/cli/terminal/read.ts

@@ -4,7 +4,7 @@ import * as Stream from "effect/Stream";
 import { Argument, Command, Flag } from "effect/unstable/cli";
 
 import { T3Application } from "../../application/service.ts";
-import { Environment } from "../../environment/service.ts";
+import { extraArgsConfig } from "../extra-args.ts";
 import { InvalidFlagCombinationError, InvalidLimitError } from "../error.ts";
 import { threadFlag } from "../flags.ts";
 import { T3Output } from "../output/service.ts";
@@ -23,16 +23,13 @@ export const readTerminalCommand = Command.make(
     follow: Flag.boolean("follow"),
     fromSequence: Flag.integer("from-sequence").pipe(Flag.optional),
     format: Flag.choice("format", jsonNdjsonFormatChoices).pipe(Flag.withDefault("json")),
+    ...extraArgsConfig,
   },
   ({ thread, terminalId, history, follow, fromSequence, format }) =>
     Effect.gen(function* () {
       const output = yield* T3Output;
       const application = yield* T3Application;
-      const environment = yield* Environment;
-      const threadId = yield* requireCommandThreadId({
-        thread,
-        env: environment.env,
-      });
+      const threadId = yield* requireCommandThreadId({ thread });
       const fromSequenceValue = Option.getOrUndefined(fromSequence);
 
       if (fromSequenceValue !== undefined && fromSequenceValue < 0) {

package/src/cli/terminal/scope.ts

@@ -1,24 +1,29 @@
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 
-import { resolveThreadId } from "../../scope/index.ts";
+import type { T3CliEnvScope } from "../../config/env/env.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import { resolveThreadId } from "../scope/index.ts";
 import { MissingThreadError } from "../error.ts";
 
 export function resolveCommandThreadId(input: {
   readonly thread: Option.Option<string>;
-  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly scope: T3CliEnvScope;
 }): string | undefined {
   return resolveThreadId({
     value: Option.getOrUndefined(input.thread),
-    env: input.env,
+    scope: input.scope,
   });
 }
 
 export const requireCommandThreadId = Effect.fn("requireCommandThreadId")(function* (input: {
   readonly thread: Option.Option<string>;
-  readonly env: Readonly<Record<string, string | undefined>>;
 }) {
-  const threadId = resolveCommandThreadId(input);
+  const t3CliEnv = yield* loadT3CliEnv;
+  const threadId = resolveCommandThreadId({
+    thread: input.thread,
+    scope: t3CliEnv.scope,
+  });
   if (threadId === undefined) {
     return yield* Effect.fail(
       new MissingThreadError({

package/src/cli/terminal/shared.ts

@@ -6,7 +6,7 @@ import type {
   TerminalAttachStreamEvent,
   TerminalSessionSnapshot,
   TerminalSummary,
-} from "#t3tools/contracts";
+} from "@t3tools/contracts";
 
 import type { TerminalAttachTarget, TerminalRef } from "../../application/service.ts";
 import { T3Application } from "../../application/service.ts";

package/src/cli/terminal/stream.ts

@@ -4,7 +4,7 @@ import * as Stream from "effect/Stream";
 import { Argument, Command, Flag } from "effect/unstable/cli";
 
 import { T3Application } from "../../application/service.ts";
-import { Environment } from "../../environment/service.ts";
+import { extraArgsConfig } from "../extra-args.ts";
 import { InvalidLimitError } from "../error.ts";
 import { threadFlag } from "../flags.ts";
 import { T3Output } from "../output/service.ts";
@@ -20,16 +20,13 @@ export const streamTerminalCommand = Command.make(
     terminalId: Argument.string("terminal-id"),
     fromSequence: Flag.integer("from-sequence").pipe(Flag.optional),
     format: Flag.choice("format", ndjsonOnlyFormatChoices).pipe(Flag.withDefault("ndjson")),
+    ...extraArgsConfig,
   },
   ({ thread, terminalId, fromSequence }) =>
     Effect.gen(function* () {
       const output = yield* T3Output;
       const application = yield* T3Application;
-      const environment = yield* Environment;
-      const threadId = yield* requireCommandThreadId({
-        thread,
-        env: environment.env,
-      });
+      const threadId = yield* requireCommandThreadId({ thread });
       const fromSequenceValue = Option.getOrUndefined(fromSequence);
 
       if (fromSequenceValue !== undefined && fromSequenceValue < 0) {

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

@@ -12,8 +12,9 @@ import { Command } from "effect/unstable/cli";
 import { fromPartial } from "@total-typescript/shoehorn";
 
 import { T3Application } from "../../application/service.ts";
-import { T3Config } from "../../config/service.ts";
-import { NodeEnvironmentLive } from "../../environment/layer.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";
@@ -95,7 +96,8 @@ describe("waitTerminalCommand", () => {
       printInfo: () => Effect.void,
     }),
     NodeServices.layer,
-    NodeEnvironmentLive,
+    CliRuntime.layer,
+    t3CliEnvConfigLayer("/tmp/t3cli-test"),
   );
 
   it.layer(testLayer)("waitTerminalCommand", (t) => {

package/src/cli/terminal/wait.ts

@@ -1,13 +1,15 @@
 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 type { TerminalMetadataStreamEvent, TerminalSummary } from "@t3tools/contracts";
 import { Argument, Command, Flag } from "effect/unstable/cli";
 
 import { T3Application } from "../../application/service.ts";
-import { Environment } from "../../environment/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 "../output-format.ts";
+import { resolveOutputFormat } from "../format/output.ts";
 import { T3Output } from "../output/service.ts";
 import { TerminalCliError } from "./error.ts";
 import { requireCommandThreadId } from "./scope.ts";
@@ -50,17 +52,16 @@ export const waitTerminalCommand = Command.make(
     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 environment = yield* Environment;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
-      const threadId = yield* requireCommandThreadId({
-        thread,
-        env: environment.env,
-      });
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      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)),

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);
+        }
+      }),
+    );
+  });
+});