t3code-cli 0.11.0 → 0.13.0

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

@@ -1,25 +1,53 @@
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import { T3Config } from "../config/service.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";
 export declare const makeT3Auth: () => Effect.Effect<{
     pair: (pairingUrl: string) => Effect.Effect<import("./type.ts").PairResult, import("./error.ts").AuthPairingUrlError | import("./error.ts").AuthTransportError>;
     local: (input: import("./type.ts").LocalAuthInput) => Effect.Effect<import("./type.ts").LocalAuthResult, import("./error.ts").AuthLocalError>;
     writeConfig: (input: AuthConfigInput) => Effect.Effect<void, AuthConfigError, never>;
+    persistEnvironment: (input: {
+        readonly name: string;
+        readonly url: string;
+        readonly token: string;
+        readonly local: boolean;
+        readonly replace?: boolean;
+        readonly allowReplace: boolean;
+    }) => Effect.Effect<string, AuthConfigError, never>;
+    environmentExists: (name: string) => Effect.Effect<boolean, AuthConfigError, never>;
+    defaultNameFromUrl: (url: string) => Effect.Effect<string, AuthConfigError, never>;
+    defaultNameForLocal: () => Effect.Effect<"local", never, never>;
+    listEnvironments: () => Effect.Effect<AuthEnvironmentListItem[], AuthConfigError, never>;
+    useEnvironment: (name: string) => Effect.Effect<{
+        name: string;
+        default: true;
+    }, AuthConfigError, never>;
+    resolveUnpairTarget: (input: {
+        readonly name?: string;
+    }) => Effect.Effect<string, AuthConfigError, never>;
+    unpairEnvironment: (input: {
+        readonly name: string;
+    }) => Effect.Effect<{
+        name: string;
+        removed: true;
+    }, AuthConfigError, never>;
     status: () => Effect.Effect<{
-        readonly authenticated: boolean;
-        readonly role?: "client" | "owner";
-        readonly sessionMethod?: string;
-        readonly expiresAt?: string;
+        readonly config: AuthResolvedConfig;
+        readonly session: {
+            readonly authenticated: boolean;
+            readonly role?: "client" | "owner";
+            readonly sessionMethod?: string;
+            readonly expiresAt?: string;
+        };
     }, AuthConfigError | import("./error.ts").AuthTransportError, never>;
     issueWebSocketTicket: () => Effect.Effect<{
         readonly ticket: string;
         readonly expiresAt: string;
     }, AuthConfigError | import("./error.ts").AuthTransportError, never>;
-}, never, T3Config | T3LocalAuth | T3AuthTransport | T3AuthPairing>;
-export declare const T3AuthLive: Layer.Layer<T3Auth, never, T3Config | T3LocalAuth | T3AuthTransport | T3AuthPairing>;
+}, never, T3AuthPairing | T3AuthTransport | T3Config | T3LocalAuth>;
+export declare const T3AuthLive: Layer.Layer<T3Auth, never, T3AuthPairing | T3AuthTransport | T3Config | T3LocalAuth>;

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

@@ -1,5 +1,8 @@
 import * as Effect from "effect/Effect";
-import { Environment } from "../environment/service.ts";
+import type { CliRuntime } from "../cli/runtime/service.ts";
+import type { T3CliEnvShape } from "../config/env/env.ts";
 export declare const resolveLocalBaseDir: (input: {
     readonly baseDir?: string | undefined;
-}) => Effect.Effect<string, never, Environment | import("effect/Path").Path>;
+    readonly cliRuntime: CliRuntime["Service"];
+    readonly t3CliEnv: T3CliEnvShape;
+}) => Effect.Effect<string, never, import("effect/Path").Path>;

package/dist/src/auth/local-origin.d.ts

