t3code-cli 0.11.0 → 0.12.0

package/src/cli/action.ts

@@ -0,0 +1,398 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Command, Flag } from "effect/unstable/cli";
+
+import { T3Application, type ProjectActionSelector } from "../application/service.ts";
+import { loadT3CliEnv } from "../config/env/env.ts";
+import {
+  formatActionAddedHuman,
+  formatActionDeletedHuman,
+  formatActionListHuman,
+  formatActionRunHuman,
+  formatActionUpdatedHuman,
+} from "./action-format.ts";
+import {
+  ConflictingUpdateFlagsError,
+  InvalidFlagCombinationError,
+  MissingUpdateFieldsError,
+} from "./error.ts";
+import { extraArgsConfig } from "./extra-args.ts";
+import { formatFlag, projectFlag, threadFlag, yesFlag } from "./flags.ts";
+import { resolveOutputFormat } from "./format/output.ts";
+import { requireDestructiveConfirmation } from "./interaction/confirm.ts";
+import { T3Output } from "./output/service.ts";
+import { requireCommandProjectRef } from "./require.ts";
+import { CliRuntime } from "./runtime/service.ts";
+import { requireCommandThreadId } from "./terminal/scope.ts";
+import { runAttachedTerminalSession, snapshotToTerminalAttachTarget } from "./terminal/shared.ts";
+
+const actionIconChoices = ["play", "test", "lint", "configure", "build", "debug"] as const;
+
+export function createActionCommand() {
+  return Command.make("action").pipe(
+    Command.withDescription("project-defined toolbar action commands"),
+    Command.withSubcommands([
+      listActionsCommand,
+      runActionCommand,
+      addActionCommand,
+      updateActionCommand,
+      deleteActionCommand,
+    ]),
+  );
+}
+
+const idFlag = Flag.string("id").pipe(Flag.optional);
+const nameFlag = Flag.string("name").pipe(Flag.optional);
+const commandFlag = Flag.string("command");
+const optionalCommandFlag = Flag.string("command").pipe(Flag.optional);
+const iconFlag = Flag.choice("icon", actionIconChoices).pipe(Flag.withDefault("play"));
+const optionalIconFlag = Flag.choice("icon", actionIconChoices).pipe(Flag.optional);
+const setupFlag = Flag.boolean("setup");
+const optionalSetupFlag = Flag.boolean("setup").pipe(Flag.optional);
+const noSetupFlag = Flag.boolean("no-setup").pipe(Flag.optional);
+const previewUrlFlag = Flag.string("preview-url").pipe(Flag.optional);
+const clearPreviewUrlFlag = Flag.boolean("clear-preview-url").pipe(Flag.optional);
+const autoOpenPreviewFlag = Flag.boolean("auto-open-preview").pipe(Flag.optional);
+const noAutoOpenPreviewFlag = Flag.boolean("no-auto-open-preview").pipe(Flag.optional);
+const clearAutoOpenPreviewFlag = Flag.boolean("clear-auto-open-preview").pipe(Flag.optional);
+
+const listActionsCommand = Command.make(
+  "list",
+  {
+    project: projectFlag,
+    format: formatFlag,
+    ...extraArgsConfig,
+  },
+  ({ project, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
+      const output = yield* T3Output;
+      const projectRef = yield* requireCommandProjectRef({
+        project,
+      });
+      const result = yield* application.listActions(projectRef);
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
+      if (resolvedFormat === "json") {
+        yield* output.printJson(result);
+      } else {
+        yield* output.writeStdout(formatActionListHuman(result));
+      }
+    }),
+).pipe(Command.withDescription("list project actions"));
+
+const runActionCommand = Command.make(
+  "run",
+  {
+    thread: threadFlag,
+    id: idFlag,
+    name: nameFlag,
+    terminal: Flag.string("terminal").pipe(Flag.optional),
+    attach: Flag.boolean("attach"),
+    format: formatFlag,
+    ...extraArgsConfig,
+  },
+  ({ thread, id, name, terminal, attach, 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 selector = yield* requireActionSelector({ id, name });
+      const terminalId = Option.getOrUndefined(terminal);
+      const result = yield* application.runAction({
+        threadId,
+        selector,
+        ...(terminalId !== undefined ? { terminalId } : {}),
+      });
+
+      if (attach) {
+        yield* runAttachedTerminalSession({
+          terminal: snapshotToTerminalAttachTarget(result.terminal),
+        });
+      } else {
+        const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
+        if (resolvedFormat === "json") {
+          yield* output.printJson(result);
+        } else {
+          yield* output.printInfo(formatActionRunHuman(result));
+        }
+      }
+    }),
+).pipe(Command.withDescription("run a project action in a thread terminal"));
+
+const addActionCommand = Command.make(
+  "add",
+  {
+    project: projectFlag,
+    name: Flag.string("name"),
+    command: commandFlag,
+    id: idFlag,
+    icon: iconFlag,
+    setup: setupFlag,
+    previewUrl: previewUrlFlag,
+    autoOpenPreview: Flag.boolean("auto-open-preview"),
+    format: formatFlag,
+    ...extraArgsConfig,
+  },
+  ({ project, name, command, id, icon, setup, previewUrl, autoOpenPreview, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
+      const output = yield* T3Output;
+      const projectRef = yield* requireCommandProjectRef({
+        project,
+      });
+      const idValue = Option.getOrUndefined(id);
+      const previewUrlValue = Option.getOrUndefined(previewUrl);
+      const result = yield* application.addAction({
+        projectRef,
+        name,
+        command,
+        icon,
+        ...(idValue !== undefined ? { id: idValue } : {}),
+        ...(setup ? { setup: true } : {}),
+        ...(previewUrlValue !== undefined ? { previewUrl: previewUrlValue } : {}),
+        ...(autoOpenPreview ? { autoOpenPreview: true } : {}),
+      });
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
+      if (resolvedFormat === "json") {
+        yield* output.printJson(result);
+      } else {
+        yield* output.printInfo(
+          formatActionAddedHuman({
+            project: result.project,
+            action: result.action,
+            sequence: result.dispatch.sequence,
+          }),
+        );
+      }
+    }),
+).pipe(Command.withDescription("add a project action"));
+
+const updateActionCommand = Command.make(
+  "update",
+  {
+    project: projectFlag,
+    id: idFlag,
+    name: nameFlag,
+    setName: Flag.string("set-name").pipe(Flag.optional),
+    command: optionalCommandFlag,
+    icon: optionalIconFlag,
+    setup: optionalSetupFlag,
+    noSetup: noSetupFlag,
+    previewUrl: previewUrlFlag,
+    clearPreviewUrl: clearPreviewUrlFlag,
+    autoOpenPreview: autoOpenPreviewFlag,
+    noAutoOpenPreview: noAutoOpenPreviewFlag,
+    clearAutoOpenPreview: clearAutoOpenPreviewFlag,
+    format: formatFlag,
+    ...extraArgsConfig,
+  },
+  ({
+    project,
+    id,
+    name,
+    setName,
+    command,
+    icon,
+    setup,
+    noSetup,
+    previewUrl,
+    clearPreviewUrl,
+    autoOpenPreview,
+    noAutoOpenPreview,
+    clearAutoOpenPreview,
+    format,
+  }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
+      const output = yield* T3Output;
+      const projectRef = yield* requireCommandProjectRef({
+        project,
+      });
+      const selector = yield* requireActionSelector({ id, name });
+      const patch = yield* buildUpdatePatch({
+        setName,
+        command,
+        icon,
+        setup,
+        noSetup,
+        previewUrl,
+        clearPreviewUrl,
+        autoOpenPreview,
+        noAutoOpenPreview,
+        clearAutoOpenPreview,
+      });
+      const result = yield* application.updateAction({
+        projectRef,
+        selector,
+        ...patch,
+      });
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
+      if (resolvedFormat === "json") {
+        yield* output.printJson(result);
+      } else {
+        yield* output.printInfo(
+          formatActionUpdatedHuman({
+            project: result.project,
+            action: result.action,
+            sequence: result.dispatch.sequence,
+          }),
+        );
+      }
+    }),
+).pipe(Command.withDescription("update a project action"));
+
+const deleteActionCommand = Command.make(
+  "delete",
+  {
+    project: projectFlag,
+    id: idFlag,
+    name: nameFlag,
+    yes: yesFlag,
+    format: formatFlag,
+    ...extraArgsConfig,
+  },
+  ({ project, id, name, yes, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
+      const output = yield* T3Output;
+      const projectRef = yield* requireCommandProjectRef({
+        project,
+      });
+      const selector = yield* requireActionSelector({ id, name });
+      const listed = yield* application.listActions(projectRef);
+      const selectorLabel =
+        selector.id !== undefined ? `id ${selector.id}` : `name ${selector.name.trim()}`;
+      yield* requireDestructiveConfirmation({
+        message: `Delete action selected by ${selectorLabel} from ${listed.project.title}?`,
+        yes,
+        cliRuntime,
+        t3CliEnv,
+      });
+      const result = yield* application.deleteAction({
+        projectRef,
+        selector,
+      });
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
+      if (resolvedFormat === "json") {
+        yield* output.printJson(result);
+      } else {
+        yield* output.printInfo(
+          formatActionDeletedHuman({
+            project: result.project,
+            action: result.action,
+            sequence: result.dispatch.sequence,
+          }),
+        );
+      }
+    }),
+).pipe(Command.withDescription("delete a project action"));
+
+function requireActionSelector(input: {
+  readonly id: Option.Option<string>;
+  readonly name: Option.Option<string>;
+}) {
+  return Effect.gen(function* () {
+    const id = Option.getOrUndefined(input.id);
+    const name = Option.getOrUndefined(input.name);
+    if ((id === undefined && name === undefined) || (id !== undefined && name !== undefined)) {
+      return yield* Effect.fail(
+        new InvalidFlagCombinationError({
+          message: "provide exactly one action selector: --id <id> or --name <name>",
+        }),
+      );
+    }
+    return id !== undefined
+      ? ({ id } satisfies ProjectActionSelector)
+      : ({ name: name! } satisfies ProjectActionSelector);
+  });
+}
+
+function buildUpdatePatch(input: {
+  readonly setName: Option.Option<string>;
+  readonly command: Option.Option<string>;
+  readonly icon: Option.Option<(typeof actionIconChoices)[number]>;
+  readonly setup: Option.Option<boolean>;
+  readonly noSetup: Option.Option<boolean>;
+  readonly previewUrl: Option.Option<string>;
+  readonly clearPreviewUrl: Option.Option<boolean>;
+  readonly autoOpenPreview: Option.Option<boolean>;
+  readonly noAutoOpenPreview: Option.Option<boolean>;
+  readonly clearAutoOpenPreview: Option.Option<boolean>;
+}) {
+  return Effect.gen(function* () {
+    const setName = Option.getOrUndefined(input.setName);
+    const command = Option.getOrUndefined(input.command);
+    const icon = Option.getOrUndefined(input.icon);
+    const setup = Option.getOrUndefined(input.setup);
+    const noSetup = Option.getOrUndefined(input.noSetup);
+    const previewUrl = Option.getOrUndefined(input.previewUrl);
+    const clearPreviewUrl = Option.getOrUndefined(input.clearPreviewUrl);
+    const autoOpenPreview = Option.getOrUndefined(input.autoOpenPreview);
+    const noAutoOpenPreview = Option.getOrUndefined(input.noAutoOpenPreview);
+    const clearAutoOpenPreview = Option.getOrUndefined(input.clearAutoOpenPreview);
+
+    if (setup === true && noSetup === true) {
+      return yield* Effect.fail(
+        new ConflictingUpdateFlagsError({
+          message: "--setup and --no-setup are mutually exclusive",
+        }),
+      );
+    }
+    if (previewUrl !== undefined && clearPreviewUrl === true) {
+      return yield* Effect.fail(
+        new ConflictingUpdateFlagsError({
+          message: "--preview-url and --clear-preview-url are mutually exclusive",
+        }),
+      );
+    }
+    const autoOpenSetCount = [autoOpenPreview, noAutoOpenPreview, clearAutoOpenPreview].filter(
+      (value) => value === true,
+    ).length;
+    if (autoOpenSetCount > 1) {
+      return yield* Effect.fail(
+        new ConflictingUpdateFlagsError({
+          message:
+            "--auto-open-preview, --no-auto-open-preview, and --clear-auto-open-preview are mutually exclusive",
+        }),
+      );
+    }
+
+    const patch = {
+      ...(setName !== undefined ? { name: setName } : {}),
+      ...(command !== undefined ? { command } : {}),
+      ...(icon !== undefined ? { icon } : {}),
+      ...(setup === true ? { setup: true } : noSetup === true ? { setup: false } : {}),
+      ...(clearPreviewUrl === true
+        ? { previewUrl: null }
+        : previewUrl !== undefined
+          ? { previewUrl }
+          : {}),
+      ...(autoOpenPreview === true
+        ? { autoOpenPreview: true }
+        : noAutoOpenPreview === true || clearAutoOpenPreview === true
+          ? { autoOpenPreview: null }
+          : {}),
+    };
+    if (Object.keys(patch).length === 0) {
+      return yield* Effect.fail(
+        new MissingUpdateFieldsError({
+          message:
+            "at least one update field is required: --set-name, --command, --icon, --setup, --no-setup, --preview-url, --clear-preview-url, --auto-open-preview, --no-auto-open-preview, or --clear-auto-open-preview",
+        }),
+      );
+    }
+    return patch;
+  });
+}

