t3code-cli 0.10.0 → 0.12.0

package/dist/src/config/credential/cipher.d.ts

@@ -0,0 +1,29 @@
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import type { CredentialCipherError } from "./error.ts";
+export declare const credentialCipherNonceByteLength = 12;
+export declare const credentialCipherTagByteLength = 16;
+export type AesGcmEncryptInput = {
+    readonly key: Uint8Array;
+    readonly nonce: Uint8Array;
+    readonly plaintext: Uint8Array;
+    readonly additionalData: Uint8Array;
+};
+export type AesGcmDecryptInput = {
+    readonly key: Uint8Array;
+    readonly nonce: Uint8Array;
+    readonly ciphertext: Uint8Array;
+    readonly tag: Uint8Array;
+    readonly additionalData: Uint8Array;
+};
+export type AesGcmEncryptResult = {
+    readonly ciphertext: Uint8Array;
+    readonly tag: Uint8Array;
+};
+declare const T3CredentialCipher_base: Context.ServiceClass<T3CredentialCipher, "t3cli/T3CredentialCipher", {
+    readonly encrypt: (input: AesGcmEncryptInput) => Effect.Effect<AesGcmEncryptResult, CredentialCipherError>;
+    readonly decrypt: (input: AesGcmDecryptInput) => Effect.Effect<Uint8Array, CredentialCipherError>;
+}>;
+export declare class T3CredentialCipher extends T3CredentialCipher_base {
+}
+export {};

package/dist/src/config/credential/env.d.ts

@@ -0,0 +1,3 @@
+import * as Option from "effect/Option";
+import type { T3CliEnvShape } from "../env/env.ts";
+export declare function credentialTokenFromEnv(t3CliEnv: Pick<T3CliEnvShape, "t3codeToken">): Option.Option<string>;

package/dist/src/config/credential/error.d.ts