@@ -3,7 +3,7 @@ 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 { CliRuntime } from "../cli/runtime/service.ts";
 import { AuthLocalError } from "./error.ts";
 import type { LocalAuthOriginInput } from "./type.ts";
 declare const T3LocalAuthOrigin_base: Context.ServiceClass<T3LocalAuthOrigin, "t3cli/T3LocalAuthOrigin", {
@@ -13,6 +13,6 @@ export declare class T3LocalAuthOrigin extends T3LocalAuthOrigin_base {
 }
 export declare const makeT3LocalAuthOrigin: () => Effect.Effect<{
     resolve: (input?: LocalAuthOriginInput | undefined) => Effect.Effect<string, AuthLocalError, never>;
-}, never, Environment | Path.Path | FileSystem.FileSystem>;
-export declare const T3LocalAuthOriginLive: Layer.Layer<T3LocalAuthOrigin, never, Environment | Path.Path | FileSystem.FileSystem>;
+}, import("effect/Config").ConfigError, CliRuntime | FileSystem.FileSystem | Path.Path>;
+export declare const T3LocalAuthOriginLive: Layer.Layer<T3LocalAuthOrigin, import("effect/Config").ConfigError, CliRuntime | FileSystem.FileSystem | Path.Path>;
 export {};

package/dist/src/auth/local-token.d.ts

@@ -4,7 +4,7 @@ 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 { CliRuntime } from "../cli/runtime/service.ts";
 import { SqlClientFactory } from "../sql/service.ts";
 import { AuthLocalError } from "./error.ts";
 import type { LocalAuthTokenInput, LocalAuthTokenResult } from "./type.ts";
@@ -21,6 +21,6 @@ export declare const makeT3LocalAuthToken: () => Effect.Effect<{
         source: "local";
         baseDir: string;
     }, AuthLocalError, never>;
-}, never, Environment | Path.Path | Crypto.Crypto | FileSystem.FileSystem | SqlClientFactory>;
-export declare const T3LocalAuthTokenLive: Layer.Layer<T3LocalAuthToken, never, Environment | Path.Path | Crypto.Crypto | FileSystem.FileSystem | SqlClientFactory>;
+}, import("effect/Config").ConfigError, CliRuntime | Crypto.Crypto | FileSystem.FileSystem | Path.Path | SqlClientFactory>;
+export declare const T3LocalAuthTokenLive: Layer.Layer<T3LocalAuthToken, import("effect/Config").ConfigError, CliRuntime | Crypto.Crypto | FileSystem.FileSystem | Path.Path | SqlClientFactory>;
 export {};

package/dist/src/auth/remote-error.d.ts

@@ -0,0 +1,3 @@
+import { RemoteEnvironmentAuthFetchError, RemoteEnvironmentAuthInvalidJsonError, RemoteEnvironmentAuthTimeoutError, RemoteEnvironmentAuthUndeclaredStatusError } from "@t3tools/client-runtime/authorization";
+import * as Schema from "effect/Schema";
+export declare const RemoteEnvironmentAuthErrorSchema: Schema.Union<readonly [Schema.Union<readonly [typeof import("@t3tools/contracts").EnvironmentRequestInvalidError, typeof import("@t3tools/contracts").EnvironmentAuthInvalidError, typeof import("@t3tools/contracts").EnvironmentScopeRequiredError, typeof import("@t3tools/contracts").EnvironmentOperationForbiddenError, typeof import("@t3tools/contracts").EnvironmentResourceNotFoundError, typeof import("@t3tools/contracts").EnvironmentInternalError]>, Schema.instanceOf<RemoteEnvironmentAuthFetchError, unknown>, Schema.instanceOf<RemoteEnvironmentAuthInvalidJsonError, unknown>, Schema.instanceOf<RemoteEnvironmentAuthTimeoutError, unknown>, Schema.instanceOf<RemoteEnvironmentAuthUndeclaredStatusError, unknown>]>;

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

@@ -1,13 +1,25 @@
 import * as Context from "effect/Context";
 import type * as Effect from "effect/Effect";
-import type { AuthSessionState, AuthWebSocketTicketResult } from "./schema.ts";
+import type { AuthWebSocketTicketResult } from "./schema.ts";
 import type { AuthError } from "./error.ts";
