t3code-cli 0.11.0 → 0.13.0

package/src/application/service.ts

@@ -9,13 +9,15 @@ import type {
   OrchestrationShellSnapshot,
   OrchestrationThread,
   OrchestrationThreadShell,
+  ProjectScript,
+  ProjectScriptIcon,
   ProviderUserInputAnswers,
   ServerProvider,
   TerminalAttachStreamEvent,
   TerminalMetadataStreamEvent,
   TerminalSessionSnapshot,
   TerminalSummary,
-} from "#t3tools/contracts";
+} from "@t3tools/contracts";
 
 import type { ApplicationError } from "./error.ts";
 import type { ThreadShow } from "./threads.ts";
@@ -34,6 +36,7 @@ export type CreateTerminalInput = {
   readonly threadId: string;
   readonly terminalId?: string;
   readonly command?: string;
+  readonly env?: Readonly<Record<string, string>>;
 };
 
 export type TerminalRef = {
@@ -80,6 +83,80 @@ export type WaitEvent =
   | { readonly type: "status"; readonly status: string; readonly threadId: string }
   | { readonly type: "done"; readonly thread: OrchestrationThread };
 
+export type ProjectActionSelector =
+  | { readonly id: string; readonly name?: never }
+  | { readonly id?: never; readonly name: string };
+
+export type AddProjectActionInput = {
+  readonly projectRef: string;
+  readonly id?: string;
+  readonly name: string;
+  readonly command: string;
+  readonly icon?: ProjectScriptIcon;
+  readonly setup?: boolean;
+  readonly previewUrl?: string;
+  readonly autoOpenPreview?: boolean;
+};
+
+export type UpdateProjectActionInput = {
+  readonly projectRef: string;
+  readonly selector: ProjectActionSelector;
+  readonly name?: string;
+  readonly command?: string;
+  readonly icon?: ProjectScriptIcon;
+  readonly setup?: boolean;
+  readonly previewUrl?: string | null;
+  readonly autoOpenPreview?: boolean | null;
+};
+
+export type ProjectActionMutationResult = {
+  readonly dispatch: DispatchResult;
+  readonly project: OrchestrationProjectShell;
+  readonly action: ProjectScript;
+};
+
+export type ProjectActionDeleteResult = {
+  readonly dispatch: DispatchResult;
+  readonly project: OrchestrationProjectShell;
+  readonly action: ProjectScript;
+};
+
+export type ProjectActionRunResult = {
+  readonly project: OrchestrationProjectShell;
+  readonly action: ProjectScript;
+  readonly terminal: TerminalSessionSnapshot;
+};
+
+export type T3ActionApplicationService = {
+  readonly listActions: (projectRef: string) => Effect.Effect<
+    {
+      readonly project: OrchestrationProjectShell;
+      readonly actions: ReadonlyArray<ProjectScript>;
+    },
+    ApplicationError
+  >;
+  readonly addAction: (
+    input: AddProjectActionInput,
+  ) => Effect.Effect<ProjectActionMutationResult, ApplicationError>;
+  readonly updateAction: (
+    input: UpdateProjectActionInput,
+  ) => Effect.Effect<ProjectActionMutationResult, ApplicationError>;
+  readonly deleteAction: (input: {
+    readonly projectRef: string;
+    readonly selector: ProjectActionSelector;
+  }) => Effect.Effect<ProjectActionDeleteResult, ApplicationError>;
+  readonly runAction: (input: {
+    readonly threadId: string;
+    readonly selector: ProjectActionSelector;
+    readonly terminalId?: string;
+  }) => Effect.Effect<ProjectActionRunResult, ApplicationError>;
+};
+
+export class T3ActionApplication extends Context.Service<
+  T3ActionApplication,
+  T3ActionApplicationService
+>()("t3cli/T3ActionApplication") {}
+
 export type T3ModelApplicationService = {
   readonly listModels: (input: {
     readonly all?: boolean;
@@ -239,6 +316,7 @@ export class T3TerminalApplication extends Context.Service<
 >()("t3cli/T3TerminalApplication") {}
 
 export type T3ApplicationService = T3ModelApplicationService &
+  T3ActionApplicationService &
   T3ProjectApplicationService &
   T3ThreadApplicationService &
   T3TerminalApplicationService;

package/src/application/shell-sequence.ts

@@ -1,7 +1,7 @@
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Stream from "effect/Stream";
-import { ORCHESTRATION_WS_METHODS } from "#t3tools/contracts";
+import { ORCHESTRATION_WS_METHODS } from "@t3tools/contracts";
 
 import { T3Orchestration } from "../orchestration/service.ts";
 import { RpcError } from "../rpc/error.ts";

package/src/application/terminals.ts

@@ -2,7 +2,7 @@ import * as Crypto from "effect/Crypto";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Stream from "effect/Stream";
-import { WS_METHODS, type TerminalSummary } from "#t3tools/contracts";
+import { WS_METHODS, type TerminalSummary } from "@t3tools/contracts";
 
 import { ProjectLookupError, TerminalLookupError, ThreadLookupError } from "../domain/error.ts";
 import { findProjectById } from "../domain/helpers.ts";
@@ -124,6 +124,7 @@ export const makeTerminalApplication = Effect.fn("makeTerminalApplication")(func
         terminalId,
         cwd,
         worktreePath: thread.worktreePath ?? null,
+        ...(input.env !== undefined ? { env: input.env } : {}),
       }),
     );
 

package/src/application/thread-commands.ts

@@ -12,7 +12,7 @@ import {
   type OrchestrationProjectShell,
   type ProviderApprovalDecision,
   type ProviderUserInputAnswers,
-} from "#t3tools/contracts";
+} from "@t3tools/contracts";
 import type { ServerConfigForCli } from "../orchestration/service.ts";
 import { resolveModelSelection } from "./model-selection.ts";
 import type { SendThreadInput, StartThreadInput } from "./service.ts";

package/src/application/thread-update.ts

@@ -1,6 +1,6 @@
 import * as Crypto from "effect/Crypto";
 import * as Effect from "effect/Effect";
-import type { ModelSelection } from "#t3tools/contracts";
+import type { ModelSelection } from "@t3tools/contracts";
 
 import { ModelSelectionError, ThreadEventError } from "../domain/error.ts";
 import { T3Orchestration } from "../orchestration/service.ts";

package/src/application/thread-wait.ts

@@ -1,7 +1,7 @@
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Stream from "effect/Stream";
-import type { OrchestrationMessage, OrchestrationThread } from "#t3tools/contracts";
+import type { OrchestrationMessage, OrchestrationThread } from "@t3tools/contracts";
 
 import { ThreadSessionError } from "../domain/error.ts";
 import { T3Orchestration } from "../orchestration/service.ts";
@@ -42,6 +42,10 @@ export function watchThread(input: { readonly threadId: string }) {
               return Stream.fromIterable(events);
             }
 
+            if (item.kind === "synchronized") {
+              return Stream.empty;
+            }
+
             if (current === undefined || currentMessages === undefined) {
               return Stream.fail(
                 new ThreadSessionError({

package/src/application/threads.test.ts

@@ -10,9 +10,10 @@ import type {
   OrchestrationShellSnapshot,
   OrchestrationThread,
   OrchestrationThreadShell,
-} from "#t3tools/contracts";
+} from "@t3tools/contracts";
 
-import { NodeEnvironmentLive } from "../environment/layer.ts";
+import * as CliRuntime from "../cli/runtime/service.ts";
+import { t3CliEnvConfigLayer } from "../config/env/env.test-utils.ts";
 import { T3Orchestration, type Orchestration } from "../orchestration/service.ts";
 import { makeThreadApplication } from "./threads.ts";
 
@@ -58,7 +59,12 @@ function makeOrchestrationLayer(input: {
 }
 
 const testLayer = (orchestration: Layer.Layer<T3Orchestration>) =>
-  Layer.mergeAll(orchestration, NodeServices.layer, NodeEnvironmentLive);
+  Layer.mergeAll(
+    orchestration,
+    NodeServices.layer,
+    CliRuntime.layer,
+    t3CliEnvConfigLayer("/tmp/t3cli-test"),
+  );
 
 describe("interruptThread", () => {
   it.layer(NodeServices.layer)("interruptThread", (t) => {

package/src/application/threads.ts

@@ -2,14 +2,14 @@ import * as Crypto from "effect/Crypto";
 import * as Effect from "effect/Effect";
 import * as Path from "effect/Path";
 import * as Stream from "effect/Stream";
-import { Environment } from "../environment/service.ts";
+import { CliRuntime } from "../cli/runtime/service.ts";
 import { T3Orchestration } from "../orchestration/service.ts";
 import { ProjectLookupError, ThreadLookupError, ThreadSessionError } from "../domain/error.ts";
 import { resolveProjectScope } from "../domain/helpers.ts";
 import { type ListThreadsInclude, type StartThreadInput } from "./service.ts";
 import type { CallbackThreadInput, SendThreadInput } from "./service.ts";
 import type { T3ThreadApplicationService } from "./service.ts";
-import type { OrchestrationThreadShell } from "#t3tools/contracts";
+import type { OrchestrationThreadShell } from "@t3tools/contracts";
 import { mergeModelOptions } from "./model-selection.ts";
 import { derivePendingApprovals, derivePendingUserInputs } from "../domain/thread-activities.ts";
 import {
@@ -17,8 +17,8 @@ import {
   threadStatus,
   type ThreadLifecycleStatus,
 } from "../domain/thread-lifecycle.ts";
-import type { OrchestrationThread } from "#t3tools/contracts";
-import type { ProviderApprovalDecision, ProviderUserInputAnswers } from "#t3tools/contracts";
+import type { OrchestrationThread } from "@t3tools/contracts";
+import type { ProviderApprovalDecision, ProviderUserInputAnswers } from "@t3tools/contracts";
 import {
   makeThreadApprovalRespondCommand,
   makeThreadArchiveCommand,
@@ -41,7 +41,7 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
   const orchestration = yield* T3Orchestration;
   const crypto = yield* Crypto.Crypto;
   const path = yield* Path.Path;
-  const environment = yield* Environment;
+  const cliRuntime = yield* CliRuntime;
   const awaitShellSequence = (sequence: number) =>
     waitForShellSequence({ sequence }).pipe(Effect.provideService(T3Orchestration, orchestration));
   const awaitThreadCompletion = (threadId: string) =>
@@ -149,7 +149,7 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
       return yield* Effect.fail(
         new ProjectLookupError({
           message: "project is required",
-          ref: environment.cwd,
+          ref: cliRuntime.cwd,
         }),
       );
     }

package/src/auth/error.ts

@@ -1,9 +1,10 @@
 import * as Cause from "effect/Cause";
 import * as Schema from "effect/Schema";
 import { PlatformError } from "effect/PlatformError";
-import { HttpClientError } from "effect/unstable/http";
 
-import { ConfigError, UrlError } from "../config/error.ts";
+import { ConfigError } from "../config/error.ts";
+import { UrlError } from "../config/url/error.ts";
+import { RemoteEnvironmentAuthErrorSchema } from "./remote-error.ts";
 
 export class AuthPairingUrlError extends Schema.TaggedErrorClass<AuthPairingUrlError>()(
   "AuthPairingUrlError",
@@ -22,13 +23,7 @@ export class AuthTransportError extends Schema.TaggedErrorClass<AuthTransportErr
   "AuthTransportError",
   {
     message: Schema.String,
-    cause: Schema.optionalKey(
-      Schema.Union([
-        HttpClientError.HttpClientErrorSchema,
-        Schema.instanceOf(Schema.SchemaError),
-        UrlError,
-      ]),
-    ),
+    cause: RemoteEnvironmentAuthErrorSchema,
   },
 ) {}
 

package/src/auth/index.ts

@@ -17,7 +17,13 @@ export type { AuthError } from "./error.ts";
 export type { AuthSessionState, AuthWebSocketTicketResult } from "./schema.ts";
 export type {
   AuthConfigInput,
+  AuthEnvironmentListItem,
+  AuthEnvironmentSummary,
+  AuthResolvedConfig,
   AuthSessionRole,
+  AuthStatusResult,
+  AuthUnpairResult,
+  AuthUseResult,
   LocalAuthInput,
   LocalAuthOriginInput,
   LocalAuthResult,
@@ -25,4 +31,5 @@ export type {
   LocalAuthTokenResult,
   PairingUrl,
   PairResult,
+  PersistEnvironmentInput,
 } from "./type.ts";

package/src/auth/layer.test-utils.ts

@@ -0,0 +1,34 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+import { T3AuthLive } from "./layer.ts";
+import { T3LocalAuth } from "./local.ts";
+import { T3AuthPairing } from "./pairing.ts";
+import { T3AuthTransport } from "./transport.ts";
+import { t3ConfigDepsLayer } from "../config/layer.test-utils.ts";
+import { ConfigPlatformLayer } from "../config/platform.test-utils.ts";
+
+export function t3AuthDepsLayer(homeDir: string) {
+  return T3AuthLive.pipe(
+    Layer.provide(
+      Layer.mergeAll(
+        t3ConfigDepsLayer(homeDir),
+        Layer.succeed(T3AuthTransport)({
+          bootstrapBearer: () => Effect.die("unused in test"),
+          getSession: () => Effect.succeed({ authenticated: false }),
+          issueWebSocketTicket: () => Effect.die("unused in test"),
+        }),
+        Layer.succeed(T3LocalAuth)({
+          local: () => Effect.die("unused in test"),
+        }),
+        Layer.succeed(T3AuthPairing)({
+          pair: () => Effect.die("unused in test"),
+        }),
+      ),
+    ),
+  );
+}
+
+export function t3AuthLayerTest(homeDir: string) {
+  return Layer.mergeAll(ConfigPlatformLayer, t3AuthDepsLayer(homeDir));
+}

package/src/auth/layer.ts

@@ -1,13 +1,23 @@
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 
-import { T3Config } from "../config/service.ts";
+import {
+  defaultEnvironmentNameForLocal,
+  defaultEnvironmentNameFromUrl,
+} from "../config/environment-name/name.ts";
+import type { EnvironmentSummary, ResolvedConfig } from "../config/types.ts";
+import type { ConfigError } from "../config/error.ts";
+import type { UrlError } from "../config/url/error.ts";
+import { T3Config } from "../config/config.ts";
 import { AuthConfigError } from "./error.ts";
 import { T3LocalAuth } from "./local.ts";
 import { T3AuthPairing } from "./pairing.ts";
 import { T3Auth } from "./service.ts";
 import { T3AuthTransport } from "./transport.ts";
-import type { AuthConfigInput } from "./type.ts";
+import type { AuthConfigInput, AuthEnvironmentListItem, AuthResolvedConfig } from "./type.ts";
+
+const mapConfigError = (error: ConfigError | UrlError) =>
+  new AuthConfigError({ message: error.message, cause: error });
 
 export const makeT3Auth = Effect.fn("makeT3Auth")(function* () {
   const config = yield* T3Config;
@@ -16,58 +26,130 @@ export const makeT3Auth = Effect.fn("makeT3Auth")(function* () {
   const pairing = yield* T3AuthPairing;
 
   const status = Effect.fn("T3AuthLive.status")(function* () {
-    const resolved = yield* config.resolve().pipe(
-      Effect.catchTags({
-        ConfigError: (error) =>
-          Effect.fail(new AuthConfigError({ message: "auth config failed", cause: error })),
-        UrlError: (error) =>
-          Effect.fail(new AuthConfigError({ message: "auth config failed", cause: error })),
-      }),
-    );
-    return yield* transport.getSession(resolved);
+    const resolved = yield* config.resolve().pipe(Effect.mapError(mapConfigError));
+    const session = yield* transport.getSession(resolved);
+    return { config: toAuthResolvedConfig(resolved), session } as const;
   });
 
   const issueWebSocketTicket = Effect.fn("T3AuthLive.issueWebSocketTicket")(function* () {
-    const resolved = yield* config.resolve().pipe(
-      Effect.catchTags({
-        ConfigError: (error) =>
-          Effect.fail(new AuthConfigError({ message: "auth config failed", cause: error })),
-        UrlError: (error) =>
-          Effect.fail(new AuthConfigError({ message: "auth config failed", cause: error })),
-      }),
-    );
+    const resolved = yield* config.resolve().pipe(Effect.mapError(mapConfigError));
     return yield* transport.issueWebSocketTicket(resolved);
   });
 
-  const writeConfig = Effect.fn("T3AuthLive.writeConfig")(function* (input: AuthConfigInput) {
-    const existing = yield* config.readStored().pipe(
-      Effect.catchTags({
-        ConfigError: (error) =>
-          Effect.fail(new AuthConfigError({ message: "auth config failed", cause: error })),
-      }),
-    );
+  const persistEnvironment = Effect.fn("T3AuthLive.persistEnvironment")(function* (input: {
+    readonly name: string;
+    readonly url: string;
+    readonly token: string;
+    readonly local: boolean;
+    readonly replace?: boolean;
+    readonly allowReplace: boolean;
+  }) {
+    const exists = yield* config.hasEnvironment(input.name).pipe(Effect.mapError(mapConfigError));
+    if (exists && !input.allowReplace) {
+      return yield* Effect.fail(
+        new AuthConfigError({
+          message: `environment '${input.name}' already exists: pass --replace`,
+        }),
+      );
+    }
+    const makeDefault = exists && input.replace === true;
     yield* config
-      .writeStored({
-        ...existing,
+      .upsertEnvironment({
+        name: input.name,
         url: input.url,
         token: input.token,
-        ...(input.local !== undefined ? { local: input.local } : {}),
+        local: input.local,
+        ...(makeDefault ? { makeDefault: true } : {}),
       })
-      .pipe(
-        Effect.catchTags({
-          ConfigError: (error) =>
-            Effect.fail(new AuthConfigError({ message: "auth config failed", cause: error })),
+      .pipe(Effect.mapError(mapConfigError));
+    return input.name;
+  });
+
+  const listEnvironments = Effect.fn("T3AuthLive.listEnvironments")(function* () {
+    const [environments, activeName] = yield* Effect.all(
+      [config.listEnvironments(), config.resolveActiveEnvironmentName()],
+      { concurrency: "unbounded" },
+    ).pipe(Effect.mapError(mapConfigError));
+    return environments.map((environment) => toAuthEnvironmentListItem(environment, activeName));
+  });
+
+  const resolveUnpairTarget = Effect.fn("T3AuthLive.resolveUnpairTarget")(function* (input: {
+    readonly name?: string;
+  }) {
+    if (input.name !== undefined && input.name.length > 0) {
+      return input.name;
+    }
+    const defaultName = yield* config
+      .getDefaultEnvironmentName()
+      .pipe(Effect.mapError(mapConfigError));
+    if (defaultName === undefined) {
+      return yield* Effect.fail(
+        new AuthConfigError({
+          message: "no environment selected: pass --name or run: t3cli env use <name>",
         }),
       );
+    }
+    return defaultName;
   });
 
   return {
     pair: pairing.pair,
     local: localAuth.local,
-    writeConfig,
+    writeConfig: (input: AuthConfigInput) =>
+      config
+        .upsertEnvironment({
+          name: input.name,
+          url: input.url,
+          token: input.token,
+          local: input.local,
+          ...(input.makeDefault === true ? { makeDefault: true } : {}),
+        })
+        .pipe(Effect.mapError(mapConfigError)),
+    persistEnvironment,
+    environmentExists: (name: string) =>
+      config.hasEnvironment(name).pipe(Effect.mapError(mapConfigError)),
+    defaultNameFromUrl: (url: string) =>
+      defaultEnvironmentNameFromUrl(url).pipe(Effect.mapError(mapConfigError)),
+    defaultNameForLocal: () => Effect.succeed(defaultEnvironmentNameForLocal()),
+    listEnvironments,
+    useEnvironment: (name: string) =>
+      config
+        .setDefaultEnvironment(name)
+        .pipe(Effect.mapError(mapConfigError), Effect.as({ name, default: true as const })),
+    resolveUnpairTarget,
+    unpairEnvironment: (input: { readonly name: string }) =>
+      config
+        .removeEnvironment(input.name)
+        .pipe(
+          Effect.mapError(mapConfigError),
+          Effect.as({ name: input.name, removed: true as const }),
+        ),
     status,
     issueWebSocketTicket,
   };
 });
 
 export const T3AuthLive = Layer.effect(T3Auth, makeT3Auth());
+
+function toAuthResolvedConfig(config: ResolvedConfig): AuthResolvedConfig {
+  return {
+    url: config.url,
+    token: config.token,
+    source: config.source,
+    local: config.local,
+    ...(config.environment !== undefined ? { environment: config.environment } : {}),
+  };
+}
+
+function toAuthEnvironmentListItem(
+  environment: EnvironmentSummary,
+  activeName: string | undefined,
+): AuthEnvironmentListItem {
+  return {
+    name: environment.name,
+    url: environment.url,
+    local: environment.local,
+    default: environment.default,
+    active: environment.name === activeName,
+  };
+}

package/src/auth/local-base-dir.ts

@@ -1,17 +1,24 @@
 import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
 
-import { Environment } from "../environment/service.ts";
-import { resolveT3BaseDir } from "../layout/base-dir.ts";
+import type { CliRuntime } from "../cli/runtime/service.ts";
+import type { T3CliEnvShape } from "../config/env/env.ts";
+import { resolveT3BaseDir } from "../config/env/layout.ts";
 
 export const resolveLocalBaseDir = Effect.fn("resolveLocalBaseDir")(function* (input: {
   readonly baseDir?: string | undefined;
+  readonly cliRuntime: CliRuntime["Service"];
+  readonly t3CliEnv: T3CliEnvShape;
 }) {
-  const environment = yield* Environment;
+  const homeDir = yield* Option.match(input.t3CliEnv.home, {
+    onNone: () => Effect.die("HOME is not set"),
+    onSome: Effect.succeed,
+  });
   return yield* resolveT3BaseDir({
     layout: {
-      cwd: environment.cwd,
-      homeDir: environment.homeDir,
-      t3codeHome: environment.env["T3CODE_HOME"],
+      cwd: input.cliRuntime.cwd,
+      homeDir,
+      t3codeHome: Option.getOrUndefined(input.t3CliEnv.t3codeHome),
     },
     baseDir: input.baseDir,
   });

package/src/auth/local-origin.ts

@@ -4,8 +4,9 @@ import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Path from "effect/Path";
 
-import { normalizeHttpBaseUrl } from "../config/url.ts";
-import { Environment } from "../environment/service.ts";
+import { normalizeHttpBaseUrl } from "../config/url/url.ts";
+import { loadT3CliEnv } from "../config/env/env.ts";
+import { CliRuntime } from "../cli/runtime/service.ts";
 import { AuthLocalError } from "./error.ts";
 import { resolveLocalBaseDir } from "./local-base-dir.ts";
 import { decodeAuthLocalRuntimeStateFromJson } from "./schema.ts";
@@ -21,15 +22,17 @@ export class T3LocalAuthOrigin extends Context.Service<
 export const makeT3LocalAuthOrigin = Effect.fn("makeT3LocalAuthOrigin")(function* () {
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
-  const environment = yield* Environment;
+  const cliRuntime = yield* CliRuntime;
+  const t3CliEnv = yield* loadT3CliEnv;
 
   const resolve = Effect.fn("T3LocalAuthOriginLive.resolve")(function* (
     input?: LocalAuthOriginInput,
   ) {
-    const baseDir = yield* resolveLocalBaseDir({ baseDir: input?.baseDir }).pipe(
-      Effect.provideService(Environment, environment),
-      Effect.provideService(Path.Path, path),
-    );
+    const baseDir = yield* resolveLocalBaseDir({
+      baseDir: input?.baseDir,
+      cliRuntime,
+      t3CliEnv,
+    }).pipe(Effect.provideService(Path.Path, path));
     if (input?.origin !== undefined) {
       return yield* normalizeLocalOrigin(input.origin);
     }