t3code-cli 0.10.0 → 0.12.0

package/src/bin.ts

@@ -1,32 +1,47 @@
 #!/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,
   VersionLive.pipe(Layer.provide(NodeServices.layer)),
 );
 
@@ -34,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") : "-";
+}

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,10 @@
 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";
 import { createThreadCommand } from "./thread.ts";
@@ -14,11 +18,15 @@ 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(),
+      createTerminalCommandGroup(),
       startThreadCommand,
       sendThreadCommand,
       showThreadCommand,