t3code-cli 0.11.0 → 0.12.0

package/src/cli/format/thread.ts

@@ -0,0 +1,185 @@
+import type { ThreadShow } from "../../application/threads.ts";
+import type { WaitEvent } from "../../application/service.ts";
+import type { OrchestrationThread, OrchestrationThreadShell } from "@t3tools/contracts";
+import { latestAssistantMessage, threadStatus } from "../../domain/thread-lifecycle.ts";
+import { formatChatTranscript, formatRecord, formatTable } from "./human.ts";
+
+export function formatThreadShowJson(thread: ThreadShow) {
+  return {
+    id: thread.id,
+    projectId: thread.projectId,
+    title: thread.title,
+    status: thread.status,
+    session: thread.session,
+    latestTurn: thread.latestTurn,
+    modelSelection: thread.modelSelection,
+    runtimeMode: thread.runtimeMode,
+    interactionMode: thread.interactionMode,
+    branch: thread.branch,
+    worktreePath: thread.worktreePath,
+    archivedAt: thread.archivedAt,
+    createdAt: thread.createdAt,
+    updatedAt: thread.updatedAt,
+    messageCount: thread.messageCount,
+    hasPendingApprovals: thread.hasPendingApprovals,
+    hasPendingUserInput: thread.hasPendingUserInput,
+    hasActionableProposedPlan: thread.hasActionableProposedPlan,
+    pendingApprovals: thread.pendingApprovals,
+    pendingUserInputs: thread.pendingUserInputs,
+  };
+}
+
+export function formatThreadShowHuman(thread: ThreadShow) {
+  const sections = [
+    formatRecord([
+      { field: "title", value: thread.title },
+      { field: "id", value: thread.id },
+      { field: "project", value: thread.projectId },
+      { field: "status", value: thread.status },
+      {
+        field: "model",
+        value: `${thread.modelSelection.instanceId}/${thread.modelSelection.model}`,
+      },
+      { field: "runtime", value: thread.runtimeMode },
+      { field: "interaction", value: thread.interactionMode },
+      ...(thread.branch !== null ? [{ field: "branch", value: thread.branch }] : []),
+      ...(thread.worktreePath !== null ? [{ field: "worktree", value: thread.worktreePath }] : []),
+      ...(thread.archivedAt !== null ? [{ field: "archived", value: thread.archivedAt }] : []),
+      { field: "messages", value: String(thread.messageCount) },
+      { field: "updated", value: thread.updatedAt },
+    ]),
+  ];
+  if (thread.pendingApprovals.length > 0) {
+    sections.push(
+      `\npending approvals\n${formatTable(
+        [
+          { header: "request", value: (approval) => approval.requestId, maxWidth: 40 },
+          { header: "kind", value: (approval) => approval.requestKind, maxWidth: 16 },
+          { header: "created", value: (approval) => approval.createdAt, maxWidth: 28 },
+          { header: "detail", value: (approval) => approval.detail ?? "-", maxWidth: 72 },
+        ],
+        thread.pendingApprovals,
+      )}`,
+    );
+  }
+  if (thread.pendingUserInputs.length > 0) {
+    sections.push(
+      `\npending user inputs\n${formatTable(
+        [
+          { header: "request", value: (input) => input.requestId, maxWidth: 40 },
+          { header: "questions", value: (input) => String(input.questions.length), maxWidth: 9 },
+          { header: "created", value: (input) => input.createdAt, maxWidth: 28 },
+          {
+            header: "prompt",
+            value: (input) => input.questions.map((question) => question.question).join("\n"),
+            maxWidth: 72,
+          },
+        ],
+        thread.pendingUserInputs,
+      )}`,
+    );
+  }
+  return `${sections.join("\n")}\n`;
+}
+
+export function formatThreadsHuman(threads: ReadonlyArray<OrchestrationThreadShell>) {
+  if (threads.length === 0) {
+    return "no threads\n";
+  }
+  return `${formatTable(
+    [
+      { header: "title", value: (thread) => thread.title, maxWidth: 36 },
+      { header: "id", value: (thread) => thread.id, maxWidth: 40 },
+      { header: "status", value: (thread) => threadStatus(thread), maxWidth: 18 },
+      { header: "updated", value: (thread) => thread.updatedAt, maxWidth: 28 },
+      { header: "flags", value: formatThreadFlags, maxWidth: 34 },
+    ],
+    threads,
+  )}\n`;
+}
+
+export function formatThreadDeletedHuman(input: {
+  readonly threadId: string;
+  readonly dispatch: { readonly sequence: number };
+}) {
+  return `thread deleted: ${input.threadId} (sequence ${input.dispatch.sequence})`;
+}
+
+export function formatThreadStartedHuman(input: {
+  readonly thread: OrchestrationThread;
+  readonly sequence: number;
+}) {
+  return `thread started\n${formatRecord([
+    { field: "title", value: input.thread.title },
+    { field: "id", value: input.thread.id },
+    { field: "status", value: threadStatus(input.thread) },
+    { field: "sequence", value: String(input.sequence) },
+  ])}`;
+}
+
+export function formatThreadMessagesHuman(thread: OrchestrationThread, limit: number) {
+  const messages = limit === 0 ? thread.messages : thread.messages.slice(-limit);
+  return formatChatTranscript(messages);
+}
+
+export function formatWaitDoneHuman(thread: OrchestrationThread) {
+  const latest = latestAssistantMessage(thread);
+  return `status: ${threadStatus(thread)}\n${
+    latest !== undefined ? `\n${formatChatTranscript([latest])}` : ""
+  }`;
+}
+
+export function formatThreadMessagesJson(thread: OrchestrationThread, full: boolean) {
+  return full ? thread : { thread: stripThreadMessages(thread), messages: thread.messages };
+}
+
+export function formatWaitEventNdjson(event: WaitEvent) {
+  if (event.type !== "thread" && event.type !== "done") {
+    return event;
+  }
+  const compactThread = stripThreadHeavy(event.thread);
+  return event.type === "done"
+    ? {
+        type: "done",
+        thread: compactThread,
+        latestAssistantMessage: latestAssistantMessage(event.thread) ?? null,
+      }
+    : {
+        type: "thread",
+        thread: compactThread,
+        messageCount: event.thread.messages.length,
+      };
+}
+
+function stripThreadMessages<T extends { readonly messages: unknown }>(thread: T) {
+  const { messages: _messages, ...rest } = thread;
+  return rest;
+}
+
+function formatThreadFlags(thread: OrchestrationThreadShell) {
+  const flags = [
+    thread.archivedAt !== null ? "archived" : null,
+    thread.hasPendingApprovals ? "approval" : null,
+    thread.hasPendingUserInput ? "input" : null,
+    thread.hasActionableProposedPlan ? "plan" : null,
+  ].filter((flag): flag is string => flag !== null);
+  return flags.length > 0 ? flags.join(", ") : "-";
+}
+
+function stripThreadHeavy<
+  T extends {
+    readonly messages: unknown;
+    readonly activities?: unknown;
+    readonly proposedPlans?: unknown;
+    readonly checkpoints?: unknown;
+  },
+>(thread: T) {
+  const {
+    messages: _messages,
+    activities: _activities,
+    proposedPlans: _proposedPlans,
+    checkpoints: _checkpoints,
+    ...rest
+  } = thread;
+  return rest;
+}

