t3code-cli 0.11.0 → 0.12.0

package/src/domain/error.ts

@@ -55,6 +55,23 @@ export class TerminalLookupError extends Schema.TaggedErrorClass<TerminalLookupE
   },
 ) {}
 
+export class ProjectActionLookupError extends Schema.TaggedErrorClass<ProjectActionLookupError>()(
+  "ProjectActionLookupError",
+  {
+    message: Schema.String,
+    projectId: Schema.String,
+    selector: Schema.String,
+  },
+) {}
+
+export class ProjectActionValidationError extends Schema.TaggedErrorClass<ProjectActionValidationError>()(
+  "ProjectActionValidationError",
+  {
+    message: Schema.String,
+    projectId: Schema.String,
+  },
+) {}
+
 export type DomainError =
   | ProjectLookupError
   | ModelSelectionError
@@ -62,4 +79,6 @@ export type DomainError =
   | ThreadSessionError
   | ThreadLookupError
   | ProjectCreateVisibilityError
-  | TerminalLookupError;
+  | TerminalLookupError
+  | ProjectActionLookupError
+  | ProjectActionValidationError;

package/src/domain/helpers.test.ts

@@ -5,7 +5,7 @@ import * as NodeServices from "@effect/platform-node/NodeServices";
 import { assert, describe, it } from "@effect/vitest";
 import { fromPartial } from "@total-typescript/shoehorn";
 
-import type { OrchestrationShellSnapshot } from "#t3tools/contracts";
+import type { OrchestrationShellSnapshot } from "@t3tools/contracts";
 
 import { resolveProjectScope } from "./helpers.ts";
 

package/src/domain/helpers.ts

@@ -1,6 +1,6 @@
 import * as Effect from "effect/Effect";
 import * as Path from "effect/Path";
-import type { OrchestrationProjectShell, OrchestrationShellSnapshot } from "#t3tools/contracts";
+import type { OrchestrationProjectShell, OrchestrationShellSnapshot } from "@t3tools/contracts";
 
 export type ResolvedProjectScope = {
   readonly project: OrchestrationProjectShell;

package/src/domain/model-config.ts

@@ -1,4 +1,4 @@
-import type { ServerProvider } from "#t3tools/contracts";
+import type { ServerProvider } from "@t3tools/contracts";
 
 export function isSelectableProvider(provider: ServerProvider) {
   return provider.status === "ready" && provider.models.length > 0;

package/src/domain/thread-activities.test.ts

@@ -1,6 +1,6 @@
 import "vite-plus/test/config";
 
-import { EventId, TurnId, type OrchestrationThreadActivity } from "#t3tools/contracts";
+import { EventId, TurnId, type OrchestrationThreadActivity } from "@t3tools/contracts";
 import { describe, expect, it } from "vite-plus/test";
 
 import { derivePendingApprovals, derivePendingUserInputs } from "./thread-activities.ts";

package/src/domain/thread-activities.ts

@@ -2,7 +2,7 @@ import {
   ApprovalRequestId,
   type OrchestrationThreadActivity,
   type UserInputQuestion,
-} from "#t3tools/contracts";
+} from "@t3tools/contracts";
 
 export type PendingApproval = {
   readonly requestId: ApprovalRequestId;

package/src/domain/thread-lifecycle.test.ts

@@ -3,7 +3,7 @@ import "vite-plus/test/config";
 import { describe, expect, it } from "vite-plus/test";
 import { fromPartial } from "@total-typescript/shoehorn";
 
-import type { OrchestrationThread } from "#t3tools/contracts";
+import type { OrchestrationThread } from "@t3tools/contracts";
 
 import { isThreadActive, isThreadCompleteEnough } from "./thread-lifecycle.ts";
 

package/src/domain/thread-lifecycle.ts

@@ -5,7 +5,7 @@ import {
   type OrchestrationSession,
   type OrchestrationThread,
   type OrchestrationThreadShell,
-} from "#t3tools/contracts";
+} from "@t3tools/contracts";
 import * as Schema from "effect/Schema";
 
 type SessionStatusForDelete = OrchestrationSession["status"] | "closed";

package/src/effect.test-utils.ts

@@ -0,0 +1,25 @@
+import { assert } from "@effect/vitest";
+import { assertInstanceOf } from "@effect/vitest/utils";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Option from "effect/Option";
+
+export const expectFailWithMessage = <E extends { readonly message: string }, R>(
+  effect: Effect.Effect<unknown, E, R>,
+  ErrorClass: new (...args: never) => E,
+  message: string,
+): Effect.Effect<void, never, R> =>
+  Effect.gen(function* () {
+    const exit = yield* effect.pipe(Effect.exit);
+    if (!Exit.isFailure(exit)) {
+      return yield* Effect.die("expected failure");
+    }
+    const error = Cause.findErrorOption(exit.cause);
+    if (Option.isNone(error)) {
+      return yield* Effect.die("expected failure cause");
+    }
+    assertInstanceOf(error.value, ErrorClass);
+    assert.equal(error.value.message, message);
+    return yield* Effect.void;
+  });

package/src/index.ts

@@ -4,6 +4,6 @@ export type {
   StartThreadInput,
   StartThreadPolicy,
   WaitEvent,
+  ApplicationError,
 } from "./application/index.ts";
-export type { ApplicationError } from "./application/index.ts";
 export { AppLayer, AuthAppLayer } from "./runtime/index.ts";

package/src/{connection/node.ts → node/connection.ts}

@@ -2,7 +2,7 @@ import * as Layer from "effect/Layer";
 import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient";
 import * as NodeSocket from "@effect/platform-node/NodeSocket";
 
-import { T3CodeRpcLayer } from "./layer.ts";
+import { T3CodeRpcLayer } from "../connection/index.ts";
 
 const NodeConnectionPlatformLayer = Layer.mergeAll(
   NodeHttpClient.layerUndici,

package/src/node/index.ts

@@ -1,2 +1 @@
-export { T3CodeNodeRpcLayer } from "../connection/node.ts";
-export { NodeEnvironmentLive } from "../environment/layer.ts";
+export { T3CodeNodeRpcLayer } from "./connection.ts";

package/src/orchestration/index.ts

@@ -5,4 +5,3 @@ export {
   type OrchestrationError,
 } from "./service.ts";
 export { makeT3Orchestration, T3OrchestrationLive } from "./layer.ts";
-export { T3OrchestrationLayer } from "../runtime/layer.ts";

package/src/orchestration/layer.ts

@@ -10,7 +10,7 @@ import {
   type ClientOrchestrationCommand,
   type OrchestrationShellStreamItem,
   type OrchestrationThreadStreamItem,
-} from "#t3tools/contracts";
+} from "@t3tools/contracts";
 
 import { RpcError } from "../rpc/error.ts";
 import { T3RpcOperations } from "../rpc/operation.ts";

package/src/orchestration/service.ts

@@ -10,7 +10,7 @@ import type {
   OrchestrationThread,
   OrchestrationThreadStreamItem,
   ServerProviders,
-} from "#t3tools/contracts";
+} from "@t3tools/contracts";
 
 import type { RpcError } from "../rpc/error.ts";
 

