t3code-cli 0.11.0 → 0.12.0

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

package/src/cli/terminal/write.ts

@@ -2,13 +2,15 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Argument, Command, Flag } from "effect/unstable/cli";
 
-import { formatTerminalWrittenHuman } from "../terminal-format.ts";
+import { extraArgsConfig } from "../extra-args.ts";
+import { formatTerminalWrittenHuman } 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 { InvalidFlagCombinationError } from "../error.ts";
 import { T3Input } from "../input/service.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 { decodeBase64Payload, decodeHexPayload } from "./encoding.ts";
 import { TerminalCliError } from "./error.ts";
@@ -25,17 +27,16 @@ export const writeTerminalCommand = Command.make(
     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 environment = yield* Environment;
-      const threadId = yield* requireCommandThreadId({
-        thread,
-        env: environment.env,
-      });
+      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);
@@ -83,7 +84,7 @@ export const writeTerminalCommand = Command.make(
         return;
       }
       const bytes = Buffer.byteLength(payload, "latin1");
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       if (resolvedFormat === "json") {
         yield* output.printJson({
           threadId,

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"));

package/src/cli/threads/archive.ts

@@ -2,13 +2,15 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Command } from "effect/unstable/cli";
 
+import { extraArgsConfig } from "../extra-args.ts";
 import { formatFlag, selfActionForceFlag, threadFlag } from "../flags.ts";
 import { MissingThreadError } from "../error.ts";
-import { requireSelfActionConfirmation } from "../self-action.ts";
-import { resolveThreadId } from "../../scope/index.ts";
+import { requireSelfActionConfirmation } from "../interaction/self-action.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";
 
 export const archiveThreadCommand = Command.make(
@@ -17,15 +19,17 @@ export const archiveThreadCommand = Command.make(
     thread: threadFlag,
     force: selfActionForceFlag,
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ thread, force, 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(
@@ -37,16 +41,17 @@ export const archiveThreadCommand = Command.make(
       yield* requireSelfActionConfirmation({
         threadId,
         force,
-        environment,
+        cliRuntime,
+        t3CliEnv,
         action: "archive",
       });
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const dispatch = yield* application.archiveThread(threadId);
       if (resolvedFormat === "json") {
         return yield* output.printJson(dispatch);
       }
       return yield* output.printInfo(
-        `thread archived: ${threadId}\nsequence: ${dispatch.sequence}`,
+        `thread archived: ${threadId} (sequence ${dispatch.sequence})`,
       );
     }),
 ).pipe(Command.withDescription("archive thread"));

package/src/cli/threads/callback.ts

@@ -4,10 +4,11 @@ import * as ChildProcess from "effect/unstable/process/ChildProcess";
 import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
 import { Command, Flag } from "effect/unstable/cli";
 
+import { extraArgsConfig } from "../extra-args.ts";
 import { threadFlag } from "../flags.ts";
 import { MissingThreadError } from "../error.ts";
-import { resolveThreadId } from "../../scope/index.ts";
-import { Environment } from "../../environment/service.ts";
+import { resolveThreadId } from "../scope/index.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
 import { T3Application } from "../../application/service.ts";
 import { T3Output } from "../output/service.ts";
 import { CliPath } from "../../cli-path/service.ts";
@@ -22,11 +23,12 @@ export const callbackThreadCommand = Command.make(
       Flag.withDescription("Fork and detach as background process"),
       Flag.optional,
     ),
+    ...extraArgsConfig,
   },
   ({ from, thread, prompt, background }) =>
     Effect.gen(function* () {
       const application = yield* T3Application;
-      const environment = yield* Environment;
+      const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
       const cliPath = yield* CliPath;
       const spawner = yield* ChildProcessSpawner;
@@ -35,7 +37,7 @@ export const callbackThreadCommand = Command.make(
 
       const targetThreadId = resolveThreadId({
         value: Option.getOrUndefined(thread),
-        env: environment.env,
+        scope: t3CliEnv.scope,
       });
       if (targetThreadId === undefined) {
         return yield* Effect.fail(

package/src/cli/threads/delete.ts

@@ -2,15 +2,17 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Command } from "effect/unstable/cli";
 
-import { requireDestructiveConfirmation } from "../confirm.ts";
+import { extraArgsConfig } from "../extra-args.ts";
+import { requireDestructiveConfirmation } from "../interaction/confirm.ts";
 import { formatFlag, selfActionForceFlag, threadFlag, yesFlag } from "../flags.ts";
-import { formatThreadDeletedHuman } from "../thread-format.ts";
+import { formatThreadDeletedHuman } from "../format/thread.ts";
 import { MissingThreadError } from "../error.ts";
-import { requireSelfActionConfirmation } from "../self-action.ts";
-import { resolveThreadId } from "../../scope/index.ts";
+import { requireSelfActionConfirmation } from "../interaction/self-action.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";
 
 export const deleteThreadCommand = Command.make(
@@ -20,15 +22,17 @@ export const deleteThreadCommand = Command.make(
     force: selfActionForceFlag,
     yes: yesFlag,
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ thread, 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 threadId = resolveThreadId({
         value: Option.getOrUndefined(thread),
-        env: environment.env,
+        scope: t3CliEnv.scope,
       });
       if (threadId === undefined) {
         return yield* Effect.fail(
@@ -40,15 +44,17 @@ export const deleteThreadCommand = Command.make(
       yield* requireSelfActionConfirmation({
         threadId,
         force,
-        environment,
+        cliRuntime,
+        t3CliEnv,
         action: "delete",
       });
       yield* requireDestructiveConfirmation({
         message: `Delete thread ${threadId}?`,
         yes,
-        environment,
+        cliRuntime,
+        t3CliEnv,
       });
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const result = yield* application.deleteThread(threadId);
       if (resolvedFormat === "json") {
         return yield* output.printJson({