package/src/cli/app.ts

@@ -1,6 +1,9 @@
 import { Command } from "effect/unstable/cli";
 
+import { createActionCommand } from "./action.ts";
 import { createAuthCommand } from "./auth.ts";
+import { createEnvCommand } from "./env.ts";
+import { cliEnvironmentSetting } from "./env/flag.ts";
 import { createTerminalCommandGroup } from "./terminal.ts";
 import { createModelCommand } from "./model.ts";
 import { createProjectCommand } from "./project.ts";
@@ -15,8 +18,11 @@ import { waitForThreadCommand } from "./threads/wait.ts";
 export function createCliCommand() {
   return Command.make("t3cli").pipe(
     Command.withDescription("non-interactive cli for running t3code server"),
+    Command.withGlobalFlags([cliEnvironmentSetting]),
     Command.withSubcommands([
+      createActionCommand(),
       createAuthCommand(),
+      createEnvCommand(),
       listThreadsCommand,
       createModelCommand(),
       createProjectCommand(),

package/src/cli/auth.ts

@@ -8,14 +8,49 @@ import {
   formatAuthPaired,
   formatAuthStatusHuman,
   formatAuthStatusJson,
-} from "./auth-format.ts";
+} from "./format/auth.ts";
 import { T3Auth } from "../auth/service.ts";
-import { T3Config } from "../config/service.ts";
-import { Environment } from "../environment/service.ts";
-import { formatFlag } from "./flags.ts";
-import { resolveOutputFormat } from "./output-format.ts";
+import { extraArgsConfig } from "./extra-args.ts";
+import { CliRuntime } from "../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../config/env/env.ts";
+import { requireEnvironmentReplaceConfirmation } from "./interaction/confirm.ts";
+import { envNameFlag, formatFlag, replaceFlag } from "./flags.ts";
+import { resolveOutputFormat } from "./format/output.ts";
 import { T3Output } from "./output/service.ts";
 
+const persistAuthEnvironment = Effect.fn("persistAuthEnvironment")(function* (input: {
+  readonly explicitName: Option.Option<string>;
+  readonly fallbackName: string;
+  readonly url: string;
+  readonly token: string;
+  readonly local: boolean;
+  readonly replace: boolean;
+}) {
+  const auth = yield* T3Auth;
+  const cliRuntime = yield* CliRuntime;
+  const t3CliEnv = yield* loadT3CliEnv;
+  const environmentName = Option.isSome(input.explicitName)
+    ? input.explicitName.value
+    : input.fallbackName;
+  const exists = yield* auth.environmentExists(environmentName);
+  if (exists) {
+    yield* requireEnvironmentReplaceConfirmation({
+      name: environmentName,
+      replace: input.replace,
+      cliRuntime,
+      t3CliEnv,
+    });
+  }
+  return yield* auth.persistEnvironment({
+    name: environmentName,
+    url: input.url,
+    token: input.token,
+    local: input.local,
+    replace: input.replace,
+    allowReplace: true,
+  });
+});
+
 export function createAuthCommand() {
   return Command.make("auth").pipe(
     Command.withDescription("auth commands"),
@@ -28,24 +63,33 @@ const pairCommand = Command.make(
   {
     url: Flag.string("url"),
     local: Flag.boolean("local"),
+    name: envNameFlag,
+    replace: replaceFlag,
     format: formatFlag,
+    ...extraArgsConfig,
   },
-  ({ url, local, format }) =>
+  ({ url, local, name, replace, format }) =>
     Effect.gen(function* () {
       const auth = yield* T3Auth;
-      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 result = yield* auth.pair(url);
-      yield* auth.writeConfig({
+      const fallbackName = yield* auth.defaultNameFromUrl(result.url);
+      const environmentName = yield* persistAuthEnvironment({
+        explicitName: name,
+        fallbackName,
         url: result.url,
         token: result.token,
         local,
+        replace,
       });
+      const payload = { ...result, name: environmentName };
       if (resolvedFormat === "json") {
-        yield* output.printJson(result);
+        yield* output.printJson(payload);
       } else {
-        yield* output.printInfo(formatAuthPaired(result));
+        yield* output.printInfo(formatAuthPaired(payload));
       }
     }),
 ).pipe(Command.withDescription("pair with t3code server"));
@@ -58,14 +102,18 @@ const localCommand = Command.make(
     role: Flag.choice("role", ["owner", "client"] as const).pipe(Flag.withDefault("owner")),
     label: Flag.string("label").pipe(Flag.withDefault("t3cli")),
     subject: Flag.string("subject").pipe(Flag.withDefault("t3cli-local")),
+    name: envNameFlag,
+    replace: replaceFlag,
     format: formatFlag,
+    ...extraArgsConfig,
   },
-  ({ baseDir, origin, role, label, subject, format }) =>
+  ({ baseDir, origin, role, label, subject, name, replace, format }) =>
     Effect.gen(function* () {
       const auth = yield* T3Auth;
-      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 result = yield* auth.local({
         role,
         label,
@@ -73,15 +121,20 @@ const localCommand = Command.make(
         ...(Option.isSome(baseDir) ? { baseDir: baseDir.value } : {}),
         ...(Option.isSome(origin) ? { origin: origin.value } : {}),
       });
-      yield* auth.writeConfig({
+      const fallbackName = yield* auth.defaultNameForLocal();
+      const environmentName = yield* persistAuthEnvironment({
+        explicitName: name,
+        fallbackName,
         url: result.url,
         token: result.token,
         local: true,
+        replace,
       });
+      const payload = { ...result, name: environmentName };
       if (resolvedFormat === "json") {
-        yield* output.printJson(formatAuthLocalJson(result));
+        yield* output.printJson(formatAuthLocalJson(payload));
       } else {
-        yield* output.printInfo(formatAuthLocalHuman(result));
+        yield* output.printInfo(formatAuthLocalHuman(payload));
       }
     }),
 ).pipe(Command.withDescription("authenticate with local t3code installation"));
@@ -90,20 +143,20 @@ const statusCommand = Command.make(
   "status",
   {
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ format }) =>
     Effect.gen(function* () {
-      const configService = yield* T3Config;
       const auth = yield* T3Auth;
-      const environment = yield* Environment;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
-      const config = yield* configService.resolve();
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const result = yield* auth.status();
       if (resolvedFormat === "json") {
-        yield* output.printJson(formatAuthStatusJson({ config, result }));
+        yield* output.printJson(formatAuthStatusJson(result));
       } else {
-        yield* output.printInfo(formatAuthStatusHuman({ config, result }));
+        yield* output.printInfo(formatAuthStatusHuman(result));
       }
     }),
 ).pipe(Command.withDescription("show auth status"));

package/src/cli/env/flag.ts

@@ -0,0 +1,8 @@
+import { Flag, GlobalFlag } from "effect/unstable/cli";
+
+export const cliEnvironmentSetting = GlobalFlag.setting("environment")({
+  flag: Flag.string("environment").pipe(
+    Flag.withDescription("Auth environment name for this command"),
+    Flag.optional,
+  ),
+});

package/src/cli/env/index.ts

@@ -0,0 +1,2 @@
+export { cliEnvironmentSetting } from "./flag.ts";
+export * as Selection from "./selection-layer.ts";

package/src/cli/env/selection-layer.test.ts

@@ -0,0 +1,49 @@
+import "vite-plus/test/config";
+
+import * as Effect from "effect/Effect";
+import { assert, describe, it } from "@effect/vitest";
+
+import { T3Config } from "../../config/config.ts";
+import { ConfigPlatformLayer } from "../../config/platform.test-utils.ts";
+import { makeTempHomeScoped } from "../../config/temp-home.test-utils.ts";
+import { t3ConfigDepsLayer } from "../../config/layer.test-utils.ts";
+
+describe("T3ConfigSelectionLive", () => {
+  it.effect("resolves T3CLI_ENV through the selection layer", () =>
+    Effect.gen(function* () {
+      return yield* makeTempHomeScoped("t3cli-selection-");
+    }).pipe(
+      Effect.flatMap((homeDir) =>
+        Effect.gen(function* () {
+          const config = yield* T3Config;
+          yield* config.upsertEnvironment({
+            name: "home",
+            url: "https://home.example",
+            token: "home-token",
+            local: false,
+          });
+          yield* config.upsertEnvironment({
+            name: "work",
+            url: "https://work.example",
+            token: "work-token",
+            local: true,
+          });
+          const resolved = yield* config.resolve();
+          assert.equal(resolved.source, "config");
+          if (resolved.source === "config") {
+            assert.equal(resolved.environment, "work");
+          }
+        }).pipe(
+          Effect.provide(
+            t3ConfigDepsLayer(homeDir, {
+              useSelectionLive: true,
+              env: { T3CLI_ENV: "work" },
+            }),
+          ),
+        ),
+      ),
+      Effect.provide(ConfigPlatformLayer),
+      Effect.scoped,
+    ),
+  );
+});

package/src/cli/env/selection-layer.ts

@@ -0,0 +1,27 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+
+import { resolveConfiguredEnvironment } from "../../config/selection/resolve.ts";
+import { T3ConfigSelection } from "../../config/selection/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import { cliEnvironmentSetting } from "./flag.ts";
+
+export const layer = Layer.effect(
+  T3ConfigSelection,
+  Effect.gen(function* () {
+    const t3CliEnv = yield* loadT3CliEnv;
+    return {
+      getSelectedEnvironment: () =>
+        Effect.gen(function* () {
+          const cliEnvironment = yield* Effect.serviceOption(cliEnvironmentSetting);
+          return resolveConfiguredEnvironment({
+            cliFlag: Option.isSome(cliEnvironment)
+              ? Option.getOrUndefined(cliEnvironment.value)
+              : undefined,
+            t3cliEnv: Option.getOrUndefined(t3CliEnv.t3cliEnv),
+          });
+        }),
+    };
+  }),
+);