t3code-cli 0.10.0 → 0.12.0

package/src/config/resolve/resolve.test.ts

@@ -0,0 +1,137 @@
+import "vite-plus/test/config";
+
+import { assert, describe, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+
+import { resolveConfiguredEnvironment } from "../selection/resolve.ts";
+import { sampleEncrypted, sampleEncryptedToken } from "./resolve.test-utils.ts";
+import {
+  buildResolvedConfigFromEnv,
+  resolveDefaultForUpsert,
+  selectEnvironmentName,
+  validateCredentialEnvVars,
+} from "./resolve.ts";
+
+describe("resolveConfiguredEnvironment", () => {
+  it("prefers cli flag over T3CLI_ENV", () => {
+    assert.equal(
+      resolveConfiguredEnvironment({
+        cliFlag: "cli",
+        t3cliEnv: "env",
+      }),
+      "cli",
+    );
+  });
+
+  it("falls back to T3CLI_ENV when cli flag is absent", () => {
+    assert.equal(
+      resolveConfiguredEnvironment({
+        t3cliEnv: "env",
+      }),
+      "env",
+    );
+  });
+});
+
+describe("selectEnvironmentName", () => {
+  it("prefers selected environment over config default", () => {
+    const selected = selectEnvironmentName({
+      selectedEnvironment: "cli",
+      defaultEnvironment: "default",
+    });
+    assert.equal(selected, "cli");
+  });
+
+  it("falls back to config default", () => {
+    assert.equal(
+      selectEnvironmentName({
+        defaultEnvironment: "default",
+      }),
+      "default",
+    );
+  });
+});
+
+describe("validateCredentialEnvVars", () => {
+  it.effect("requires both T3CODE_URL and T3CODE_TOKEN together", () =>
+    Effect.gen(function* () {
+      const onlyUrl = yield* validateCredentialEnvVars({ envUrl: "https://example.com" }).pipe(
+        Effect.exit,
+      );
+      assert.equal(Exit.isFailure(onlyUrl), true);
+
+      const onlyToken = yield* validateCredentialEnvVars({ envToken: "token" }).pipe(Effect.exit);
+      assert.equal(Exit.isFailure(onlyToken), true);
+
+      yield* validateCredentialEnvVars({
+        envUrl: "https://example.com",
+        envToken: "token",
+      });
+    }),
+  );
+});
+
+describe("buildResolvedConfigFromEnv", () => {
+  it.effect(
+    "does not inherit local=true from selected stored environment when env vars override",
+    () =>
+      Effect.gen(function* () {
+        const resolved = yield* buildResolvedConfigFromEnv({
+          envUrl: "https://remote.example",
+          envToken: "env-token",
+        });
+        assert.equal(resolved.source, "env");
+        assert.equal(resolved.local, false);
+        assert.equal(resolved.url, "https://remote.example");
+        assert.equal(resolved.token, "env-token");
+      }),
+  );
+});
+
+describe("resolveDefaultForUpsert", () => {
+  it("sets default only for the first environment", () => {
+    assert.equal(resolveDefaultForUpsert(sampleEncrypted({}), "first"), "first");
+    assert.equal(
+      resolveDefaultForUpsert(
+        sampleEncrypted({
+          default: "home",
+          environments: {
+            home: {
+              url: "https://home.example",
+              local: false,
+              token: sampleEncryptedToken(),
+            },
+          },
+        }),
+        "work",
+      ),
+      "home",
+    );
+  });
+
+  it("promotes default when makeDefault is true", () => {
+    assert.equal(
+      resolveDefaultForUpsert(
+        sampleEncrypted({
+          default: "home",
+          environments: {
+            home: {
+              url: "https://home.example",
+              local: false,
+              token: sampleEncryptedToken(),
+            },
+            work: {
+              url: "https://work.example",
+              local: false,
+              token: { ...sampleEncryptedToken(), nonce: "n2", ciphertext: "c2", tag: "t2" },
+            },
+          },
+        }),
+        "work",
+        true,
+      ),
+      "work",
+    );
+  });
+});

package/src/config/resolve/resolve.ts

@@ -0,0 +1,104 @@
+import * as Effect from "effect/Effect";
+
+import { validateEnvironmentName } from "../environment-name/name.ts";
+import { ConfigError } from "../error.ts";
+import type { EncryptedConfig, ResolvedConfig } from "../types.ts";
+import { normalizeHttpBaseUrl } from "../url/url.ts";
+
+export type ResolveSelectionInput = {
+  readonly selectedEnvironment?: string | undefined;
+  readonly defaultEnvironment?: string | undefined;
+};
+
+export function selectEnvironmentName(input: ResolveSelectionInput) {
+  if (input.selectedEnvironment !== undefined && input.selectedEnvironment.length > 0) {
+    return input.selectedEnvironment;
+  }
+  return input.defaultEnvironment;
+}
+
+export type ResolveCredentialInput = {
+  readonly envUrl?: string | undefined;
+  readonly envToken?: string | undefined;
+};
+
+export function validateCredentialEnvVars(input: ResolveCredentialInput) {
+  const hasEnvUrl = input.envUrl !== undefined && input.envUrl.length > 0;
+  const hasEnvToken = input.envToken !== undefined && input.envToken.length > 0;
+  if (hasEnvUrl !== hasEnvToken) {
+    return Effect.fail(
+      new ConfigError({
+        message: "T3CODE_URL and T3CODE_TOKEN must both be set together",
+      }),
+    );
+  }
+  return Effect.void;
+}
+
+export function resolveDefaultForUpsert(
+  encrypted: EncryptedConfig,
+  environmentName: string,
+  makeDefault?: boolean,
+): string | undefined {
+  if (makeDefault === true) {
+    return environmentName;
+  }
+  if (Object.keys(encrypted.environments).length === 0) {
+    return environmentName;
+  }
+  return encrypted.default;
+}
+
+export function summarizeEnvironments(encrypted: EncryptedConfig) {
+  return Object.entries(encrypted.environments)
+    .map(([name, environmentConfig]) => ({
+      name,
+      url: environmentConfig.url,
+      local: environmentConfig.local,
+      default: encrypted.default === name,
+    }))
+    .toSorted((left, right) => left.name.localeCompare(right.name));
+}
+
+export function buildResolvedConfigFromEnv(input: {
+  readonly envUrl: string;
+  readonly envToken: string;
+}) {
+  return normalizeHttpBaseUrl(input.envUrl).pipe(
+    Effect.mapError((error) => new ConfigError({ message: error.message, cause: error.cause })),
+    Effect.map((normalizedUrl) => {
+      return {
+        url: normalizedUrl,
+        token: input.envToken,
+        source: "env" as const,
+        local: false,
+      } satisfies ResolvedConfig;
+    }),
+  );
+}
+
+export function buildResolvedConfigFromStored(input: {
+  readonly selectedName: string;
+  readonly token: string;
+  readonly encrypted: EncryptedConfig;
+}) {
+  return Effect.gen(function* () {
+    yield* validateEnvironmentName(input.selectedName);
+    const selectedEnvironment = input.encrypted.environments[input.selectedName];
+    if (selectedEnvironment === undefined) {
+      return yield* Effect.fail(
+        new ConfigError({ message: `environment not found: ${input.selectedName}` }),
+      );
+    }
+    const normalizedUrl = yield* normalizeHttpBaseUrl(selectedEnvironment.url).pipe(
+      Effect.mapError((error) => new ConfigError({ message: error.message, cause: error.cause })),
+    );
+    return {
+      url: normalizedUrl,
+      token: input.token,
+      source: "config" as const,
+      local: selectedEnvironment.local,
+      environment: input.selectedName,
+    } satisfies ResolvedConfig;
+  });
+}

package/src/config/selection/index.ts

@@ -0,0 +1 @@
+export * as Service from "./service.ts";

package/src/config/selection/resolve.ts

@@ -0,0 +1,14 @@
+export function resolveConfiguredEnvironment(input: {
+  readonly cliFlag?: string | undefined;
+  readonly t3cliEnv?: string | undefined;
+}): string | undefined {
+  const fromFlag = input.cliFlag?.trim();
+  if (fromFlag !== undefined && fromFlag.length > 0) {
+    return fromFlag;
+  }
+  const fromEnv = input.t3cliEnv?.trim();
+  if (fromEnv !== undefined && fromEnv.length > 0) {
+    return fromEnv;
+  }
+  return undefined;
+}

package/src/config/selection/service.ts

@@ -0,0 +1,29 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+
+import { loadT3CliEnv } from "../env/env.ts";
+import { resolveConfiguredEnvironment } from "./resolve.ts";
+
+export class T3ConfigSelection extends Context.Service<
+  T3ConfigSelection,
+  {
+    readonly getSelectedEnvironment: () => Effect.Effect<string | undefined>;
+  }
+>()("t3cli/T3ConfigSelection") {}
+
+export const layer = Layer.effect(
+  T3ConfigSelection,
+  Effect.gen(function* () {
+    const t3CliEnv = yield* loadT3CliEnv;
+    return {
+      getSelectedEnvironment: () =>
+        Effect.sync(() =>
+          resolveConfiguredEnvironment({
+            t3cliEnv: Option.getOrUndefined(t3CliEnv.t3cliEnv),
+          }),
+        ),
+    };
+  }),
+);

package/src/config/temp-home.test-utils.ts

@@ -0,0 +1,7 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+
+export const makeTempHomeScoped = Effect.fn("makeTempHomeScoped")(function* (prefix: string) {
+  const fs = yield* FileSystem.FileSystem;
+  return yield* fs.makeTempDirectoryScoped({ prefix });
+});

package/src/config/types.ts

@@ -0,0 +1,49 @@
+import type {
+  EncryptedToken,
+  StoredConfigV2File,
+  StoredEnvironmentFile,
+} from "./persist/schema.ts";
+
+export type EncryptedEnvironment = StoredEnvironmentFile;
+
+export type EncryptedConfig = StoredConfigV2File;
+
+export type DecryptedEnvironment = {
+  readonly url: string;
+  readonly local: boolean;
+  readonly token: string;
+};
+
+export type DecryptedConfig = {
+  readonly version: 2;
+  readonly default?: string;
+  readonly environments: Readonly<Record<string, DecryptedEnvironment>>;
+};
+
+export type EnvironmentSummary = {
+  readonly name: string;
+  readonly url: string;
+  readonly local: boolean;
+  readonly default: boolean;
+};
+
+export type ResolvedConfig = {
+  readonly url: string;
+  readonly token: string;
+  readonly source: "env" | "config";
+  readonly local: boolean;
+  readonly environment?: string;
+};
+
+export type UpsertEnvironmentInput = {
+  readonly name: string;
+  readonly url: string;
+  readonly token: string;
+  readonly local: boolean;
+  readonly makeDefault?: boolean;
+};
+
+export type StoredConfig = DecryptedConfig;
+export type StoredEnvironment = DecryptedEnvironment;
+
+export type { EncryptedToken };

package/src/config/url/error.ts

@@ -0,0 +1,8 @@
+import * as Cause from "effect/Cause";
+import * as Schema from "effect/Schema";
+
+export class UrlError extends Schema.TaggedErrorClass<UrlError>()("UrlError", {
+  message: Schema.String,
+  protocol: Schema.optionalKey(Schema.String),
+  cause: Schema.optionalKey(Schema.instanceOf(Cause.IllegalArgumentError)),
+}) {}

package/src/config/url/index.ts

@@ -0,0 +1,7 @@
+export {
+  normalizeHttpBaseUrl,
+  toWebSocketBaseUrl,
+  toHttpEndpointUrl,
+  toWebSocketEndpointUrl,
+} from "./url.ts";
+export { UrlError } from "./error.ts";

package/src/config/url/url.test.ts

@@ -0,0 +1,31 @@
+import "vite-plus/test/config";
+
+import * as Effect from "effect/Effect";
+import { assert, describe, it } from "@effect/vitest";
+
+import { expectFailWithMessage } from "../../effect.test-utils.ts";
+import { UrlError } from "./error.ts";
+import { normalizeHttpBaseUrl, toWebSocketEndpointUrl } from "./url.ts";
+
+describe("normalizeHttpBaseUrl", () => {
+  it.effect("strips query and trailing slash from urls with paths", () =>
+    Effect.gen(function* () {
+      const normalized = yield* normalizeHttpBaseUrl("https://app.example.com/api/?q=1");
+      assert.equal(normalized, "https://app.example.com/api");
+    }),
+  );
+
+  it.effect("maps invalid urls to UrlError", () =>
+    expectFailWithMessage(normalizeHttpBaseUrl("not-a-url"), UrlError, "invalid url"),
+  );
+});
+
+describe("toWebSocketEndpointUrl", () => {
+  it.effect("rejects unsupported protocols with UrlError", () =>
+    expectFailWithMessage(
+      toWebSocketEndpointUrl("ftp://example.com", "/ws"),
+      UrlError,
+      "unsupported server url protocol: ftp:",
+    ),
+  );
+});

package/src/connection/index.ts

@@ -1,6 +1,5 @@
 export { T3CodeConnectionError } from "./error.ts";
 export { T3CodeRpcLayer, makeT3CodeRpcLayer } from "./layer.ts";
-export { T3CodeNodeRpcLayer } from "./node.ts";
 export {
   T3CodeConnectionProvider,
   T3CodeConnectionProviderLive,

package/src/contracts/index.ts

@@ -5,4 +5,4 @@ export type {
   OrchestrationThread,
   OrchestrationThreadShell,
   ServerProvider,
-} from "#t3tools/contracts";
+} from "@t3tools/contracts";

package/src/domain/error.ts

@@ -30,6 +30,14 @@ export class ThreadSessionError extends Schema.TaggedErrorClass<ThreadSessionErr
   },
 ) {}
 
