t3code-cli 0.11.0 → 0.12.0

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

package/src/cli/format/model.ts

@@ -0,0 +1,29 @@
+import type { ServerProvider } from "@t3tools/contracts";
+
+import { formatTable } from "./human.ts";
+
+export function formatModelsHuman(providers: ReadonlyArray<ServerProvider>) {
+  if (providers.length === 0) {
+    return "no models found\n";
+  }
+  return providers
+    .map((provider) => {
+      const models = provider.models;
+      const displayName = provider.displayName ?? provider.instanceId;
+      const header = `${displayName} (${provider.instanceId}) - ${provider.status}`;
+      if (models.length === 0) {
+        return `${header}\n  no models`;
+      }
+      return `${header}\n${formatTable(
+        [
+          { header: "slug", value: (model) => model.slug, maxWidth: 40 },
+          { header: "name", value: (model) => model.name, maxWidth: 48 },
+          { header: "custom", value: (model) => (model.isCustom ? "yes" : "no"), maxWidth: 6 },
+          { header: "sub-provider", value: (model) => model.subProvider ?? "-", maxWidth: 24 },
+        ],
+        models,
+      )}`;
+    })
+    .join("\n\n")
+    .concat("\n");
+}

package/src/cli/format/output.ts

@@ -0,0 +1,51 @@
+import * as Option from "effect/Option";
+
+import type { T3CliEnvShape } from "../../config/env/env.ts";
+import type { CliRuntime } from "../runtime/service.ts";
+
+export const humanJsonFormatChoices = ["auto", "human", "json"] as const;
+export const humanNdjsonFormatChoices = ["auto", "human", "ndjson"] as const;
+export const humanJsonNdjsonFormatChoices = ["auto", "human", "json", "ndjson"] as const;
+
+export type HumanJsonFormat = (typeof humanJsonFormatChoices)[number];
+export type HumanNdjsonFormat = (typeof humanNdjsonFormatChoices)[number];
+export type HumanJsonNdjsonFormat = (typeof humanJsonNdjsonFormatChoices)[number];
+
+export function resolveOutputFormat<T extends "json" | "ndjson">(
+  format: "auto" | "human" | T,
+  cliRuntime: CliRuntime["Service"],
+  t3CliEnv: T3CliEnvShape,
+  nonHumanFormat: T,
+): "human" | T {
+  if (format !== "auto") {
+    return format;
+  }
+  return isHumanTerminal(cliRuntime, t3CliEnv) ? "human" : nonHumanFormat;
+}
+
+export function canRenderLiveTerminal(cliRuntime: CliRuntime["Service"], t3CliEnv: T3CliEnvShape) {
+  return (
+    cliRuntime.stderrIsTTY &&
+    Option.getOrElse(t3CliEnv.term, () => "") !== "dumb" &&
+    !isAgentEnvironment(t3CliEnv)
+  );
+}
+
+export function isInteractiveHumanTerminal(
+  cliRuntime: CliRuntime["Service"],
+  t3CliEnv: T3CliEnvShape,
+) {
+  return (
+    cliRuntime.stdoutIsTTY &&
+    !isAgentEnvironment(t3CliEnv) &&
+    Option.getOrElse(t3CliEnv.term, () => "") !== "dumb"
+  );
+}
+
+function isHumanTerminal(cliRuntime: CliRuntime["Service"], t3CliEnv: T3CliEnvShape) {
+  return isInteractiveHumanTerminal(cliRuntime, t3CliEnv);
+}
+
+export function isAgentEnvironment(t3CliEnv: T3CliEnvShape) {
+  return t3CliEnv.ci || t3CliEnv.codexCi || t3CliEnv.codexThreadId || t3CliEnv.t3cliAgent;
+}

package/src/cli/format/project.ts

@@ -0,0 +1,32 @@
+import type { OrchestrationProjectShell } from "@t3tools/contracts";
+
+import { formatRecord, formatTable } from "./human.ts";
+
+export function formatProjectsHuman(projects: ReadonlyArray<OrchestrationProjectShell>) {
+  if (projects.length === 0) {
+    return "no projects\n";
+  }
+  return `${formatTable(
+    [
+      { header: "title", value: (project) => project.title, maxWidth: 32 },
+      { header: "id", value: (project) => project.id, maxWidth: 40 },
+      { header: "path", value: (project) => project.workspaceRoot, maxWidth: 72 },
+    ],
+    projects,
+  )}\n`;
+}
+
+export function formatProjectAddedHuman(project: OrchestrationProjectShell) {
+  return `project added\n${formatRecord([
+    { field: "title", value: project.title },
+    { field: "id", value: project.id },
+    { field: "path", value: project.workspaceRoot },
+  ])}`;
+}
+
+export function formatProjectDeletedHuman(input: {
+  readonly projectId: string;
+  readonly dispatch: { readonly sequence: number };
+}) {
+  return `project deleted: ${input.projectId} (sequence ${input.dispatch.sequence})`;
+}