package/src/cli/index.ts

@@ -8,3 +8,23 @@ export {
   waitFormatFlag,
   worktreeFlag,
 } from "./flags.ts";
+export * as Env from "./env/index.ts";
+export * as Runtime from "./runtime/index.ts";
+export {
+  resolveCommandProjectRef,
+  resolveProjectRef,
+  resolveThreadId,
+  resolveWorktreePath,
+} from "./scope/index.ts";
+export {
+  resolveOutputFormat,
+  canRenderLiveTerminal,
+  isInteractiveHumanTerminal,
+  isAgentEnvironment,
+  humanJsonFormatChoices,
+  humanNdjsonFormatChoices,
+  humanJsonNdjsonFormatChoices,
+  type HumanJsonFormat,
+  type HumanNdjsonFormat,
+  type HumanJsonNdjsonFormat,
+} from "./format/index.ts";

package/src/cli/interaction/confirm.ts

@@ -0,0 +1,64 @@
+import * as Effect from "effect/Effect";
+import * as Prompt from "effect/unstable/cli/Prompt";
+
+import { DestructiveConfirmationRequiredError } from "../error.ts";
+import { isInteractiveHumanTerminal } from "../format/output.ts";
+import type { T3CliEnvShape } from "../../config/env/env.ts";
+import type { CliRuntime } from "../runtime/service.ts";
+
+export const requireDestructiveConfirmation = Effect.fn("requireDestructiveConfirmation")(
+  function* (input: {
+    readonly message: string;
+    readonly yes: boolean;
+    readonly cliRuntime: CliRuntime["Service"];
+    readonly t3CliEnv: T3CliEnvShape;
+  }) {
+    if (input.yes) {
+      return;
+    }
+    if (!isInteractiveHumanTerminal(input.cliRuntime, input.t3CliEnv)) {
+      yield* Effect.fail(
+        new DestructiveConfirmationRequiredError({
+          message: "destructive action requires --yes in non-interactive mode",
+        }),
+      );
+      return;
+    }
+    const confirmed = yield* Prompt.run(Prompt.confirm({ message: input.message, initial: false }));
+    if (confirmed) {
+      return;
+    }
+    yield* Effect.fail(new DestructiveConfirmationRequiredError({ message: "aborted" }));
+  },
+);
+
+export const requireEnvironmentReplaceConfirmation = Effect.fn(
+  "requireEnvironmentReplaceConfirmation",
+)(function* (input: {
+  readonly name: string;
+  readonly replace: boolean;
+  readonly cliRuntime: CliRuntime["Service"];
+  readonly t3CliEnv: T3CliEnvShape;
+}) {
+  if (input.replace) {
+    return;
+  }
+  if (!isInteractiveHumanTerminal(input.cliRuntime, input.t3CliEnv)) {
+    yield* Effect.fail(
+      new DestructiveConfirmationRequiredError({
+        message: `environment '${input.name}' already exists: pass --replace`,
+      }),
+    );
+    return;
+  }
+  const confirmed = yield* Prompt.run(
+    Prompt.confirm({
+      message: `Environment '${input.name}' already exists. Replace?`,
+      initial: false,
+    }),
+  );
+  if (confirmed) {
+    return;
+  }
+  yield* Effect.fail(new DestructiveConfirmationRequiredError({ message: "aborted" }));
+});