+export class ThreadLookupError extends Schema.TaggedErrorClass<ThreadLookupError>()(
+  "ThreadLookupError",
+  {
+    message: Schema.String,
+    threadId: Schema.String,
+  },
+) {}
+
 export class ProjectCreateVisibilityError extends Schema.TaggedErrorClass<ProjectCreateVisibilityError>()(
   "ProjectCreateVisibilityError",
   {
@@ -38,9 +46,39 @@ export class ProjectCreateVisibilityError extends Schema.TaggedErrorClass<Projec
   },
 ) {}
 
+export class TerminalLookupError extends Schema.TaggedErrorClass<TerminalLookupError>()(
+  "TerminalLookupError",
+  {
+    message: Schema.String,
+    threadId: Schema.String,
+    terminalId: Schema.String,
+  },
+) {}
+
+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
   | ThreadEventError
   | ThreadSessionError
-  | ProjectCreateVisibilityError;
+  | ThreadLookupError
+  | ProjectCreateVisibilityError
+  | 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;
@@ -12,6 +12,10 @@ export function firstSelectableModel(provider: ServerProvider) {
   return provider.models[0];
 }
 
+export function findSelectableModel(provider: ServerProvider, slug: string) {
+  return provider.models.find((model) => model.slug === slug);
+}
+
 export function findSelectableProvider(
   providers: ReadonlyArray<ServerProvider>,
   instanceId: string,

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

@@ -2,11 +2,25 @@ import {
   OrchestrationMessage,
   type OrchestrationEvent,
   type OrchestrationMessage as OrchestrationMessageType,
+  type OrchestrationSession,
   type OrchestrationThread,
   type OrchestrationThreadShell,
-} from "#t3tools/contracts";
+} from "@t3tools/contracts";
 import * as Schema from "effect/Schema";
 
+type SessionStatusForDelete = OrchestrationSession["status"] | "closed";
+
+function isClosedSessionStatus(status: SessionStatusForDelete): status is "closed" {
+  return status === "closed";
+}
+
+export function sessionNeedsStopBeforeDelete(session: OrchestrationSession | null) {
+  if (session === null) {
+    return false;
+  }
+  return !isClosedSessionStatus(session.status);
+}
+
 export function isThreadActive(thread: OrchestrationThreadShell | OrchestrationThread) {
   if (thread.session?.status === "starting" || thread.session?.status === "running") {
     return true;

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

@@ -0,0 +1 @@
+export { T3CodeNodeRpcLayer } from "./connection.ts";

package/src/orchestration/index.ts

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