t3code-cli 0.11.0 → 0.12.0

package/src/auth/service.test.ts

@@ -0,0 +1,200 @@
+import "vite-plus/test/config";
+
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+import { assert, describe, it } from "@effect/vitest";
+
+import { T3Auth } from "./service.ts";
+import { StoredConfigV2FileJson } from "../config/persist/schema.ts";
+import { ConfigPlatformLayer } from "../config/platform.test-utils.ts";
+import { makeTempHomeScoped } from "../config/temp-home.test-utils.ts";
+import { t3AuthDepsLayer } from "./layer.test-utils.ts";
+
+describe("T3Auth persistence", () => {
+  it.effect("fails to persist a duplicate environment without allowReplace", () =>
+    Effect.gen(function* () {
+      return yield* makeTempHomeScoped("t3cli-auth-");
+    }).pipe(
+      Effect.flatMap((homeDir) =>
+        Effect.gen(function* () {
+          const auth = yield* T3Auth;
+          yield* auth.persistEnvironment({
+            name: "work",
+            url: "https://work.example",
+            token: "work-token",
+            local: false,
+            allowReplace: true,
+          });
+          const result = yield* auth
+            .persistEnvironment({
+              name: "work",
+              url: "https://work.example",
+              token: "work-token-2",
+              local: false,
+              allowReplace: false,
+            })
+            .pipe(Effect.exit);
+          assert.equal(Exit.isFailure(result), true);
+        }).pipe(Effect.provide(t3AuthDepsLayer(homeDir))),
+      ),
+      Effect.provide(ConfigPlatformLayer),
+      Effect.scoped,
+    ),
+  );
+
+  it.effect("does not change default when replace is used for a new environment", () =>
+    Effect.gen(function* () {
+      return yield* makeTempHomeScoped("t3cli-auth-");
+    }).pipe(
+      Effect.flatMap((homeDir) =>
+        Effect.gen(function* () {
+          const auth = yield* T3Auth;
+          yield* auth.persistEnvironment({
+            name: "home",
+            url: "https://home.example",
+            token: "home-token",
+            local: false,
+            allowReplace: true,
+          });
+          yield* auth.persistEnvironment({
+            name: "work",
+            url: "https://work.example",
+            token: "work-token",
+            local: false,
+            replace: true,
+            allowReplace: true,
+          });
+          const listed = yield* auth.listEnvironments();
+          assert.equal(listed.find((environment) => environment.name === "home")?.default, true);
+          assert.equal(listed.find((environment) => environment.name === "work")?.default, false);
+        }).pipe(Effect.provide(t3AuthDepsLayer(homeDir))),
+      ),
+      Effect.provide(ConfigPlatformLayer),
+      Effect.scoped,
+    ),
+  );
+
+  it.effect("promotes default when replacing an existing environment with replace", () =>
+    Effect.gen(function* () {
+      return yield* makeTempHomeScoped("t3cli-auth-");
+    }).pipe(
+      Effect.flatMap((homeDir) =>
+        Effect.gen(function* () {
+          const auth = yield* T3Auth;
+          yield* auth.persistEnvironment({
+            name: "home",
+            url: "https://home.example",
+            token: "home-token",
+            local: false,
+            allowReplace: true,
+          });
+          yield* auth.persistEnvironment({
+            name: "work",
+            url: "https://work.example",
+            token: "work-token",
+            local: false,
+            allowReplace: true,
+          });
+          yield* auth.persistEnvironment({
+            name: "work",
+            url: "https://work.example",
+            token: "work-token-2",
+            local: false,
+            replace: true,
+            allowReplace: true,
+          });
+          const listed = yield* auth.listEnvironments();
+          assert.equal(listed.find((environment) => environment.name === "work")?.default, true);
+        }).pipe(Effect.provide(t3AuthDepsLayer(homeDir))),
+      ),
+      Effect.provide(ConfigPlatformLayer),
+      Effect.scoped,
+    ),
+  );
+
+  it.effect("lists environments without decrypting tokens", () =>
+    Effect.gen(function* () {
+      return yield* makeTempHomeScoped("t3cli-auth-");
+    }).pipe(
+      Effect.flatMap((homeDir) =>
+        Effect.gen(function* () {
+          const fs = yield* FileSystem.FileSystem;
+          const path = yield* Path.Path;
+          const configPath = path.join(homeDir, ".config", "t3cli", "config.json");
+
+          yield* Effect.gen(function* () {
+            const auth = yield* T3Auth;
+            yield* auth.persistEnvironment({
+              name: "home",
+              url: "https://home.example",
+              token: "home-token",
+              local: false,
+              allowReplace: true,
+            });
+            yield* auth.persistEnvironment({
+              name: "work",
+              url: "https://work.example",
+              token: "work-token",
+              local: false,
+              allowReplace: true,
+            });
+          }).pipe(Effect.provide(t3AuthDepsLayer(homeDir)));
+
+          const raw = yield* fs.readFileString(configPath);
+          const parsed = yield* Schema.decodeUnknownEffect(StoredConfigV2FileJson)(raw);
+          const homeEnvironment = parsed.environments.home;
+          assert.isDefined(homeEnvironment);
+          const corrupted = yield* Schema.encodeEffect(StoredConfigV2FileJson)({
+            ...parsed,
+            environments: {
+              ...parsed.environments,
+              home: {
+                ...homeEnvironment,
+                token: {
+                  ...homeEnvironment.token,
+                  tag: "AAAAAAAAAAAAAAAAAAAAAA==",
+                },
+              },
+            },
+          });
+          yield* fs.writeFileString(configPath, `${corrupted}\n`, { mode: 0o600 });
+
+          yield* Effect.gen(function* () {
+            const auth = yield* T3Auth;
+            const listed = yield* auth.listEnvironments();
+            assert.equal(listed.length, 2);
+            assert.equal(listed.find((environment) => environment.name === "home")?.active, true);
+          }).pipe(Effect.provide(t3AuthDepsLayer(homeDir)));
+        }),
+      ),
+      Effect.provide(ConfigPlatformLayer),
+      Effect.scoped,
+    ),
+  );
+
+  it.effect("resolves unpair target from encrypted default metadata", () =>
+    Effect.gen(function* () {
+      return yield* makeTempHomeScoped("t3cli-auth-");
+    }).pipe(
+      Effect.flatMap((homeDir) =>
+        Effect.gen(function* () {
+          const auth = yield* T3Auth;
+          yield* auth.persistEnvironment({
+            name: "home",
+            url: "https://home.example",
+            token: "home-token",
+            local: false,
+            allowReplace: true,
+          });
+          const target = yield* auth.resolveUnpairTarget({});
+          assert.equal(target, "home");
+        }).pipe(Effect.provide(t3AuthDepsLayer(homeDir))),
+      ),
+      Effect.provide(ConfigPlatformLayer),
+      Effect.scoped,
+    ),
+  );
+});

