t3code-cli 0.11.0 → 0.13.0

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

package/src/cli/env.ts

@@ -0,0 +1,107 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Argument, Command } from "effect/unstable/cli";
+
+import {
+  formatAuthListHuman,
+  formatAuthListJson,
+  formatAuthUnpairHuman,
+  formatAuthUseHuman,
+} from "./format/auth.ts";
+import { T3Auth } from "../auth/service.ts";
+import { CliRuntime } from "../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../config/env/env.ts";
+import { requireDestructiveConfirmation } from "./interaction/confirm.ts";
+import { extraArgsConfig } from "./extra-args.ts";
+import { envNameFlag, formatFlag, yesFlag } from "./flags.ts";
+import { resolveOutputFormat } from "./format/output.ts";
+import { T3Output } from "./output/service.ts";
+
+export function createEnvCommand() {
+  return Command.make("env").pipe(
+    Command.withDescription("manage stored environments"),
+    Command.withSubcommands([listCommand, useCommand, removeCommand]),
+  );
+}
+
+const listCommand = Command.make(
+  "list",
+  {
+    format: formatFlag,
+    ...extraArgsConfig,
+  },
+  ({ format }) =>
+    Effect.gen(function* () {
+      const auth = yield* T3Auth;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
+      const output = yield* T3Output;
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
+      const environments = yield* auth.listEnvironments();
+      if (resolvedFormat === "json") {
+        yield* output.printJson(formatAuthListJson(environments));
+      } else {
+        yield* output.printInfo(formatAuthListHuman(environments));
+      }
+    }),
+).pipe(Command.withDescription("list stored environments"));
+
+const useCommand = Command.make(
+  "use",
+  {
+    name: Argument.string("name"),
+    format: formatFlag,
+    ...extraArgsConfig,
+  },
+  ({ name, format }) =>
+    Effect.gen(function* () {
+      const auth = yield* T3Auth;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
+      const output = yield* T3Output;
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
+      const result = yield* auth.useEnvironment(name);
+      if (resolvedFormat === "json") {
+        yield* output.printJson(result);
+      } else {
+        yield* output.printInfo(formatAuthUseHuman(result));
+      }
+    }),
+).pipe(Command.withDescription("set the default environment"));
+
+const removeCommand = Command.make(
+  "remove",
+  {
+    name: envNameFlag,
+    yes: yesFlag,
+    format: formatFlag,
+    ...extraArgsConfig,
+  },
+  ({ name, yes, format }) =>
+    Effect.gen(function* () {
+      const auth = yield* T3Auth;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
+      const output = yield* T3Output;
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
+      const targetName = yield* auth.resolveUnpairTarget(
+        Option.isSome(name) ? { name: name.value } : {},
+      );
+      yield* requireDestructiveConfirmation({
+        message: `Remove local credentials for environment '${targetName}'?`,
+        yes,
+        cliRuntime,
+        t3CliEnv,
+      });
+      const result = yield* auth.unpairEnvironment({ name: targetName });
+      if (resolvedFormat === "json") {
+        yield* output.printJson(result);
+      } else {
+        yield* output.printInfo(formatAuthUnpairHuman(result));
+      }
+    }),
+).pipe(
+  Command.withDescription(
+    "remove local credentials for an environment (remote tokens may remain valid until expiry)",
+  ),
+);

package/src/cli/extra-args.test.ts

@@ -0,0 +1,32 @@
+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 { CliError } from "effect/unstable/cli";
+
+import { extraArgsConfig } from "./extra-args.ts";
+
+describe("extraArgsConfig", () => {
+  it("rejects leftover positional arguments", () =>
+    Effect.gen(function* () {
+      const exit = yield* extraArgsConfig.extraArgs
+        .parse({ flags: {}, arguments: ["extra"] })
+        .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, CliError.InvalidValue);
+        assert.equal(
+          error.value.message,
+          'Invalid value for argument <extra>: "extra". Expected: no extra arguments',
+        );
+      }
+    }));
+});

package/src/cli/extra-args.ts

@@ -0,0 +1,22 @@
+import * as Effect from "effect/Effect";
+import { Argument, CliError } from "effect/unstable/cli";
+
+const rejectExtraArguments = Argument.string("extra").pipe(
+  Argument.variadic(),
+  Argument.mapEffect((extra) =>
+    extra.length === 0
+      ? Effect.void
+      : Effect.fail(
+          new CliError.InvalidValue({
+            option: "extra",
+            value: extra[0] ?? "",
+            expected: "no extra arguments",
+            kind: "argument",
+          }),
+        ),
+  ),
+);
+
+export const extraArgsConfig = {
+  extraArgs: rejectExtraArguments,
+};