package/src/rpc/error.ts

@@ -9,13 +9,13 @@ import {
   TerminalHistoryError,
   TerminalNotRunningError,
   TerminalSessionLookupError,
-} from "#t3tools/contracts";
+} from "@t3tools/contracts";
 import { HttpClientError } from "effect/unstable/http";
 import { RpcClientError } from "effect/unstable/rpc";
 
 import { AuthTransportError } from "../auth/error.ts";
 import { T3CodeConnectionError } from "../connection/error.ts";
-import { UrlError } from "../config/error.ts";
+import { UrlError } from "../config/url/error.ts";
 
 const RpcErrorCauseSchema = Schema.Union([
   RpcClientError.RpcClientError,

package/src/rpc/index.ts

@@ -1,6 +1,5 @@
-export { RpcError, type OrchestrationError } from "./error.ts";
+export { RpcError } from "./error.ts";
 export { makeT3RpcLayer, T3RpcLive } from "./layer.ts";
 export { T3RpcOperations, T3RpcOperationsLive, makeT3RpcOperations } from "./operation.ts";
-export type { T3RpcOperationsService } from "./operation.ts";
 export { T3Rpc } from "./service.ts";
-export type { T3RpcService, WsClient } from "./service.ts";
+export type { WsClient } from "./service.ts";

package/src/rpc/layer.ts

@@ -12,7 +12,7 @@ import * as Socket from "effect/unstable/socket/Socket";
 
 import { T3AuthTransport } from "../auth/transport.ts";
 import { T3CodeConnectionProvider } from "../connection/service.ts";
-import { normalizeHttpBaseUrl, toWebSocketEndpointUrl } from "../config/url.ts";
+import { normalizeHttpBaseUrl, toWebSocketEndpointUrl } from "../config/url/url.ts";
 import { CliWsRpcGroup } from "./ws-group.ts";
 import { RpcError } from "./error.ts";
 import { T3Rpc, type WsClient } from "./service.ts";

package/src/rpc/ws-group.ts

@@ -22,7 +22,7 @@ import {
   WsOrchestrationGetArchivedShellSnapshotRpc,
   WsOrchestrationSubscribeShellRpc,
   WsOrchestrationSubscribeThreadRpc,
-} from "#t3tools/contracts";
+} from "@t3tools/contracts";
 import * as Schema from "effect/Schema";
 import { Rpc, RpcGroup } from "effect/unstable/rpc";
 

package/src/runtime/index.ts

@@ -1,6 +1,8 @@
 export {
   AppLayer,
   AuthAppLayer,
+  BaseAppLayer,
+  BaseAuthAppLayer,
   T3AuthLayer,
   T3AuthPairingLayer,
   T3AuthTransportLayer,
@@ -9,4 +11,3 @@ export {
   T3LocalAuthTokenLayer,
   T3OrchestrationLayer,
 } from "./layer.ts";
-export { NodeEnvironmentLive } from "../environment/layer.ts";

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

@@ -0,0 +1,32 @@
+import * as Layer from "effect/Layer";
+
+import * as CliSelection from "../cli/env/selection-layer.ts";
+import * as CliRuntime from "../cli/runtime/service.ts";
+import * as Config from "../config/config.ts";
+import * as Credential from "../config/credential/service.ts";
+import * as CredentialCipherNode from "../config/credential/cipher-node.ts";
+import { ConfigPlatformLayer } from "../config/platform.test-utils.ts";
+import { t3CliEnvConfigLayer } from "../config/env/env.test-utils.ts";
+import * as Keystore from "../config/keystore/service.test-utils.ts";
+
+export function cliConfigRoutingLayerTest(homeDir: string) {
+  const cliRuntimeLayer = CliRuntime.CliRuntime.layerTest({ cwd: homeDir });
+  const configLayer = t3CliEnvConfigLayer(homeDir, { T3CLI_ENV: "home" });
+  const platformEnvLayer = Layer.mergeAll(cliRuntimeLayer, configLayer);
+
+  return Layer.mergeAll(
+    ConfigPlatformLayer,
+    platformEnvLayer,
+    Config.layer.pipe(
+      Layer.provide(Credential.layer),
+      Layer.provide(
+        Layer.mergeAll(
+          platformEnvLayer,
+          CliSelection.layer.pipe(Layer.provide(platformEnvLayer)),
+          CredentialCipherNode.layerNode,
+          Keystore.unavailableKeystoreFactoryLayer,
+        ),
+      ),
+    ),
+  );
+}

package/src/runtime/layer.test.ts

@@ -0,0 +1,66 @@
+import "vite-plus/test/config";
+
+import * as Effect from "effect/Effect";
+import * as Ref from "effect/Ref";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { assert, describe, it } from "@effect/vitest";
+import { Command } from "effect/unstable/cli";
+
+import { cliEnvironmentSetting } from "../cli/env/flag.ts";
+import type { ResolvedConfig } from "../config/types.ts";
+import { T3Config } from "../config/config.ts";
+import { makeTempHomeScoped } from "../config/temp-home.test-utils.ts";
+import { cliConfigRoutingLayerTest } from "./layer.test-utils.ts";
+
+describe("CLI config routing", () => {
+  it.effect(
+    "routes --environment through Command.run to T3Config.resolve ahead of default and T3CLI_ENV",
+    () =>
+      Effect.gen(function* () {
+        return yield* makeTempHomeScoped("t3cli-runtime-");
+      }).pipe(
+        Effect.flatMap((homeDir) => {
+          const testLayer = cliConfigRoutingLayerTest(homeDir);
+          return Effect.gen(function* () {
+            const resolvedRef = yield* Ref.make<ResolvedConfig | undefined>(undefined);
+            const resolveProbeCommand = Command.make("resolve-probe", {}, () =>
+              Effect.gen(function* () {
+                const config = yield* T3Config;
+                const resolved = yield* config.resolve();
+                yield* Ref.set(resolvedRef, resolved);
+              }),
+            ).pipe(Command.withGlobalFlags([cliEnvironmentSetting]));
+            const runResolveProbe = Command.runWith(resolveProbeCommand, { version: "0.0.0-test" });
+
+            yield* 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: false,
+              });
+            }).pipe(Effect.provide(testLayer));
+
+            yield* runResolveProbe(["--environment", "work"]).pipe(Effect.provide(testLayer));
+
+            const resolved = yield* Ref.get(resolvedRef);
+            assert.isDefined(resolved);
+            assert.equal(resolved.source, "config");
+            if (resolved.source === "config") {
+              assert.equal(resolved.environment, "work");
+              assert.equal(resolved.token, "work-token");
+            }
+          });
+        }),
+        Effect.provide(NodeServices.layer),
+        Effect.scoped,
+      ),
+  );
+});