package/src/cli/format/terminal.ts

@@ -0,0 +1,87 @@
+import type { TerminalSessionSnapshot, TerminalSummary } from "@t3tools/contracts";
+
+import { formatTable } from "./human.ts";
+
+type TerminalRow = {
+  readonly id: string;
+  readonly status: string;
+  readonly label: string;
+  readonly cwd: string;
+  readonly updated: string;
+  readonly process: string;
+};
+
+export function formatTerminalListHuman(terminals: ReadonlyArray<TerminalSummary>) {
+  if (terminals.length === 0) {
+    return "no terminals\n";
+  }
+  return `${formatTerminalTable(terminals.map(toSummaryRow))}\n`;
+}
+
+export function formatTerminalCreatedHuman(snapshot: TerminalSessionSnapshot) {
+  return `terminal created\n${formatTerminalTable([toSnapshotRow(snapshot)])}`;
+}
+
+export function formatTerminalWrittenHuman(input: {
+  readonly terminalId: string;
+  readonly threadId: string;
+  readonly bytes: number;
+}) {
+  return `wrote ${input.bytes} bytes to ${input.terminalId} (${input.threadId})`;
+}
+
+export function formatTerminalDestroyedHuman(input: {
+  readonly terminalId: string;
+  readonly threadId: string;
+}) {
+  return `destroyed ${input.terminalId} (${input.threadId})`;
+}
+
+function formatTerminalTable(rows: ReadonlyArray<TerminalRow>) {
+  return formatTable(
+    [
+      { header: "id", value: (row) => row.id, maxWidth: 44 },
+      { header: "status", value: (row) => row.status, maxWidth: 8 },
+      { header: "label", value: (row) => row.label, maxWidth: 24 },
+      { header: "cwd", value: (row) => row.cwd, maxWidth: 40 },
+      { header: "updated", value: (row) => row.updated, maxWidth: 24 },
+      { header: "process", value: (row) => row.process, maxWidth: 20 },
+    ],
+    rows,
+  );
+}
+
+function toSummaryRow(terminal: TerminalSummary): TerminalRow {
+  return {
+    id: terminal.terminalId,
+    status: terminal.status,
+    label: terminal.label,
+    cwd: terminal.cwd,
+    updated: terminal.updatedAt,
+    process: formatProcessInfo(terminal),
+  };
+}
+
+function toSnapshotRow(snapshot: TerminalSessionSnapshot): TerminalRow {
+  return {
+    id: snapshot.terminalId,
+    status: snapshot.status,
+    label: snapshot.label,
+    cwd: snapshot.cwd,
+    updated: snapshot.updatedAt,
+    process: formatProcessInfo(snapshot),
+  };
+}
+
+function formatProcessInfo(input: {
+  readonly pid: number | null;
+  readonly exitCode: number | null;
+  readonly exitSignal: number | null;
+}) {
+  const parts = [
+    typeof input.pid === "number" ? `pid ${input.pid}` : null,
+    typeof input.exitCode === "number" ? `exit ${input.exitCode}` : null,
+    typeof input.exitSignal === "number" ? `sig ${input.exitSignal}` : null,
+  ].filter((part): part is string => part !== null);
+  return parts.length > 0 ? parts.join(", ") : "-";
+}

package/src/cli/{thread-format.test.ts → format/thread.test.ts}

@@ -2,9 +2,9 @@ import "vite-plus/test/config";
 
 import { assert, describe, it } from "@effect/vitest";
 import { fromPartial } from "@total-typescript/shoehorn";
-import type { OrchestrationThreadShell } from "#t3tools/contracts";
+import type { OrchestrationThreadShell } from "@t3tools/contracts";
 
-import { formatThreadsHuman } from "./thread-format.ts";
+import { formatThreadsHuman } from "./thread.ts";
 
 describe("formatThreadsHuman", () => {
   it("appends (archived) for archived threads", () => {
@@ -26,7 +26,9 @@ describe("formatThreadsHuman", () => {
     ];
 
     const output = formatThreadsHuman(threads);
-    assert.include(output, "- Active thread\n");
-    assert.include(output, "- Archived thread (archived)\n");
+    assert.include(output, "title            id          status   updated                   flags");
+    assert.include(output, "Active thread    active-1");
+    assert.include(output, "Archived thread  archived-1");
+    assert.include(output, "archived");
   });
 });