@@ -0,0 +1,8 @@
+import * as Schema from "effect/Schema";
+declare const CredentialCipherError_base: Schema.Class<CredentialCipherError, Schema.TaggedStruct<"CredentialCipherError", {
+    readonly operation: Schema.Literals<readonly ["encrypt", "decrypt"]>;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class CredentialCipherError extends CredentialCipherError_base {
+}
+export {};

package/dist/src/config/credential/index.d.ts

@@ -0,0 +1,6 @@
+export * as Service from "./service.ts";
+export * as Cipher from "./cipher.ts";
+export * as CipherNode from "./cipher-node.ts";
+export * as CipherWeb from "./cipher-web.ts";
+export { credentialTokenFromEnv } from "./env.ts";
+export { CredentialCipherError } from "./error.ts";

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

@@ -0,0 +1,34 @@
+import * as Context from "effect/Context";
+import * as Crypto from "effect/Crypto";
+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 { T3CredentialCipher } from "./cipher.ts";
+import type { EncryptedToken } from "../persist/schema.ts";
+import { ConfigError } from "../error.ts";
+import { T3MasterKeyKeystoreFactory } from "../keystore/service.ts";
+export type CredentialEncryptInput = {
+    readonly environmentName: string;
+    readonly url: string;
+    readonly local: boolean;
+    readonly token: string;
+};
+export type CredentialDecryptInput = {
+    readonly environmentName: string;
+    readonly url: string;
+    readonly local: boolean;
+    readonly token: EncryptedToken;
+};
+declare const T3CredentialCrypto_base: Context.ServiceClass<T3CredentialCrypto, "t3cli/T3CredentialCrypto", {
+    readonly encrypt: (input: CredentialEncryptInput) => Effect.Effect<EncryptedToken, ConfigError>;
+    readonly decrypt: (input: CredentialDecryptInput) => Effect.Effect<string, ConfigError>;
+}>;
+export declare class T3CredentialCrypto extends T3CredentialCrypto_base {
+}
+export declare const make: () => Effect.Effect<{
+    encrypt: (input: CredentialEncryptInput) => Effect.Effect<EncryptedToken, ConfigError>;
+    decrypt: (input: CredentialDecryptInput) => Effect.Effect<string, ConfigError>;
+}, ConfigError, Path.Path | Crypto.Crypto | T3CredentialCipher | T3MasterKeyKeystoreFactory | FileSystem.FileSystem>;
+export declare const layer: Layer.Layer<T3CredentialCrypto, ConfigError, Path.Path | Crypto.Crypto | T3CredentialCipher | T3MasterKeyKeystoreFactory | FileSystem.FileSystem>;
+export {};

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

@@ -0,0 +1,55 @@
+import * as Config from "effect/Config";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import type * as Redacted from "effect/Redacted";
+export type T3CliEnvScope = {
+    readonly t3codeProjectRoot?: string | undefined;
+    readonly t3codeProjectId?: string | undefined;
+    readonly t3codeWorktreePath?: string | undefined;
+    readonly t3codeThreadId?: string | undefined;
+};
+export type T3CliEnvShape = {
+    readonly home: Option.Option<string>;
+    readonly xdgConfigHome: Option.Option<string>;
+    readonly t3cliEnv: Option.Option<string>;
+    readonly t3codeUrl: Option.Option<string>;
+    readonly t3codeToken: Option.Option<Redacted.Redacted>;
+    readonly t3codeHome: Option.Option<string>;
+    readonly term: Option.Option<string>;
+    readonly ci: boolean;
+    readonly codexCi: boolean;
+    readonly codexThreadId: boolean;
+    readonly t3cliAgent: boolean;
+    readonly scope: T3CliEnvScope;
+};
+export declare const T3CliEnvConfig: Config.Config<{
+    home: Option.Option<string>;
+    xdgConfigHome: Option.Option<string>;
+    t3cliEnv: Option.Option<string>;
+    t3codeUrl: Option.Option<string>;
+    t3codeToken: Option.Option<Redacted.Redacted<string>>;
+    t3codeHome: Option.Option<string>;
+    t3codeProjectRoot: Option.Option<string>;
+    t3codeProjectId: Option.Option<string>;
+    t3codeWorktreePath: Option.Option<string>;
+    t3codeThreadId: Option.Option<string>;
+    term: Option.Option<string>;
+    ci: boolean;
+    codexCi: boolean;
+    codexThreadId: boolean;
+    t3cliAgent: boolean;
+}>;
+export declare const loadT3CliEnv: Effect.Effect<{
+    home: Option.Option<string>;
+    xdgConfigHome: Option.Option<string>;
+    t3cliEnv: Option.Option<string>;
+    t3codeUrl: Option.Option<string>;
+    t3codeToken: Option.Option<Redacted.Redacted<string>>;
+    t3codeHome: Option.Option<string>;
+    term: Option.Option<string>;
+    ci: boolean;
+    codexCi: boolean;
+    codexThreadId: boolean;
+    t3cliAgent: boolean;
+    scope: T3CliEnvScope;
+}, Config.ConfigError, never>;

package/dist/src/config/env/index.d.ts

@@ -0,0 +1,2 @@
+export { loadT3CliEnv, T3CliEnvConfig, type T3CliEnvScope, type T3CliEnvShape } from "./env.ts";
+export { resolveT3BaseDir, type T3Layout } from "./layout.ts";

package/dist/src/{layout/base-dir.d.ts → config/env/layout.d.ts}

@@ -5,7 +5,6 @@ export type T3Layout = {
     readonly homeDir: string;
     readonly t3codeHome?: string | undefined;
 };
-export declare function readT3LayoutFromNodeProcess(): T3Layout;
 export declare const resolveT3BaseDir: (input: {
     readonly layout: T3Layout;
     readonly baseDir?: string | undefined;

package/dist/src/config/environment-name/index.d.ts

@@ -0,0 +1 @@
+export { defaultEnvironmentNameForLocal, defaultEnvironmentNameFromUrl, migrateV1EnvironmentName, slugifyEnvironmentName, validateEnvironmentName, } from "./name.ts";

package/dist/src/config/environment-name/name.d.ts

@@ -0,0 +1,10 @@
+import * as Effect from "effect/Effect";
+import { ConfigError } from "../error.ts";
+export declare function slugifyEnvironmentName(value: string): string;
+export declare function validateEnvironmentName(name: string): Effect.Effect<void, never, never> | Effect.Effect<never, ConfigError, never>;
+export declare function defaultEnvironmentNameFromUrl(url: string): Effect.Effect<string, ConfigError, never>;
+export declare function defaultEnvironmentNameForLocal(): "local";
+export declare function migrateV1EnvironmentName(input: {
+    readonly url?: string;
+    readonly local?: boolean;
+}): Effect.Effect<string, ConfigError, never>;

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

@@ -1,18 +1,11 @@
-import * as Cause from "effect/Cause";
 import * as Schema from "effect/Schema";
 import { PlatformError } from "effect/PlatformError";
-declare const UrlError_base: Schema.Class<UrlError, Schema.TaggedStruct<"UrlError", {
-    readonly message: Schema.String;
-    readonly protocol: Schema.optionalKey<Schema.String>;
-    readonly cause: Schema.optionalKey<Schema.instanceOf<Cause.IllegalArgumentError, Cause.IllegalArgumentError>>;
-}>, Cause.YieldableError>;
-export declare class UrlError extends UrlError_base {
-}
 declare const ConfigError_base: Schema.Class<ConfigError, Schema.TaggedStruct<"ConfigError", {
     readonly message: Schema.String;
-    readonly cause: Schema.optionalKey<Schema.Union<readonly [Schema.instanceOf<PlatformError, unknown>, Schema.instanceOf<Schema.SchemaError, unknown>]>>;
-}>, Cause.YieldableError>;
+    readonly cause: Schema.optionalKey<Schema.Union<readonly [Schema.instanceOf<PlatformError, unknown>, Schema.instanceOf<Schema.SchemaError, unknown>, Schema.Defect]>>;
+}>, import("effect/Cause").YieldableError>;
 export declare class ConfigError extends ConfigError_base {
 }
-export type ConfigServiceError = ConfigError | UrlError;
+export type ConfigServiceError = ConfigError;
+export declare function isPlatformNotFoundError(error: PlatformError): boolean;
 export {};

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

@@ -1,5 +1,10 @@
-export { T3Config } from "./service.ts";
-export type { ResolvedConfig, StoredConfig } from "./service.ts";
-export { T3ConfigLive, makeT3Config } from "./layer.ts";
-export { ConfigError, UrlError } from "./error.ts";
-export type { ConfigServiceError } from "./error.ts";
+export * as Config from "./config.ts";
+export type { EncryptedConfig, EncryptedToken, EnvironmentSummary, ResolvedConfig, UpsertEnvironmentInput, } from "./types.ts";
+export { ConfigError, type ConfigServiceError } from "./error.ts";
+export * as Credential from "./credential/index.ts";
+export * as Keystore from "./keystore/index.ts";
+export * as Selection from "./selection/index.ts";
+export * as Env from "./env/index.ts";
+export * as Paths from "./paths/index.ts";
+export * as Url from "./url/index.ts";
+export * as EnvironmentName from "./environment-name/index.ts";

package/dist/src/config/keystore/error.d.ts

@@ -0,0 +1,8 @@
+import * as Schema from "effect/Schema";
+declare const KeystoreUnavailableError_base: Schema.Class<KeystoreUnavailableError, Schema.TaggedStruct<"KeystoreUnavailableError", {
+    readonly reason: Schema.Literals<readonly ["module-not-found", "backend-unavailable"]>;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class KeystoreUnavailableError extends KeystoreUnavailableError_base {
+}
+export {};

package/dist/src/config/keystore/file.d.ts

@@ -0,0 +1,9 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import { ConfigError } from "../error.ts";
+import { type MasterKeyReadResult } from "./service.ts";
+export declare const makeFileKeystore: () => Effect.Effect<{
+    read: () => Effect.Effect<MasterKeyReadResult, ConfigError>;
+    write: (key: Uint8Array) => Effect.Effect<void, ConfigError>;
+}, ConfigError, Path.Path | FileSystem.FileSystem>;

package/dist/src/config/keystore/index.d.ts

@@ -0,0 +1,4 @@
+export * as Service from "./service.ts";
+export { KeystoreUnavailableError } from "./error.ts";
+export * as KeyringNode from "./keyring-node.ts";
+export * as File from "./file.ts";

package/dist/src/config/keystore/keyring-node.d.ts

@@ -0,0 +1,4 @@
+import * as Layer from "effect/Layer";
+import { T3MasterKeyKeystoreFactory, type MasterKeyReadResult } from "./service.ts";
+export declare function parseKeyringPassword(password: string | null): MasterKeyReadResult;
+export declare const layerNode: Layer.Layer<T3MasterKeyKeystoreFactory, never, never>;

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

@@ -0,0 +1,33 @@
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import type { ConfigError } from "../error.ts";
+import type { KeystoreUnavailableError } from "./error.ts";
+export declare const masterKeyByteLength = 32;
+export type MasterKeyReadResult = {
+    readonly kind: "missing";
+} | {
+    readonly kind: "present";
+    readonly key: Uint8Array;
+} | {
+    readonly kind: "corrupt";
+    readonly message: string;
+} | {
+    readonly kind: "unavailable";
+    readonly message: string;
+};
+export type MasterKeyKeystore = {
+    readonly read: () => Effect.Effect<MasterKeyReadResult, ConfigError>;
+    readonly write: (key: Uint8Array) => Effect.Effect<void, ConfigError | KeystoreUnavailableError>;
+};
+declare const T3MasterKeyKeystoreFactory_base: Context.ServiceClass<T3MasterKeyKeystoreFactory, "t3cli/T3MasterKeyKeystoreFactory", {
+    readonly make: () => Effect.Effect<MasterKeyKeystore, KeystoreUnavailableError>;
+}>;
+export declare class T3MasterKeyKeystoreFactory extends T3MasterKeyKeystoreFactory_base {
+}
+export declare function shouldUseFileKeystoreForRead(result: MasterKeyReadResult): result is {
+    readonly kind: "missing";
+} | {
+    readonly kind: "unavailable";
+    readonly message: string;
+};
+export {};

package/dist/src/config/paths/index.d.ts

@@ -0,0 +1 @@
+export { resolveConfigFilePath, resolveKeyFilePath, resolveT3cliConfigDir } from "./paths.ts";

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

@@ -0,0 +1,6 @@
+import * as Effect from "effect/Effect";
+import * as Path from "effect/Path";
+import { ConfigError } from "../error.ts";
+export declare const resolveT3cliConfigDir: () => Effect.Effect<string, ConfigError, Path.Path>;
+export declare const resolveConfigFilePath: () => Effect.Effect<string, ConfigError, Path.Path>;
+export declare const resolveKeyFilePath: () => Effect.Effect<string, ConfigError, Path.Path>;

package/dist/src/config/persist/file-mode.d.ts

@@ -0,0 +1,4 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import { ConfigError } from "../error.ts";
+export declare const hardenPrivateFileMode: (filePath: string, label: "config" | "credential key") => Effect.Effect<void, ConfigError, FileSystem.FileSystem>;

package/dist/src/config/persist/migration.d.ts

@@ -0,0 +1,68 @@
+import * as Effect from "effect/Effect";
+import { T3CredentialCrypto } from "../credential/service.ts";
+import { ConfigError } from "../error.ts";
+import type { EncryptedConfig } from "../types.ts";
+export declare const emptyEncryptedConfig: () => EncryptedConfig;
+export declare const readEncryptedConfigFromValue: (value: unknown) => Effect.Effect<{
+    config: {
+        readonly version: 2;
+        readonly environments: {
+            readonly [x: string]: {
+                readonly url: string;
+                readonly local: boolean;
+                readonly token: {
+                    readonly kind: "encrypted";
+                    readonly alg: "aes-256-gcm";
+                    readonly key: "default";
+                    readonly nonce: string;
+                    readonly ciphertext: string;
+                    readonly tag: string;
+                };
+            };
+        };
+        readonly default?: string;
+    };
+    migratedFromV1: false;
+} | {
+    config: {
+        readonly version: 2;
+        readonly environments: {
+            readonly [x: string]: {
+                readonly url: string;
+                readonly local: boolean;
+                readonly token: {
+                    readonly kind: "encrypted";
+                    readonly alg: "aes-256-gcm";
+                    readonly key: "default";
+                    readonly nonce: string;
+                    readonly ciphertext: string;
+                    readonly tag: string;
+                };
+            };
+        };
+        readonly default?: string;
+    };
+    migratedFromV1: true;
+}, ConfigError, T3CredentialCrypto>;
+export declare const migrateV1FileToEncrypted: (config: {
+    readonly url?: string;
+    readonly token?: string;
+    readonly local?: boolean;
+}) => Effect.Effect<{
+    readonly version: 2;
+    readonly environments: {
+        readonly [x: string]: {
+            readonly url: string;
+            readonly local: boolean;
+            readonly token: {
+                readonly kind: "encrypted";
+                readonly alg: "aes-256-gcm";
+                readonly key: "default";
+                readonly nonce: string;
+                readonly ciphertext: string;
+                readonly tag: string;
+            };
+        };
+    };
+    readonly default?: string;
+}, ConfigError, T3CredentialCrypto>;

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

@@ -0,0 +1,40 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import { ConfigError } from "../error.ts";
+export declare const readEncryptedConfigFile: () => Effect.Effect<{
+    readonly version: 2;
+    readonly environments: {
+        readonly [x: string]: {
+            readonly url: string;
+            readonly local: boolean;
+            readonly token: {
+                readonly kind: "encrypted";
+                readonly alg: "aes-256-gcm";
+                readonly key: "default";
+                readonly nonce: string;
+                readonly ciphertext: string;
+                readonly tag: string;
+            };
+        };
+    };
+    readonly default?: string;
+}, ConfigError, Path.Path | FileSystem.FileSystem | import("../credential/service.ts").T3CredentialCrypto>;
+export declare const writeEncryptedConfigFile: (config: {
+    readonly version: 2;
+    readonly environments: {
+        readonly [x: string]: {
+            readonly url: string;
+            readonly local: boolean;
+            readonly token: {
+                readonly kind: "encrypted";
+                readonly alg: "aes-256-gcm";
+                readonly key: "default";
+                readonly nonce: string;
+                readonly ciphertext: string;
+                readonly tag: string;
+            };
+        };
+    };
+    readonly default?: string;
+}) => Effect.Effect<void, ConfigError, Path.Path | FileSystem.FileSystem>;

package/dist/src/config/persist/schema.d.ts

@@ -0,0 +1,68 @@
+import * as Schema from "effect/Schema";
+export declare const EncryptedTokenSchema: Schema.Struct<{
+    readonly kind: Schema.Literal<"encrypted">;
+    readonly alg: Schema.Literal<"aes-256-gcm">;
+    readonly key: Schema.Literal<"default">;
+    readonly nonce: Schema.String;
+    readonly ciphertext: Schema.String;
+    readonly tag: Schema.String;
+}>;
+export declare const StoredEnvironmentFileSchema: Schema.Struct<{
+    readonly url: Schema.String;
+    readonly local: Schema.Boolean;
+    readonly token: Schema.Struct<{
+        readonly kind: Schema.Literal<"encrypted">;
+        readonly alg: Schema.Literal<"aes-256-gcm">;
+        readonly key: Schema.Literal<"default">;
+        readonly nonce: Schema.String;
+        readonly ciphertext: Schema.String;
+        readonly tag: Schema.String;
+    }>;
+}>;
+export declare const StoredConfigV2FileSchema: Schema.Struct<{
+    readonly version: Schema.Literal<2>;
+    readonly default: Schema.optionalKey<Schema.String>;
+    readonly environments: Schema.$Record<Schema.String, Schema.Struct<{
+        readonly url: Schema.String;
+        readonly local: Schema.Boolean;
+        readonly token: Schema.Struct<{
+            readonly kind: Schema.Literal<"encrypted">;
+            readonly alg: Schema.Literal<"aes-256-gcm">;
+            readonly key: Schema.Literal<"default">;
+            readonly nonce: Schema.String;
+            readonly ciphertext: Schema.String;
+            readonly tag: Schema.String;
+        }>;
+    }>>;
+}>;
+export declare const StoredConfigV1FileSchema: Schema.Struct<{
+    readonly url: Schema.optionalKey<Schema.String>;
+    readonly token: Schema.optionalKey<Schema.String>;
+    readonly local: Schema.optionalKey<Schema.Boolean>;
+}>;
+export type EncryptedToken = Schema.Schema.Type<typeof EncryptedTokenSchema>;
+export type StoredEnvironmentFile = Schema.Schema.Type<typeof StoredEnvironmentFileSchema>;
+export type StoredConfigV2File = Schema.Schema.Type<typeof StoredConfigV2FileSchema>;
+export type StoredConfigV1File = Schema.Schema.Type<typeof StoredConfigV1FileSchema>;
+export declare const StoredConfigV1FileJson: Schema.fromJsonString<Schema.Struct<{
+    readonly url: Schema.optionalKey<Schema.String>;
+    readonly token: Schema.optionalKey<Schema.String>;
+    readonly local: Schema.optionalKey<Schema.Boolean>;
+}>>;
+export declare const StoredConfigV2FileJson: Schema.fromJsonString<Schema.Struct<{
+    readonly version: Schema.Literal<2>;
+    readonly default: Schema.optionalKey<Schema.String>;
+    readonly environments: Schema.$Record<Schema.String, Schema.Struct<{
+        readonly url: Schema.String;
+        readonly local: Schema.Boolean;
+        readonly token: Schema.Struct<{
+            readonly kind: Schema.Literal<"encrypted">;
+            readonly alg: Schema.Literal<"aes-256-gcm">;
+            readonly key: Schema.Literal<"default">;
+            readonly nonce: Schema.String;
+            readonly ciphertext: Schema.String;
+            readonly tag: Schema.String;
+        }>;
+    }>>;
+}>>;
+export declare const UnknownConfigFileJson: Schema.UnknownFromJsonString;

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

@@ -0,0 +1,40 @@
+import * as Effect from "effect/Effect";
+import { ConfigError } from "../error.ts";
+import type { EncryptedConfig } from "../types.ts";
+export type ResolveSelectionInput = {
+    readonly selectedEnvironment?: string | undefined;
+    readonly defaultEnvironment?: string | undefined;
+};
+export declare function selectEnvironmentName(input: ResolveSelectionInput): string | undefined;
+export type ResolveCredentialInput = {
+    readonly envUrl?: string | undefined;
+    readonly envToken?: string | undefined;
+};
+export declare function validateCredentialEnvVars(input: ResolveCredentialInput): Effect.Effect<void, never, never> | Effect.Effect<never, ConfigError, never>;
+export declare function resolveDefaultForUpsert(encrypted: EncryptedConfig, environmentName: string, makeDefault?: boolean): string | undefined;
+export declare function summarizeEnvironments(encrypted: EncryptedConfig): {
+    name: string;
+    url: string;
+    local: boolean;
+    default: boolean;
+}[];
+export declare function buildResolvedConfigFromEnv(input: {
+    readonly envUrl: string;
+    readonly envToken: string;
+}): Effect.Effect<{
+    url: string;
+    token: string;
+    source: "env";
+    local: false;
+}, ConfigError, never>;
+export declare function buildResolvedConfigFromStored(input: {
+    readonly selectedName: string;
+    readonly token: string;
+    readonly encrypted: EncryptedConfig;
+}): Effect.Effect<{
+    url: string;
+    token: string;
+    source: "config";
+    local: boolean;
+    environment: string;
+}, ConfigError, never>;

package/dist/src/config/selection/index.d.ts

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

package/dist/src/config/selection/resolve.d.ts

@@ -0,0 +1,4 @@
+export declare function resolveConfiguredEnvironment(input: {
+    readonly cliFlag?: string | undefined;
+    readonly t3cliEnv?: string | undefined;
+}): string | undefined;

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

@@ -0,0 +1,10 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+declare const T3ConfigSelection_base: Context.ServiceClass<T3ConfigSelection, "t3cli/T3ConfigSelection", {
+    readonly getSelectedEnvironment: () => Effect.Effect<string | undefined>;
+}>;
+export declare class T3ConfigSelection extends T3ConfigSelection_base {
+}
+export declare const layer: Layer.Layer<T3ConfigSelection, import("effect/Config").ConfigError, never>;
+export {};

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

@@ -0,0 +1,36 @@
+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/dist/src/config/url/error.d.ts

@@ -0,0 +1,10 @@
+import * as Cause from "effect/Cause";
+import * as Schema from "effect/Schema";
+declare const UrlError_base: Schema.Class<UrlError, Schema.TaggedStruct<"UrlError", {
+    readonly message: Schema.String;
+    readonly protocol: Schema.optionalKey<Schema.String>;
+    readonly cause: Schema.optionalKey<Schema.instanceOf<Cause.IllegalArgumentError, Cause.IllegalArgumentError>>;
+}>, Cause.YieldableError>;
+export declare class UrlError extends UrlError_base {
+}
+export {};

package/dist/src/config/url/index.d.ts

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

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

@@ -1,5 +1,4 @@
 export { T3CodeConnectionError } from "./error.ts";
 export { T3CodeRpcLayer, makeT3CodeRpcLayer } from "./layer.ts";
-export { T3CodeNodeRpcLayer } from "./node.ts";
 export { T3CodeConnectionProvider, T3CodeConnectionProviderLive, makeT3CodeConnectionProvider, } from "./service.ts";
 export type { T3CodeAuth, T3CodeConnection, T3CodeOrigin } from "./type.ts";

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

@@ -1 +1 @@
-export type { OrchestrationMessage, OrchestrationProjectShell, OrchestrationShellSnapshot, OrchestrationThread, OrchestrationThreadShell, ServerProvider, } from "#t3tools/contracts";
+export type { OrchestrationMessage, OrchestrationProjectShell, OrchestrationShellSnapshot, OrchestrationThread, OrchestrationThreadShell, ServerProvider, } from "@t3tools/contracts";

package/dist/src/domain/error.d.ts

@@ -21,11 +21,37 @@ declare const ThreadSessionError_base: Schema.Class<ThreadSessionError, Schema.T
 }>, import("effect/Cause").YieldableError>;
 export declare class ThreadSessionError extends ThreadSessionError_base {
 }
+declare const ThreadLookupError_base: Schema.Class<ThreadLookupError, Schema.TaggedStruct<"ThreadLookupError", {
+    readonly message: Schema.String;
+    readonly threadId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ThreadLookupError extends ThreadLookupError_base {
+}
 declare const ProjectCreateVisibilityError_base: Schema.Class<ProjectCreateVisibilityError, Schema.TaggedStruct<"ProjectCreateVisibilityError", {
     readonly message: Schema.String;
     readonly projectId: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class ProjectCreateVisibilityError extends ProjectCreateVisibilityError_base {
 }
-export type DomainError = ProjectLookupError | ModelSelectionError | ThreadEventError | ThreadSessionError | ProjectCreateVisibilityError;
+declare const TerminalLookupError_base: Schema.Class<TerminalLookupError, Schema.TaggedStruct<"TerminalLookupError", {
+    readonly message: Schema.String;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class TerminalLookupError extends TerminalLookupError_base {
+}
+declare const ProjectActionLookupError_base: Schema.Class<ProjectActionLookupError, Schema.TaggedStruct<"ProjectActionLookupError", {
+    readonly message: Schema.String;
+    readonly projectId: Schema.String;
+    readonly selector: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ProjectActionLookupError extends ProjectActionLookupError_base {
+}
+declare const ProjectActionValidationError_base: Schema.Class<ProjectActionValidationError, Schema.TaggedStruct<"ProjectActionValidationError", {
+    readonly message: Schema.String;
+    readonly projectId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ProjectActionValidationError extends ProjectActionValidationError_base {
+}
+export type DomainError = ProjectLookupError | ModelSelectionError | ThreadEventError | ThreadSessionError | ThreadLookupError | ProjectCreateVisibilityError | TerminalLookupError | ProjectActionLookupError | ProjectActionValidationError;
 export {};