package/src/runtime/layer.ts

@@ -10,8 +10,9 @@ import { T3LocalAuthOriginLive } from "../auth/local-origin.ts";
 import { T3LocalAuthTokenLive } from "../auth/local-token.ts";
 import { T3AuthPairingLive } from "../auth/pairing.ts";
 import { T3AuthTransportLive } from "../auth/transport.ts";
-import { T3ConfigLive } from "../config/layer.ts";
-import { T3Config } from "../config/service.ts";
+import * as Config from "../config/config.ts";
+import * as Credential from "../config/credential/service.ts";
+import * as Selection from "../config/selection/service.ts";
 import { T3CodeConnectionError } from "../connection/error.ts";
 import { T3CodeConnectionProvider, makeT3CodeConnectionProvider } from "../connection/service.ts";
 import { T3OrchestrationLive } from "../orchestration/layer.ts";
@@ -20,6 +21,7 @@ import { T3RpcOperationsLive } from "../rpc/operation.ts";
 import { NodeSqlClientFactoryLive } from "../sql/node-sqlite-client.ts";
 import { NodeCliPathLayer } from "../cli-path/layer.ts";
 
+export const T3ConfigLayer = Config.layer.pipe(Layer.provide(Credential.layer));
 export const T3AuthTransportLayer = T3AuthTransportLive.pipe(
   Layer.provide(NodeHttpClient.layerUndici),
 );