package/src/cli/{self-action.ts → interaction/self-action.ts}

@@ -1,23 +1,25 @@
 import * as Effect from "effect/Effect";
 
-import { SelfActionError } from "./error.ts";
-import { isAgentEnvironment } from "./output-format.ts";
-import type { EnvironmentShape } from "../environment/service.ts";
+import { SelfActionError } from "../error.ts";
+import { isAgentEnvironment } from "../format/output.ts";
+import type { T3CliEnvShape } from "../../config/env/env.ts";
+import type { CliRuntime } from "../runtime/service.ts";
 
 export const requireSelfActionConfirmation = Effect.fn("requireSelfActionConfirmation")(
   function* (input: {
     readonly threadId: string;
     readonly force: boolean;
-    readonly environment: EnvironmentShape;
+    readonly cliRuntime: CliRuntime["Service"];
+    readonly t3CliEnv: T3CliEnvShape;
     readonly action: string;
   }) {
     if (input.force) {
       return;
     }
-    if (!isAgentEnvironment(input.environment)) {
+    if (!isAgentEnvironment(input.t3CliEnv)) {
       return;
     }
-    const callerThreadId = input.environment.env.T3CODE_THREAD_ID;
+    const callerThreadId = input.t3CliEnv.scope.t3codeThreadId;
     if (callerThreadId === undefined || callerThreadId.length === 0) {
       return;
     }

package/src/cli/message-input.ts

@@ -1,6 +1,6 @@
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
-import { ProviderUserInputAnswers } from "#t3tools/contracts";
+import { ProviderUserInputAnswers } from "@t3tools/contracts";
 
 import { MessageInputError } from "./error.ts";
 import type { InputError } from "./input/error.ts";

package/src/cli/model.ts

@@ -2,11 +2,13 @@ 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 } from "./flags.ts";
 import { T3Application } from "../application/service.ts";
-import { Environment } from "../environment/service.ts";
-import { formatModelsHuman } from "./model-format.ts";
-import { resolveOutputFormat } from "./output-format.ts";
+import { CliRuntime } from "../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../config/env/env.ts";
+import { formatModelsHuman } from "./format/model.ts";
+import { resolveOutputFormat } from "./format/output.ts";
 import { T3Output } from "./output/service.ts";
 
 export function createModelCommand() {
@@ -22,14 +24,16 @@ const listCommand = Command.make(
     all: Flag.boolean("all"),
     provider: Flag.string("provider").pipe(Flag.optional),
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ all, provider, 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 providerValue = Option.getOrUndefined(provider);
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const providers = yield* application.listModels({
         all,
         ...(providerValue !== undefined && providerValue.length > 0

package/src/cli/project.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, projectPathFlag } from "./flags.ts";
-import { formatProjectAddedHuman, formatProjectsHuman } from "./project-format.ts";
+import { formatProjectAddedHuman, formatProjectsHuman } from "./format/project.ts";
 import { deleteProjectCommand } from "./projects/delete.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 function createProjectCommand() {
@@ -21,13 +23,15 @@ const listCommand = Command.make(
   "list",
   {
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ 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 resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const snapshot = yield* application.loadShell();
       if (resolvedFormat === "json") {
         yield* output.printJson(snapshot.projects);
@@ -43,13 +47,15 @@ const addCommand = Command.make(
     path: projectPathFlag,
     title: Flag.string("title").pipe(Flag.optional),
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ path, title, 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 resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const titleValue = Option.getOrUndefined(title);
       const result = yield* application.addProject({
         path,

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 {