-import type { AuthConfigInput, LocalAuthInput, LocalAuthResult, PairResult } from "./type.ts";
+import type { AuthConfigInput, AuthEnvironmentListItem, AuthStatusResult, AuthUnpairResult, AuthUseResult, LocalAuthInput, LocalAuthResult, PairResult, PersistEnvironmentInput } from "./type.ts";
 declare const T3Auth_base: Context.ServiceClass<T3Auth, "t3cli/T3Auth", {
     readonly pair: (value: string) => Effect.Effect<PairResult, AuthError>;
     readonly local: (input: LocalAuthInput) => Effect.Effect<LocalAuthResult, AuthError>;
     readonly writeConfig: (input: AuthConfigInput) => Effect.Effect<void, AuthError>;
-    readonly status: () => Effect.Effect<AuthSessionState, AuthError>;
+    readonly persistEnvironment: (input: PersistEnvironmentInput) => Effect.Effect<string, AuthError>;
+    readonly environmentExists: (name: string) => Effect.Effect<boolean, AuthError>;
+    readonly defaultNameFromUrl: (url: string) => Effect.Effect<string, AuthError>;
+    readonly defaultNameForLocal: () => Effect.Effect<string, AuthError>;
+    readonly listEnvironments: () => Effect.Effect<readonly AuthEnvironmentListItem[], AuthError>;
+    readonly useEnvironment: (name: string) => Effect.Effect<AuthUseResult, AuthError>;
+    readonly unpairEnvironment: (input: {
+        readonly name: string;
+    }) => Effect.Effect<AuthUnpairResult, AuthError>;
+    readonly resolveUnpairTarget: (input: {
+        readonly name?: string;
+    }) => Effect.Effect<string, AuthError>;
+    readonly status: () => Effect.Effect<AuthStatusResult, AuthError>;
     readonly issueWebSocketTicket: () => Effect.Effect<AuthWebSocketTicketResult, AuthError>;
 }>;
 export declare class T3Auth extends T3Auth_base {

package/dist/src/auth/type.d.ts

@@ -1,13 +1,44 @@
 import type { AuthBearerBootstrapResult } from "./schema.ts";
+import type { AuthSessionState } from "./schema.ts";
 export type AuthSessionRole = AuthBearerBootstrapResult["role"];
 export type PairingUrl = {
     readonly baseUrl: string;
     readonly credential: string;
 };
 export type AuthConfigInput = {
+    readonly name: string;
     readonly url: string;
     readonly token: string;
-    readonly local?: boolean;
+    readonly local: boolean;
+    readonly makeDefault?: boolean;
+};
+export type PersistEnvironmentInput = {
+    readonly name: string;
+    readonly url: string;
+    readonly token: string;
+    readonly local: boolean;
+    readonly replace?: boolean;
+    readonly allowReplace: boolean;
+};
+export type AuthResolvedConfig = {
+    readonly url: string;
+    readonly token: string;
+    readonly source: "env" | "config";
+    readonly local: boolean;
+    readonly environment?: string;
+};
+export type AuthEnvironmentSummary = {
+    readonly name: string;
+    readonly url: string;
+    readonly local: boolean;
+    readonly default: boolean;
+};
+export type AuthStatusResult = {
+    readonly config: AuthResolvedConfig;
+    readonly session: AuthSessionState;
+};
+export type AuthEnvironmentListItem = AuthEnvironmentSummary & {
+    readonly active: boolean;
 };
 export type PairResult = {
     readonly url: string;
@@ -42,3 +73,11 @@ export type LocalAuthResult = {
     readonly source: "local";
     readonly baseDir: string;
 };
+export type AuthUseResult = {
+    readonly name: string;
+    readonly default: true;
+};
+export type AuthUnpairResult = {
+    readonly name: string;
+    readonly removed: true;
+};

package/dist/src/cli/env/flag.d.ts

@@ -0,0 +1,2 @@
+import { GlobalFlag } from "effect/unstable/cli";
+export declare const cliEnvironmentSetting: GlobalFlag.Setting<"environment", import("effect/Option").Option<string>>;

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

@@ -0,0 +1,2 @@
+export { cliEnvironmentSetting } from "./flag.ts";
+export * as Selection from "./selection-layer.ts";

package/dist/src/cli/env/selection-layer.d.ts

@@ -0,0 +1,3 @@
+import * as Layer from "effect/Layer";
+import { T3ConfigSelection } from "../../config/selection/service.ts";
+export declare const layer: Layer.Layer<T3ConfigSelection, import("effect/Config").ConfigError, never>;

package/dist/src/cli/flags.d.ts

@@ -4,6 +4,8 @@ export declare const threadFlag: Flag.Flag<import("effect/Option").Option<string
 export declare const worktreeFlag: Flag.Flag<import("effect/Option").Option<string>>;
 export declare const projectPathFlag: Flag.Flag<string>;
 export declare const yesFlag: Flag.Flag<boolean>;
+export declare const replaceFlag: Flag.Flag<boolean>;
+export declare const envNameFlag: Flag.Flag<import("effect/Option").Option<string>>;
 export declare const forceFlag: Flag.Flag<boolean>;
 export declare const selfActionForceFlag: Flag.Flag<boolean>;
 export declare const formatFlag: Flag.Flag<"auto" | "human" | "json">;

package/dist/src/cli/format/index.d.ts

@@ -0,0 +1 @@
+export { resolveOutputFormat, canRenderLiveTerminal, isInteractiveHumanTerminal, isAgentEnvironment, humanJsonFormatChoices, humanNdjsonFormatChoices, humanJsonNdjsonFormatChoices, type HumanJsonFormat, type HumanNdjsonFormat, type HumanJsonNdjsonFormat, } from "./output.ts";

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

@@ -0,0 +1,12 @@
+import type { T3CliEnvShape } from "../../config/env/env.ts";
+import type { CliRuntime } from "../runtime/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, cliRuntime: CliRuntime["Service"], t3CliEnv: T3CliEnvShape, nonHumanFormat: T): "human" | T;
+export declare function canRenderLiveTerminal(cliRuntime: CliRuntime["Service"], t3CliEnv: T3CliEnvShape): boolean;
+export declare function isInteractiveHumanTerminal(cliRuntime: CliRuntime["Service"], t3CliEnv: T3CliEnvShape): boolean;
+export declare function isAgentEnvironment(t3CliEnv: T3CliEnvShape): boolean;

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

@@ -1 +1,5 @@
 export { formatFlag, modelFlags, projectFlag, projectPathFlag, threadFlag, threadFormatFlag, waitFormatFlag, worktreeFlag, } from "./flags.ts";
+export * as Env from "./env/index.ts";
+export * as Runtime from "./runtime/index.ts";
+export { resolveCommandProjectRef, resolveProjectRef, resolveThreadId, resolveWorktreePath, } from "./scope/index.ts";
+export { resolveOutputFormat, canRenderLiveTerminal, isInteractiveHumanTerminal, isAgentEnvironment, humanJsonFormatChoices, humanNdjsonFormatChoices, humanJsonNdjsonFormatChoices, type HumanJsonFormat, type HumanNdjsonFormat, type HumanJsonNdjsonFormat, } from "./format/index.ts";

package/dist/src/cli/runtime/index.d.ts

@@ -0,0 +1 @@
+export { CliRuntime, layer } from "./service.ts";

package/dist/src/cli/runtime/service.d.ts

@@ -0,0 +1,16 @@
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+declare const CliRuntime_base: Context.ServiceClass<CliRuntime, "t3cli/CliRuntime", {
+    readonly cwd: string;
+    readonly stdoutIsTTY: boolean;
+    readonly stderrIsTTY: boolean;
+}>;
+export declare class CliRuntime extends CliRuntime_base {
+    static layerTest: (input?: {
+        readonly cwd?: string;
+        readonly stdoutIsTTY?: boolean;
+        readonly stderrIsTTY?: boolean;
+    }) => Layer.Layer<CliRuntime, never, never>;
+}
+export declare const layer: Layer.Layer<CliRuntime, never, never>;
+export {};

package/dist/src/{scope → cli/scope}/resolve.d.ts

@@ -1,19 +1,20 @@
+import type { T3CliEnvScope } from "../../config/env/env.ts";
 export declare function resolveProjectRef(input: {
     readonly value: string | undefined;
-    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly scope: T3CliEnvScope;
 }): string | undefined;
 export declare function resolveCommandProjectRef(input: {
     readonly value: string | undefined;
-    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly scope: T3CliEnvScope;
     readonly cwd: string;
     readonly isLocal?: boolean;
 }): string | undefined;
 export declare function resolveWorktreePath(input: {
     readonly value: string | undefined;
-    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly scope: T3CliEnvScope;
     readonly inferred?: string;
 }): string | undefined;
 export declare function resolveThreadId(input: {
     readonly value: string | undefined;
-    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly scope: T3CliEnvScope;
 }): string | undefined;

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

@@ -0,0 +1,49 @@
+import * as Context from "effect/Context";
+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 { T3CredentialCrypto } from "./credential/service.ts";
+import { ConfigError } from "./error.ts";
+import { T3ConfigSelection } from "./selection/service.ts";
+import type { EnvironmentSummary, ResolvedConfig, UpsertEnvironmentInput } from "./types.ts";
+declare const T3Config_base: Context.ServiceClass<T3Config, "t3cli/T3Config", {
+    readonly resolve: () => Effect.Effect<ResolvedConfig, ConfigError>;
+    readonly resolveActiveEnvironmentName: () => Effect.Effect<string | undefined, ConfigError>;
+    readonly listEnvironments: () => Effect.Effect<readonly EnvironmentSummary[], ConfigError>;
+    readonly upsertEnvironment: (input: UpsertEnvironmentInput) => Effect.Effect<void, ConfigError>;
+    readonly setDefaultEnvironment: (name: string) => Effect.Effect<void, ConfigError>;
+    readonly removeEnvironment: (name: string) => Effect.Effect<void, ConfigError>;
+    readonly hasEnvironment: (name: string) => Effect.Effect<boolean, ConfigError>;
+    readonly getDefaultEnvironmentName: () => Effect.Effect<string | undefined, ConfigError>;
+}>;
+export declare class T3Config extends T3Config_base {
+}
+export declare const make: () => Effect.Effect<{
+    readonly resolve: () => Effect.Effect<{
+        url: string;
+        token: string;
+        source: "env";
+        local: false;
+    } | {
+        url: string;
+        token: string;
+        source: "config";
+        local: boolean;
+        environment: string;
+    }, ConfigError, never>;
+    readonly resolveActiveEnvironmentName: () => Effect.Effect<string | undefined, ConfigError, never>;
+    readonly listEnvironments: () => Effect.Effect<{
+        name: string;
+        url: string;
+        local: boolean;
+        default: boolean;
+    }[], ConfigError, never>;
+    readonly upsertEnvironment: (input: UpsertEnvironmentInput) => Effect.Effect<void, ConfigError, never>;
+    readonly setDefaultEnvironment: (name: string) => Effect.Effect<void, ConfigError, never>;
+    readonly removeEnvironment: (name: string) => Effect.Effect<void, ConfigError, never>;
+    readonly hasEnvironment: (name: string) => Effect.Effect<boolean, ConfigError, never>;
+    readonly getDefaultEnvironmentName: () => Effect.Effect<string | undefined, ConfigError, never>;
+}, import("effect/Config").ConfigError, FileSystem.FileSystem | Path.Path | T3ConfigSelection | T3CredentialCrypto>;
+export declare const layer: Layer.Layer<T3Config, import("effect/Config").ConfigError, FileSystem.FileSystem | Path.Path | T3ConfigSelection | T3CredentialCrypto>;
+export {};

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

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

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

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

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, Crypto.Crypto | FileSystem.FileSystem | Path.Path | T3CredentialCipher | T3MasterKeyKeystoreFactory>;
+export declare const layer: Layer.Layer<T3CredentialCrypto, ConfigError, Crypto.Crypto | FileSystem.FileSystem | Path.Path | T3CredentialCipher | T3MasterKeyKeystoreFactory>;
+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, FileSystem.FileSystem | Path.Path>;

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>;