package/src/auth/service.ts

@@ -1,9 +1,19 @@
 import * as Context from "effect/Context";
 import type * as Effect from "effect/Effect";
 
-import type { AuthSessionState, AuthWebSocketTicketResult } from "./schema.ts";
+import type { AuthWebSocketTicketResult } from "./schema.ts";
 import type { AuthError } from "./error.ts";
-import type { AuthConfigInput, LocalAuthInput, LocalAuthResult, PairResult } from "./type.ts";
+import type {
+  AuthConfigInput,
+  AuthEnvironmentListItem,
+  AuthStatusResult,
+  AuthUnpairResult,
+  AuthUseResult,
+  LocalAuthInput,
+  LocalAuthResult,
+  PairResult,
+  PersistEnvironmentInput,
+} from "./type.ts";
 
 export class T3Auth extends Context.Service<
   T3Auth,
@@ -11,7 +21,21 @@ export class T3Auth extends Context.Service<
     readonly pair: (value: string) => Effect.Effect<PairResult, AuthError>;
     readonly local: (input: LocalAuthInput) => Effect.Effect<LocalAuthResult, AuthError>;
     readonly writeConfig: (input: AuthConfigInput) => Effect.Effect<void, AuthError>;
-    readonly status: () => Effect.Effect<AuthSessionState, AuthError>;
+    readonly persistEnvironment: (
+      input: PersistEnvironmentInput,
+    ) => Effect.Effect<string, AuthError>;
+    readonly environmentExists: (name: string) => Effect.Effect<boolean, AuthError>;
+    readonly defaultNameFromUrl: (url: string) => Effect.Effect<string, AuthError>;
+    readonly defaultNameForLocal: () => Effect.Effect<string, AuthError>;
+    readonly listEnvironments: () => Effect.Effect<readonly AuthEnvironmentListItem[], AuthError>;
+    readonly useEnvironment: (name: string) => Effect.Effect<AuthUseResult, AuthError>;
+    readonly unpairEnvironment: (input: {
+      readonly name: string;
+    }) => Effect.Effect<AuthUnpairResult, AuthError>;
+    readonly resolveUnpairTarget: (input: {
+      readonly name?: string;
+    }) => Effect.Effect<string, AuthError>;
+    readonly status: () => Effect.Effect<AuthStatusResult, AuthError>;
     readonly issueWebSocketTicket: () => Effect.Effect<AuthWebSocketTicketResult, AuthError>;
   }
 >()("t3cli/T3Auth") {}