package/src/cli/flags.ts

@@ -4,7 +4,7 @@ import {
   humanJsonFormatChoices,
   humanJsonNdjsonFormatChoices,
   humanNdjsonFormatChoices,
-} from "./output-format.ts";
+} from "./format/output.ts";
 
 export const projectFlag = Flag.string("project").pipe(
   Flag.withDescription(
@@ -35,6 +35,16 @@ export const yesFlag = Flag.boolean("yes").pipe(
   Flag.withDefault(false),
 );
 
+export const replaceFlag = Flag.boolean("replace").pipe(
+  Flag.withDescription("Replace an existing environment with the same name"),
+  Flag.withDefault(false),
+);
+
+export const envNameFlag = Flag.string("name").pipe(
+  Flag.withDescription("Environment name"),
+  Flag.optional,
+);
+
 export const forceFlag = Flag.boolean("force").pipe(
   Flag.withDescription("Delete non-empty project (cascade thread deletes)"),
   Flag.withDefault(false),

package/src/cli/format/auth.ts

@@ -0,0 +1,92 @@
+import type {
+  AuthEnvironmentListItem,
+  AuthStatusResult,
+  LocalAuthResult,
+  PairResult,
+} from "../../auth/type.ts";
+import { formatRecord, formatTable } from "./human.ts";
+
+export function formatAuthPaired(result: PairResult & { readonly name: string }) {
+  return `paired\n${formatRecord([
+    { field: "url", value: result.url },
+    { field: "name", value: result.name },
+    { field: "role", value: result.role },
+    { field: "expires", value: result.expiresAt },
+  ])}`;
+}
+
+export function formatAuthLocalHuman(result: LocalAuthResult & { readonly name: string }) {
+  return `paired\n${formatRecord([
+    { field: "url", value: result.url },
+    { field: "name", value: result.name },
+    { field: "role", value: result.role },
+    { field: "expires", value: result.expiresAt },
+    { field: "base dir", value: result.baseDir },
+  ])}`;
+}
+
+export function formatAuthLocalJson(result: LocalAuthResult & { readonly name: string }) {
+  return result;
+}
+
+export function formatAuthStatusHuman(input: AuthStatusResult) {
+  return formatRecord([
+    ...(input.config.environment !== undefined
+      ? [{ field: "environment", value: input.config.environment }]
+      : []),
+    { field: "url", value: input.config.url },
+    { field: "local", value: input.config.local ? "yes" : "no" },
+    { field: "source", value: input.config.source },
+    { field: "authenticated", value: input.session.authenticated ? "yes" : "no" },
+    ...(input.session.role !== undefined ? [{ field: "role", value: input.session.role }] : []),
+    ...(input.session.expiresAt !== undefined
+      ? [{ field: "expires", value: input.session.expiresAt }]
+      : []),
+  ]);
+}
+
+export function formatAuthStatusJson(input: AuthStatusResult) {
+  return {
+    ...input.session,
+    ...(input.config.environment !== undefined ? { environment: input.config.environment } : {}),
+    url: input.config.url,
+    source: input.config.source,
+    local: input.config.local,
+  };
+}
+
+export function formatAuthListHuman(environments: readonly AuthEnvironmentListItem[]) {
+  if (environments.length === 0) {
+    return "no environments";
+  }
+  return formatTable(
+    [
+      { header: "name", value: (environment) => environment.name, maxWidth: 24 },
+      { header: "url", value: (environment) => environment.url, maxWidth: 72 },
+      { header: "local", value: (environment) => (environment.local ? "yes" : "no"), maxWidth: 6 },
+      {
+        header: "default",
+        value: (environment) => (environment.default ? "yes" : "no"),
+        maxWidth: 7,
+      },
+      {
+        header: "active",
+        value: (environment) => (environment.active ? "yes" : "no"),
+        maxWidth: 6,
+      },
+    ],
+    environments,
+  );
+}
+
+export function formatAuthListJson(environments: readonly AuthEnvironmentListItem[]) {
+  return environments;
+}
+
+export function formatAuthUseHuman(result: { readonly name: string }) {
+  return `default environment: ${result.name}`;
+}
+
+export function formatAuthUnpairHuman(result: { readonly name: string }) {
+  return `removed environment: ${result.name}`;
+}

package/src/cli/format/human.ts

@@ -0,0 +1,131 @@
+import { Marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+import stringWidth from "string-width";
+import wrapAnsi from "wrap-ansi";
+
+type TableColumn<Row> = {
+  readonly header: string;
+  readonly value: (row: Row) => string;
+  readonly maxWidth?: number;
+};
+
+type RecordEntry = {
+  readonly field: string;
+  readonly value: string;
+};
+
+const terminalMarkdown = new Marked(
+  markedTerminal({
+    reflowText: false,
+    showSectionPrefix: true,
+    width: 100,
+  }),
+);
+
+export function formatTable<Row>(
+  columns: ReadonlyArray<TableColumn<Row>>,
+  rows: ReadonlyArray<Row>,
+) {
+  if (rows.length === 0) {
+    return "";
+  }
+
+  const widths = columns.map((column) =>
+    Math.min(
+      column.maxWidth ?? Number.POSITIVE_INFINITY,
+      Math.max(stringWidth(column.header), ...rows.map((row) => widestLine(column.value(row)))),
+    ),
+  );
+
+  const header = formatTableLine(
+    columns.map((column) => column.header),
+    widths,
+  );
+  const divider = widths.map((width) => "-".repeat(width)).join("  ");
+  const body = rows.map((row) =>
+    formatTableRow(
+      columns.map((column) => column.value(row)),
+      widths,
+    ),
+  );
+
+  return [header, divider, ...body].join("\n");
+}
+
+export function formatRecord(entries: ReadonlyArray<RecordEntry>) {
+  return formatTable(
+    [
+      { header: "field", value: (entry) => entry.field, maxWidth: 24 },
+      { header: "value", value: (entry) => entry.value, maxWidth: 96 },
+    ],
+    entries,
+  );
+}
+
+export function formatMarkdown(text: string) {
+  return terminalMarkdown
+    .parse(text, {
+      async: false,
+    })
+    .trimEnd();
+}
+
+export function formatChatTranscript(
+  messages: ReadonlyArray<{
+    readonly role: string;
+    readonly text: string;
+  }>,
+) {
+  return `${messages.map(formatChatMessage).join("\n\n")}\n`;
+}
+
+function formatChatMessage(message: { readonly role: string; readonly text: string }) {
+  const rendered = formatMarkdown(message.text);
+  return `${message.role}\n${indentBlock(rendered.length > 0 ? rendered : "(empty)")}`;
+}
+
+function formatTableRow(cells: ReadonlyArray<string>, widths: ReadonlyArray<number>) {
+  const wrappedCells = cells.map((cell, index) => wrapCell(cell, widths[index]!));
+  const height = Math.max(...wrappedCells.map((cell) => cell.length));
+  const lines: string[] = [];
+
+  for (let rowIndex = 0; rowIndex < height; rowIndex += 1) {
+    lines.push(
+      formatTableLine(
+        wrappedCells.map((cell) => cell[rowIndex] ?? ""),
+        widths,
+      ),
+    );
+  }
+
+  return lines.join("\n");
+}
+
+function formatTableLine(cells: ReadonlyArray<string>, widths: ReadonlyArray<number>) {
+  return cells.map((cell, index) => padRight(cell, widths[index]!)).join("  ");
+}
+
+function wrapCell(value: string, width: number) {
+  const lines = value
+    .split("\n")
+    .flatMap((line) =>
+      wrapAnsi(line.length > 0 ? line : " ", width, { hard: true, trim: false }).split("\n"),
+    );
+  return lines.length > 0 ? lines : [""];
+}
+
+function widestLine(value: string) {
+  return Math.max(...value.split("\n").map((line) => stringWidth(line)));
+}
+
+function padRight(value: string, width: number) {
+  const padding = width - stringWidth(value);
+  return padding > 0 ? `${value}${" ".repeat(padding)}` : value;
+}
+
+function indentBlock(value: string) {
+  return value
+    .split("\n")
+    .map((line) => `  ${line}`)
+    .join("\n");
+}

package/src/cli/format/index.ts

@@ -0,0 +1,12 @@
+export {
+  resolveOutputFormat,
+  canRenderLiveTerminal,
+  isInteractiveHumanTerminal,
+  isAgentEnvironment,
+  humanJsonFormatChoices,
+  humanNdjsonFormatChoices,
+  humanJsonNdjsonFormatChoices,
+  type HumanJsonFormat,
+  type HumanNdjsonFormat,
+  type HumanJsonNdjsonFormat,
+} from "./output.ts";