t3code-cli 0.11.0 → 0.12.0

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

@@ -40,5 +40,18 @@ declare const TerminalLookupError_base: Schema.Class<TerminalLookupError, Schema
 }>, import("effect/Cause").YieldableError>;
 export declare class TerminalLookupError extends TerminalLookupError_base {
 }
-export type DomainError = ProjectLookupError | ModelSelectionError | ThreadEventError | ThreadSessionError | ThreadLookupError | ProjectCreateVisibilityError | TerminalLookupError;
+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 {};

package/dist/src/domain/helpers.d.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;
     readonly inferredWorktreePath?: string;
@@ -25,6 +25,8 @@ export declare const resolveProjectScope: (snapshot: {
             readonly command: string;
             readonly icon: "play" | "test" | "lint" | "configure" | "build" | "debug";
             readonly runOnWorktreeCreate: boolean;
+            readonly previewUrl?: string | undefined;
+            readonly autoOpenPreview?: boolean | undefined;
         }[];
         readonly createdAt: string;
         readonly updatedAt: string;
@@ -83,6 +85,15 @@ export declare const resolveProjectScope: (snapshot: {
             readonly updatedAt: string;
             readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
         } | null;
+        readonly goal: {
+            readonly objective: string;
+            readonly status: "active" | "paused" | "blocked" | "usageLimited" | "budgetLimited" | "complete";
+            readonly tokensUsed: number;
+            readonly tokenBudget: number | null;
+            readonly timeUsedSeconds: number;
+            readonly createdAt: string;
+            readonly updatedAt: string;
+        } | null;
         readonly latestUserMessageAt: string | null;
         readonly hasPendingApprovals: boolean;
         readonly hasPendingUserInput: boolean;
@@ -110,6 +121,8 @@ export declare const resolveProjectScope: (snapshot: {
             readonly command: string;
             readonly icon: "play" | "test" | "lint" | "configure" | "build" | "debug";
             readonly runOnWorktreeCreate: boolean;
+            readonly previewUrl?: string | undefined;
+            readonly autoOpenPreview?: boolean | undefined;
         }[];
         readonly createdAt: string;
         readonly updatedAt: string;
@@ -147,6 +160,8 @@ export declare const resolveProjectScope: (snapshot: {
             readonly command: string;
             readonly icon: "play" | "test" | "lint" | "configure" | "build" | "debug";
             readonly runOnWorktreeCreate: boolean;
+            readonly previewUrl?: string | undefined;
+            readonly autoOpenPreview?: boolean | undefined;
         }[];
         readonly createdAt: string;
         readonly updatedAt: string;

package/dist/src/domain/model-config.d.ts

@@ -1,4 +1,4 @@
-import type { ServerProvider } from "#t3tools/contracts";
+import type { ServerProvider } from "@t3tools/contracts";
 export declare function isSelectableProvider(provider: ServerProvider): boolean;
 export declare function firstSelectableProvider(providers: ReadonlyArray<ServerProvider>): {
     readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
@@ -66,6 +66,7 @@ export declare function firstSelectableProvider(providers: ReadonlyArray<ServerP
         readonly groupKey: string;
     } | undefined;
     readonly showInteractionModeToggle?: boolean | undefined;
+    readonly requiresNewThreadForModelChange?: boolean | undefined;
     readonly message?: string | undefined;
     readonly availability?: "available" | "unavailable" | undefined;
     readonly unavailableReason?: string | undefined;
@@ -210,6 +211,7 @@ export declare function findSelectableProvider(providers: ReadonlyArray<ServerPr
         readonly groupKey: string;
     } | undefined;
     readonly showInteractionModeToggle?: boolean | undefined;
+    readonly requiresNewThreadForModelChange?: boolean | undefined;
     readonly message?: string | undefined;
     readonly availability?: "available" | "unavailable" | undefined;
     readonly unavailableReason?: string | undefined;
@@ -300,6 +302,7 @@ export declare function filterProvidersForModelListing(input: {
         readonly groupKey: string;
     } | undefined;
     readonly showInteractionModeToggle?: boolean | undefined;
+    readonly requiresNewThreadForModelChange?: boolean | undefined;
     readonly message?: string | undefined;
     readonly availability?: "available" | "unavailable" | undefined;
     readonly unavailableReason?: string | undefined;

package/dist/src/domain/thread-activities.d.ts

@@ -1,4 +1,4 @@
-import { ApprovalRequestId, type OrchestrationThreadActivity, type UserInputQuestion } from "#t3tools/contracts";
+import { ApprovalRequestId, type OrchestrationThreadActivity, type UserInputQuestion } from "@t3tools/contracts";
 export type PendingApproval = {
     readonly requestId: ApprovalRequestId;
     readonly requestKind: "command" | "file-read" | "file-change";

package/dist/src/domain/thread-lifecycle.d.ts

@@ -1,4 +1,4 @@
-import { type OrchestrationEvent, type OrchestrationMessage as OrchestrationMessageType, type OrchestrationSession, type OrchestrationThread, type OrchestrationThreadShell } from "#t3tools/contracts";
+import { type OrchestrationEvent, type OrchestrationMessage as OrchestrationMessageType, type OrchestrationSession, type OrchestrationThread, type OrchestrationThreadShell } from "@t3tools/contracts";
 export declare function sessionNeedsStopBeforeDelete(session: OrchestrationSession | null): boolean;
 export declare function isThreadActive(thread: OrchestrationThreadShell | OrchestrationThread): boolean;
 export type ThreadLifecycleStatus = ReturnType<typeof threadStatus>;
@@ -52,6 +52,15 @@ export declare function applyThreadEvent(current: OrchestrationThread, event: Or
     readonly updatedAt: string;
     readonly archivedAt: string | null;
     readonly deletedAt: string | null;
+    readonly goal: {
+        readonly objective: string;
+        readonly status: "active" | "paused" | "blocked" | "usageLimited" | "budgetLimited" | "complete";
+        readonly tokensUsed: number;
+        readonly tokenBudget: number | null;
+        readonly timeUsedSeconds: number;
+        readonly createdAt: string;
+        readonly updatedAt: string;
+    } | null;
     readonly messages: readonly {
         readonly id: string & import("effect/Brand").Brand<"MessageId">;
         readonly role: "user" | "assistant" | "system";

package/dist/src/index.d.ts

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

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

@@ -1,2 +1,2 @@
 import * as Layer from "effect/Layer";
-export declare const T3CodeNodeRpcLayer: Layer.Layer<import("../rpc/service.ts").T3Rpc, never, import("./service.ts").T3CodeConnectionProvider>;
+export declare const T3CodeNodeRpcLayer: Layer.Layer<import("../rpc/service.ts").T3Rpc, never, import("../connection/service.ts").T3CodeConnectionProvider>;

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

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

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

@@ -1,3 +1,2 @@
 export { T3Orchestration, type OpenThread, type Orchestration, type OrchestrationError, } from "./service.ts";
 export { makeT3Orchestration, T3OrchestrationLive } from "./layer.ts";
-export { T3OrchestrationLayer } from "../runtime/layer.ts";