package/src/auth/transport.ts

@@ -2,14 +2,14 @@ import {
   AuthAccessTokenType,
   AuthEnvironmentBootstrapTokenType,
   AuthTokenExchangeGrantType,
-} from "#t3tools/contracts";
+} from "@t3tools/contracts";
 import * as Context from "effect/Context";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import { HttpClient, HttpClientError, HttpClientRequest } from "effect/unstable/http";
 
-import { toHttpEndpointUrl } from "../config/url.ts";
+import { toHttpEndpointUrl } from "../config/url/url.ts";
 import { AuthTransportError } from "./error.ts";
 import {
   type AuthBearerBootstrapResult,

package/src/auth/type.ts

@@ -1,4 +1,5 @@
 import type { AuthBearerBootstrapResult } from "./schema.ts";
+import type { AuthSessionState } from "./schema.ts";
 
 export type AuthSessionRole = AuthBearerBootstrapResult["role"];
 
@@ -8,9 +9,44 @@ export type PairingUrl = {
 };
 
 export type AuthConfigInput = {
+  readonly name: string;
   readonly url: string;
   readonly token: string;
-  readonly local?: boolean;
+  readonly local: boolean;
+  readonly makeDefault?: boolean;
+};
+
+export type PersistEnvironmentInput = {
+  readonly name: string;
+  readonly url: string;
+  readonly token: string;
+  readonly local: boolean;
+  readonly replace?: boolean;
+  readonly allowReplace: boolean;
+};
+
+export type AuthResolvedConfig = {
+  readonly url: string;
+  readonly token: string;
+  readonly source: "env" | "config";
+  readonly local: boolean;
+  readonly environment?: string;
+};
+
+export type AuthEnvironmentSummary = {
+  readonly name: string;
+  readonly url: string;
+  readonly local: boolean;
+  readonly default: boolean;
+};
+
+export type AuthStatusResult = {
+  readonly config: AuthResolvedConfig;
+  readonly session: AuthSessionState;
+};
+
+export type AuthEnvironmentListItem = AuthEnvironmentSummary & {
+  readonly active: boolean;
 };
 
 export type PairResult = {
@@ -51,3 +87,13 @@ export type LocalAuthResult = {
   readonly source: "local";
   readonly baseDir: string;
 };
+
+export type AuthUseResult = {
+  readonly name: string;
+  readonly default: true;
+};
+
+export type AuthUnpairResult = {
+  readonly name: string;
+  readonly removed: true;
+};

package/src/bin.ts

@@ -1,31 +1,44 @@
 #!/usr/bin/env node
+import { homedir } from "node:os";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import { Command } from "effect/unstable/cli";
-
 import { createCliCommand } from "./cli/app.ts";
-import { NodeEnvironmentLive } from "./environment/layer.ts";
+import * as CliSelection from "./cli/env/selection-layer.ts";
+import * as CliRuntime from "./cli/runtime/service.ts";
+import * as CredentialCipherNode from "./config/credential/cipher-node.ts";
+import * as KeystoreKeyringNode from "./config/keystore/keyring-node.ts";
 import { T3InputLive } from "./cli/input/layer.ts";
 import { T3OutputLive } from "./cli/output/layer.ts";
 import { NodeTerminalIoLive } from "./cli/terminal/io-node-layer.ts";
 import { T3Output } from "./cli/output/service.ts";
-import { AppLayer } from "./runtime/layer.ts";
+import { BaseAppLayer } from "./runtime/layer.ts";
 import { T3VersionBundledLive, T3VersionPackageJsonLive } from "./version/layer.ts";
 import { T3Version } from "./version/service.ts";
 
 declare const T3CLI_VERSION: string | undefined;
 
+if (process.env.HOME === undefined || process.env.HOME.trim().length === 0) {
+  process.env.HOME = homedir();
+}
+
 const VersionLive =
   typeof T3CLI_VERSION === "string" ? T3VersionBundledLive : T3VersionPackageJsonLive;
 
-const PlatformLayer = Layer.mergeAll(NodeServices.layer, NodeEnvironmentLive);
+const PlatformLayer = Layer.mergeAll(NodeServices.layer, CliRuntime.layer);
+
+const CliAppLayer = BaseAppLayer.pipe(
+  Layer.provideMerge(CliSelection.layer),
+  Layer.provide(CredentialCipherNode.layerNode),
+  Layer.provide(KeystoreKeyringNode.layerNode),
+);
 
 const CliLayer = Layer.mergeAll(
-  AppLayer.pipe(Layer.provide(PlatformLayer)),
+  CliAppLayer.pipe(Layer.provide(PlatformLayer)),
   NodeServices.layer,
-  NodeEnvironmentLive,
+  CliRuntime.layer,
   T3InputLive.pipe(Layer.provide(NodeServices.layer)),
   T3OutputLive.pipe(Layer.provide(NodeServices.layer)),
   NodeTerminalIoLive,
@@ -36,6 +49,11 @@ const program = Effect.gen(function* () {
   const version = yield* T3Version;
   return yield* Command.run(createCliCommand(), { version: version.version });
 }).pipe(
+  Effect.catchTag("ShowHelp", (error) =>
+    Effect.sync(() => {
+      process.exitCode = error.errors.length > 0 ? 1 : 0;
+    }),
+  ),
   Effect.tapError((error) =>
     Effect.gen(function* () {
       const output = yield* T3Output;

package/src/cli/action-format.ts

@@ -0,0 +1,110 @@
+import type {
+  OrchestrationProjectShell,
+  ProjectScript,
+  TerminalSessionSnapshot,
+} from "@t3tools/contracts";
+
+import { formatRecord, formatTable } from "./format/human.ts";
+
+type ActionRow = {
+  readonly name: string;
+  readonly id: string;
+  readonly command: string;
+  readonly icon: string;
+  readonly setup: string;
+  readonly preview: string;
+};
+
+export function formatActionListHuman(input: {
+  readonly project: OrchestrationProjectShell;
+  readonly actions: ReadonlyArray<ProjectScript>;
+}) {
+  if (input.actions.length === 0) {
+    return `no actions for ${input.project.title} (${input.project.id})\n`;
+  }
+  return `${formatActionTable(input.actions.map(toActionRow))}\n`;
+}
+
+export function formatActionAddedHuman(input: {
+  readonly project: OrchestrationProjectShell;
+  readonly action: ProjectScript;
+  readonly sequence: number;
+}) {
+  return `action added\n${formatActionRecord(input)}`;
+}
+
+export function formatActionUpdatedHuman(input: {
+  readonly project: OrchestrationProjectShell;
+  readonly action: ProjectScript;
+  readonly sequence: number;
+}) {
+  return `action updated\n${formatActionRecord(input)}`;
+}
+
+export function formatActionDeletedHuman(input: {
+  readonly project: OrchestrationProjectShell;
+  readonly action: ProjectScript;
+  readonly sequence: number;
+}) {
+  return `action deleted\n${formatActionRecord(input)}`;
+}
+
+export function formatActionRunHuman(input: {
+  readonly project: OrchestrationProjectShell;
+  readonly action: ProjectScript;
+  readonly terminal: TerminalSessionSnapshot;
+}) {
+  return `action running\n${formatRecord([
+    { field: "name", value: input.action.name },
+    { field: "id", value: input.action.id },
+    { field: "project", value: input.project.id },
+    { field: "terminal", value: input.terminal.terminalId },
+    { field: "cwd", value: input.terminal.cwd },
+  ])}`;
+}
+
+function formatActionTable(rows: ReadonlyArray<ActionRow>) {
+  return formatTable(
+    [
+      { header: "name", value: (row) => row.name, maxWidth: 28 },
+      { header: "id", value: (row) => row.id, maxWidth: 24 },
+      { header: "command", value: (row) => row.command, maxWidth: 48 },
+      { header: "icon", value: (row) => row.icon, maxWidth: 10 },
+      { header: "setup", value: (row) => row.setup, maxWidth: 5 },
+      { header: "preview", value: (row) => row.preview, maxWidth: 48 },
+    ],
+    rows,
+  );
+}
+
+function formatActionRecord(input: {
+  readonly project: OrchestrationProjectShell;
+  readonly action: ProjectScript;
+  readonly sequence: number;
+}) {
+  return formatRecord([
+    { field: "name", value: input.action.name },
+    { field: "id", value: input.action.id },
+    { field: "project", value: input.project.id },
+    { field: "sequence", value: String(input.sequence) },
+  ]);
+}
+
+function toActionRow(action: ProjectScript): ActionRow {
+  return {
+    name: action.name,
+    id: action.id,
+    command: action.command,
+    icon: action.icon,
+    setup: action.runOnWorktreeCreate ? "yes" : "no",
+    preview: formatActionPreview(action),
+  };
+}
+
+function formatActionPreview(action: ProjectScript) {
+  const parts = [
+    action.previewUrl ?? null,
+    action.autoOpenPreview === true ? "auto open" : null,
+  ].filter((part): part is string => part !== null);
+  return parts.length > 0 ? parts.join("\n") : "-";
+}