@@ -33,13 +35,13 @@ export const T3LocalAuthLayer = T3LocalAuthLive.pipe(
 export const T3AuthPairingLayer = T3AuthPairingLive.pipe(Layer.provide(T3AuthTransportLayer));
 export const T3AuthLayer = T3AuthLive.pipe(
   Layer.provide(
-    Layer.mergeAll(T3ConfigLive, T3AuthTransportLayer, T3LocalAuthLayer, T3AuthPairingLayer),
+    Layer.mergeAll(T3ConfigLayer, T3AuthTransportLayer, T3LocalAuthLayer, T3AuthPairingLayer),
   ),
 );
 const T3ConfigConnectionProviderLayer = Layer.effect(
   T3CodeConnectionProvider,
   Effect.gen(function* () {
-    const config = yield* T3Config;
+    const config = yield* Config.T3Config;
     return makeT3CodeConnectionProvider(
       config.resolve().pipe(
         Effect.map((resolved) => ({
@@ -56,7 +58,7 @@ const T3ConfigConnectionProviderLayer = Layer.effect(
       ),
     );
   }),
-).pipe(Layer.provide(T3ConfigLive));
+).pipe(Layer.provide(T3ConfigLayer));
 
 const T3RpcLayer = T3RpcLive.pipe(
   Layer.provide(
@@ -73,10 +75,8 @@ const T3ApplicationLayer = T3ApplicationLive.pipe(
   Layer.provide(Layer.mergeAll(T3RpcOperationsLayer, T3OrchestrationLayer)),
 );
 
-export const AuthAppLayer = Layer.mergeAll(T3ConfigLive, T3AuthLayer);
-
-export const AppLayer = Layer.mergeAll(
-  T3ConfigLive,
+export const BaseAppLayer = Layer.mergeAll(
+  T3ConfigLayer,
   T3AuthLayer,
   T3RpcLayer,
   T3RpcOperationsLayer,
@@ -84,3 +84,9 @@ export const AppLayer = Layer.mergeAll(
   T3ApplicationLayer,
   NodeCliPathLayer,
 );
+
+export const BaseAuthAppLayer = Layer.mergeAll(T3ConfigLayer, T3AuthLayer);
+
+export const AuthAppLayer = BaseAuthAppLayer.pipe(Layer.provideMerge(Selection.layer));
+
+export const AppLayer = BaseAppLayer.pipe(Layer.provideMerge(Selection.layer));

package/src/t3tools/index.ts

@@ -1 +1 @@
-export * from "#t3tools/contracts";
+export * from "@t3tools/contracts";

package/src/types/marked-terminal.d.ts

@@ -0,0 +1,11 @@
+declare module "marked-terminal" {
+  import type { MarkedExtension } from "marked";
+
+  export type TerminalRendererOptions = {
+    readonly reflowText?: boolean;
+    readonly showSectionPrefix?: boolean;
+    readonly width?: number;
+  };
+
+  export function markedTerminal(options?: TerminalRendererOptions): MarkedExtension;
+}

package/dist/layout.js

@@ -1,2 +0,0 @@
-import { L as readT3LayoutFromNodeProcess, R as resolveT3BaseDir } from "./shared.js";
-export { readT3LayoutFromNodeProcess, resolveT3BaseDir };

package/dist/scope.js

@@ -1,2 +0,0 @@
-import { Fd as resolveWorktreePath, Md as resolveCommandProjectRef, Nd as resolveProjectRef, Pd as resolveThreadId } from "./shared.js";
-export { resolveCommandProjectRef, resolveProjectRef, resolveThreadId, resolveWorktreePath };

package/dist/src/cli/output-format.d.ts

@@ -1,11 +0,0 @@
-import type { EnvironmentShape } from "../environment/service.ts";
-export declare const humanJsonFormatChoices: readonly ["auto", "human", "json"];
-export declare const humanNdjsonFormatChoices: readonly ["auto", "human", "ndjson"];
-export declare const humanJsonNdjsonFormatChoices: readonly ["auto", "human", "json", "ndjson"];
-export type HumanJsonFormat = (typeof humanJsonFormatChoices)[number];
-export type HumanNdjsonFormat = (typeof humanNdjsonFormatChoices)[number];
-export type HumanJsonNdjsonFormat = (typeof humanJsonNdjsonFormatChoices)[number];
-export declare function resolveOutputFormat<T extends "json" | "ndjson">(format: "auto" | "human" | T, environment: EnvironmentShape, nonHumanFormat: T): "human" | T;
-export declare function canRenderLiveTerminal(environment: EnvironmentShape): boolean;
-export declare function isInteractiveHumanTerminal(environment: EnvironmentShape): boolean;
-export declare function isAgentEnvironment(environment: EnvironmentShape): boolean;

package/dist/src/config/layer.d.ts

@@ -1,22 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Layer from "effect/Layer";
-import * as Path from "effect/Path";
-import { Environment } from "../environment/service.ts";
-import { ConfigError } from "./error.ts";
-import { T3Config, type StoredConfig } from "./service.ts";
-export declare const makeT3Config: () => Effect.Effect<{
-    readStored: () => Effect.Effect<{
-        readonly url?: string;
-        readonly token?: string;
-        readonly local?: boolean;
-    }, ConfigError, never>;
-    writeStored: (config: StoredConfig) => Effect.Effect<void, ConfigError, never>;
-    resolve: () => Effect.Effect<{
-        url: string;
-        token: string;
-        source: "config" | "env";
-        local: boolean;
-    }, import("./error.ts").UrlError | ConfigError, never>;
-}, never, Environment | Path.Path | FileSystem.FileSystem>;
-export declare const T3ConfigLive: Layer.Layer<T3Config, never, Environment | Path.Path | FileSystem.FileSystem>;

package/dist/src/config/service.d.ts

@@ -1,22 +0,0 @@
-import * as Context from "effect/Context";
-import type * as Effect from "effect/Effect";
-import type { ConfigError, ConfigServiceError } from "./error.ts";
-export type StoredConfig = {
-    readonly url?: string;
-    readonly token?: string;
-    readonly local?: boolean;
-};
-export type ResolvedConfig = {
-    readonly url: string;
-    readonly token: string;
-    readonly source: "env" | "config";
-    readonly local: boolean;
-};
-declare const T3Config_base: Context.ServiceClass<T3Config, "t3cli/T3Config", {
-    readonly readStored: () => Effect.Effect<StoredConfig, ConfigError>;
-    readonly writeStored: (config: StoredConfig) => Effect.Effect<void, ConfigError>;
-    readonly resolve: () => Effect.Effect<ResolvedConfig, ConfigServiceError>;
-}>;
-export declare class T3Config extends T3Config_base {
-}
-export {};

package/dist/src/environment/layer.d.ts

@@ -1,3 +0,0 @@
-import * as Layer from "effect/Layer";
-import { Environment } from "./service.ts";
-export declare const NodeEnvironmentLive: Layer.Layer<Environment, never, never>;

package/dist/src/environment/service.d.ts

@@ -1,12 +0,0 @@
-import * as Context from "effect/Context";
-export type EnvironmentShape = {
-    readonly cwd: string;
-    readonly homeDir: string;
-    readonly env: Readonly<Record<string, string | undefined>>;
-    readonly stdoutIsTTY: boolean;
-    readonly stderrIsTTY: boolean;
-};
-declare const Environment_base: Context.ServiceClass<Environment, "t3cli/Environment", EnvironmentShape>;
-export declare class Environment extends Environment_base {
-}
-export {};

package/dist/src/layout/index.d.ts

@@ -1 +0,0 @@
-export { readT3LayoutFromNodeProcess, resolveT3BaseDir, type T3Layout } from "./base-dir.ts";