t3code-cli 0.12.0 → 0.14.0

package/dist/client-runtime/state/filesystem.js

@@ -0,0 +1,48 @@
+import { Fs as WS_METHODS, It as getBrowseDirectoryPath, Lt as getBrowseLeafPathSegment, Nt as canNavigateUp, Rt as getBrowseParentPath, Vt as isFilesystemBrowseQuery, fr as createEnvironmentRpcQueryAtomFamily, zt as hasTrailingPathSeparator } from "../../shared.js";
+//#region upstream-t3code/packages/client-runtime/src/state/filesystem.ts
+function getFilesystemBrowsePath(query, platform = "", enabled = true) {
+	const isBrowsing = enabled && isFilesystemBrowseQuery(query, platform);
+	const directoryPath = isBrowsing ? getBrowseDirectoryPath(query) : "";
+	return {
+		isBrowsing,
+		directoryPath,
+		filterQuery: isBrowsing && !hasTrailingPathSeparator(query) ? getBrowseLeafPathSegment(query) : "",
+		parentPath: isBrowsing ? getBrowseParentPath(directoryPath) : null,
+		canBrowseUp: isBrowsing && canNavigateUp(directoryPath)
+	};
+}
+function filterFilesystemBrowseEntries(entries, query) {
+	const lowerQuery = query.toLowerCase();
+	const showHidden = query.startsWith(".");
+	const visibleEntries = entries.filter((entry) => entry.name.toLowerCase().startsWith(lowerQuery) && (showHidden || !entry.name.startsWith(".")));
+	return {
+		visibleEntries,
+		exactEntry: query.length > 0 ? visibleEntries.find((entry) => entry.name === query) ?? null : null
+	};
+}
+function createBrowseNavigationCoordinator() {
+	let generation = 0;
+	return {
+		invalidate: () => {
+			generation += 1;
+		},
+		run: async (load, commit) => {
+			const navigationGeneration = ++generation;
+			await load();
+			if (navigationGeneration !== generation) return false;
+			commit();
+			return true;
+		}
+	};
+}
+function canPreloadBrowsePath(connectionPhase) {
+	return connectionPhase === "connected";
+}
+function createFilesystemEnvironmentAtoms(runtime) {
+	return { browse: createEnvironmentRpcQueryAtomFamily(runtime, {
+		label: "environment-data:filesystem:browse",
+		tag: WS_METHODS.filesystemBrowse
+	}) };
+}
+//#endregion
+export { canPreloadBrowsePath, createBrowseNavigationCoordinator, createFilesystemEnvironmentAtoms, filterFilesystemBrowseEntries, getFilesystemBrowsePath };

package/dist/client-runtime/state/git.d.ts

@@ -0,0 +1,43 @@
+import { AS as GitPullRequestMaterializationError, BS as TextGenerationError, ES as GitManagerError, TS as GitCommandError, bT as EnvironmentAuthorizationError, f as AtomCommand, hC as SourceControlProviderError, ha as EnvironmentRegistry, ma as EnvironmentNotRegisteredError, on as EnvironmentRpcUnavailableError, zT as EnvironmentId } from "../../shared.js";
+import { Atom } from "effect/unstable/reactivity";
+//#region upstream-t3code/packages/client-runtime/src/state/git.d.ts
+declare function createGitEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>): {
+  pullRequestResolution: (target: {
+    readonly environmentId: EnvironmentId;
+    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
+      readonly cwd: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
+      readonly reference: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
+    }>;
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly pullRequest: {
+      readonly number: number;
+      readonly title: string;
+      readonly url: string;
+      readonly baseBranch: string;
+      readonly headBranch: string;
+      readonly state: "closed" | "merged" | "open";
+    };
+  }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | GitCommandError | GitManagerError | GitPullRequestMaterializationError | import("effect/unstable/rpc/RpcClientError").RpcClientError | SourceControlProviderError | TextGenerationError>>;
+  preparePullRequestThread: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly cwd: string;
+      readonly reference: string;
+      readonly mode: "local" | "worktree";
+      readonly threadId?: (string & import("effect/Brand").Brand<"ThreadId">) | undefined;
+    };
+  }, {
+    readonly pullRequest: {
+      readonly number: number;
+      readonly title: string;
+      readonly url: string;
+      readonly baseBranch: string;
+      readonly headBranch: string;
+      readonly state: "closed" | "merged" | "open";
+    };
+    readonly branch: string;
+    readonly worktreePath: string | null;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | GitCommandError | GitManagerError | GitPullRequestMaterializationError | import("effect/unstable/rpc/RpcClientError").RpcClientError | SourceControlProviderError | TextGenerationError>;
+};
+//#endregion
+export { createGitEnvironmentAtoms };

package/dist/client-runtime/state/git.js

@@ -0,0 +1,18 @@
+import { Fs as WS_METHODS, St as vcsCommandScheduler, dr as createEnvironmentRpcCommand, fr as createEnvironmentRpcQueryAtomFamily, xt as vcsCommandConcurrency } from "../../shared.js";
+//#region upstream-t3code/packages/client-runtime/src/state/git.ts
+function createGitEnvironmentAtoms(runtime) {
+	return {
+		pullRequestResolution: createEnvironmentRpcQueryAtomFamily(runtime, {
+			label: "environment-data:git:resolve-pull-request",
+			tag: WS_METHODS.gitResolvePullRequest
+		}),
+		preparePullRequestThread: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:git:prepare-pull-request-thread",
+			tag: WS_METHODS.gitPreparePullRequestThread,
+			scheduler: vcsCommandScheduler,
+			concurrency: vcsCommandConcurrency
+		})
+	};
+}
+//#endregion
+export { createGitEnvironmentAtoms };

package/dist/client-runtime/state/models.d.ts

@@ -0,0 +1,2 @@
+import { at as EnvironmentThreadShell, ct as scopeThreadShell, it as EnvironmentThread, lt as selectEnvironmentThreadShell, nt as EnvironmentMessage, ot as scopeProject, rt as EnvironmentProject, st as scopeThread } from "../../shared.js";
+export { EnvironmentMessage, EnvironmentProject, EnvironmentThread, EnvironmentThreadShell, scopeProject, scopeThread, scopeThreadShell, selectEnvironmentThreadShell };

package/dist/client-runtime/state/models.js

@@ -0,0 +1,2 @@
+import { ar as scopeProject, cr as selectEnvironmentThreadShell, or as scopeThread, sr as scopeThreadShell } from "../../shared.js";
+export { scopeProject, scopeThread, scopeThreadShell, selectEnvironmentThreadShell };

package/dist/client-runtime/state/orchestration.d.ts

@@ -0,0 +1,128 @@
+import { K_ as OrchestrationGetSnapshotError, U_ as OrchestrationGetFullThreadDiffError, bT as EnvironmentAuthorizationError, ha as EnvironmentRegistry, on as EnvironmentRpcUnavailableError, q_ as OrchestrationGetTurnDiffError, zT as EnvironmentId } from "../../shared.js";
+import { Atom } from "effect/unstable/reactivity";
+//#region upstream-t3code/packages/client-runtime/src/state/orchestration.d.ts
+declare function createOrchestrationEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>): {
+  turnDiff: (target: {
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly fromTurnCount: number;
+      readonly toTurnCount: number;
+      readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+      readonly ignoreWhitespace?: boolean;
+    };
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly fromTurnCount: number;
+    readonly toTurnCount: number;
+    readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+    readonly diff: string;
+  }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | OrchestrationGetTurnDiffError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
+  fullThreadDiff: (target: {
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+      readonly toTurnCount: number;
+      readonly ignoreWhitespace?: boolean;
+    };
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly fromTurnCount: number;
+    readonly toTurnCount: number;
+    readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+    readonly diff: string;
+  }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | OrchestrationGetFullThreadDiffError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
+  archivedShellSnapshot: (target: {
+    readonly environmentId: EnvironmentId;
+    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{}>;
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly snapshotSequence: number;
+    readonly projects: readonly {
+      readonly id: string & import("effect/Brand").Brand<"ProjectId">;
+      readonly title: string;
+      readonly workspaceRoot: string;
+      readonly repositoryIdentity?: {
+        readonly canonicalKey: string;
+        readonly locator: {
+          readonly source: "git-remote";
+          readonly remoteName: string;
+          readonly remoteUrl: string;
+        };
+        readonly rootPath?: string;
+        readonly displayName?: string;
+        readonly provider?: string;
+        readonly owner?: string;
+        readonly name?: string;
+      } | null | undefined;
+      readonly defaultModelSelection: {
+        readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+        readonly model: string;
+        readonly options?: readonly {
+          readonly id: string;
+          readonly value: string | boolean;
+        }[];
+      } | null;
+      readonly scripts: readonly {
+        readonly id: string;
+        readonly name: string;
+        readonly command: string;
+        readonly icon: "build" | "configure" | "debug" | "lint" | "play" | "test";
+        readonly runOnWorktreeCreate: boolean;
+        readonly previewUrl?: string | undefined;
+        readonly autoOpenPreview?: boolean | undefined;
+      }[];
+      readonly createdAt: string;
+      readonly updatedAt: string;
+    }[];
+    readonly threads: readonly {
+      readonly id: string & import("effect/Brand").Brand<"ThreadId">;
+      readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+      readonly title: string;
+      readonly modelSelection: {
+        readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+        readonly model: string;
+        readonly options?: readonly {
+          readonly id: string;
+          readonly value: string | boolean;
+        }[];
+      };
+      readonly runtimeMode: "approval-required" | "auto" | "auto-accept-edits" | "full-access";
+      readonly interactionMode: "default" | "plan";
+      readonly branch: string | null;
+      readonly worktreePath: string | null;
+      readonly latestTurn: {
+        readonly turnId: string & import("effect/Brand").Brand<"TurnId">;
+        readonly state: "completed" | "error" | "interrupted" | "running";
+        readonly requestedAt: string;
+        readonly startedAt: string | null;
+        readonly completedAt: string | null;
+        readonly assistantMessageId: (string & import("effect/Brand").Brand<"MessageId">) | null;
+        readonly sourceProposedPlan?: {
+          readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+          readonly planId: string;
+        } | undefined;
+      } | null;
+      readonly createdAt: string;
+      readonly updatedAt: string;
+      readonly archivedAt: string | null;
+      readonly settledOverride: "active" | "settled" | null;
+      readonly settledAt: string | null;
+      readonly snoozedUntil?: string | null | undefined;
+      readonly snoozedAt?: string | null | undefined;
+      readonly session: {
+        readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+        readonly status: "error" | "idle" | "interrupted" | "ready" | "running" | "starting" | "stopped";
+        readonly providerName: string | null;
+        readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
+        readonly runtimeMode: "approval-required" | "auto" | "auto-accept-edits" | "full-access";
+        readonly activeTurnId: (string & import("effect/Brand").Brand<"TurnId">) | null;
+        readonly lastError: string | null;
+        readonly updatedAt: string;
+      } | null;
+      readonly latestUserMessageAt: string | null;
+      readonly hasPendingApprovals: boolean;
+      readonly hasPendingUserInput: boolean;
+      readonly hasActionableProposedPlan: boolean;
+    }[];
+    readonly updatedAt: string;
+  }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | OrchestrationGetSnapshotError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
+};
+//#endregion
+export { createOrchestrationEnvironmentAtoms };

package/dist/client-runtime/state/orchestration.js

@@ -0,0 +1,20 @@
+import { fr as createEnvironmentRpcQueryAtomFamily, ky as ORCHESTRATION_WS_METHODS } from "../../shared.js";
+//#region upstream-t3code/packages/client-runtime/src/state/orchestration.ts
+function createOrchestrationEnvironmentAtoms(runtime) {
+	return {
+		turnDiff: createEnvironmentRpcQueryAtomFamily(runtime, {
+			label: "environment-data:orchestration:turn-diff",
+			tag: ORCHESTRATION_WS_METHODS.getTurnDiff
+		}),
+		fullThreadDiff: createEnvironmentRpcQueryAtomFamily(runtime, {
+			label: "environment-data:orchestration:full-thread-diff",
+			tag: ORCHESTRATION_WS_METHODS.getFullThreadDiff
+		}),
+		archivedShellSnapshot: createEnvironmentRpcQueryAtomFamily(runtime, {
+			label: "environment-data:orchestration:archived-shell-snapshot",
+			tag: ORCHESTRATION_WS_METHODS.getArchivedShellSnapshot
+		})
+	};
+}
+//#endregion
+export { createOrchestrationEnvironmentAtoms };

package/dist/client-runtime/state/presentation.d.ts

@@ -0,0 +1,277 @@
+import { Ao as ConnectionCatalogEntry, Fl as ServerConfig, Gi as EnvironmentConnectionPresentation, Ki as EnvironmentPresentation, Ku as KeybindingWhenNode, os as SupervisorConnectionState, u as EnvironmentCatalogState, zT as EnvironmentId } from "../../shared.js";
+import { AsyncResult, Atom } from "effect/unstable/reactivity";
+//#region upstream-t3code/packages/client-runtime/src/state/presentation.d.ts
+declare function createEnvironmentPresentationAtoms<E>(input: {
+  readonly catalogValueAtom: Atom.Atom<EnvironmentCatalogState>;
+  readonly stateAtom: (environmentId: EnvironmentId) => Atom.Atom<AsyncResult.AsyncResult<SupervisorConnectionState, E>>;
+  /** Authoritative live server config, including streamed provider/settings updates. */
+  readonly serverConfigValueAtom: (environmentId: EnvironmentId) => Atom.Atom<ServerConfig | null>;
+}): {
+  presentationAtom: (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<{
+    entry: ConnectionCatalogEntry;
+    connection: EnvironmentConnectionPresentation;
+    serverConfig: {
+      readonly environment: {
+        readonly environmentId: string & import("effect/Brand").Brand<"EnvironmentId">;
+        readonly label: string;
+        readonly platform: {
+          readonly os: "darwin" | "linux" | "unknown" | "windows";
+          readonly arch: "arm64" | "other" | "x64";
+        };
+        readonly serverVersion: string;
+        readonly capabilities: {
+          readonly repositoryIdentity: boolean;
+          readonly connectionProbe?: boolean;
+          readonly threadSettlement?: boolean;
+          readonly threadSnooze?: boolean;
+          readonly serverSelfUpdate?: "boot-service" | "desktop-managed" | "respawn";
+        };
+      };
+      readonly auth: {
+        readonly policy: "desktop-managed-local" | "loopback-browser" | "remote-reachable" | "unsafe-no-auth";
+        readonly bootstrapMethods: readonly ("desktop-bootstrap" | "one-time-token")[];
+        readonly sessionMethods: readonly ("bearer-access-token" | "browser-session-cookie" | "dpop-access-token")[];
+        readonly sessionCookieName: string;
+      };
+      readonly cwd: string;
+      readonly keybindingsConfigPath: string;
+      readonly keybindings: readonly {
+        readonly command: "chat.new" | "chat.newLocal" | "commandPalette.toggle" | "composer.stash" | "diff.toggle" | "editor.openFavorite" | "modelPicker.jump.1" | "modelPicker.jump.2" | "modelPicker.jump.3" | "modelPicker.jump.4" | "modelPicker.jump.5" | "modelPicker.jump.6" | "modelPicker.jump.7" | "modelPicker.jump.8" | "modelPicker.jump.9" | "modelPicker.toggle" | "preview.focusUrl" | "preview.refresh" | "preview.resetZoom" | "preview.toggle" | "preview.zoomIn" | "preview.zoomOut" | "rightPanel.toggle" | "sidebar.toggle" | "terminal.close" | "terminal.new" | "terminal.split" | "terminal.splitVertical" | "terminal.toggle" | "thread.jump.1" | "thread.jump.2" | "thread.jump.3" | "thread.jump.4" | "thread.jump.5" | "thread.jump.6" | "thread.jump.7" | "thread.jump.8" | "thread.jump.9" | "thread.next" | "thread.previous" | `script.${string}.run`;
+        readonly shortcut: {
+          readonly key: string;
+          readonly metaKey: boolean;
+          readonly ctrlKey: boolean;
+          readonly shiftKey: boolean;
+          readonly altKey: boolean;
+          readonly modKey: boolean;
+        };
+        readonly whenAst?: {
+          readonly type: "identifier";
+          readonly name: string;
+        } | {
+          readonly type: "not";
+          readonly node: KeybindingWhenNode;
+        } | {
+          readonly type: "and";
+          readonly left: KeybindingWhenNode;
+          readonly right: KeybindingWhenNode;
+        } | {
+          readonly type: "or";
+          readonly left: KeybindingWhenNode;
+          readonly right: KeybindingWhenNode;
+        } | undefined;
+      }[];
+      readonly issues: readonly ({
+        readonly kind: "keybindings.malformed-config";
+        readonly message: string;
+      } | {
+        readonly kind: "keybindings.invalid-entry";
+        readonly message: string;
+        readonly index: number;
+      })[];
+      readonly providers: readonly {
+        readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+        readonly driver: string & import("effect/Brand").Brand<"ProviderDriverKind">;
+        readonly displayName?: string | undefined;
+        readonly accentColor?: string | undefined;
+        readonly badgeLabel?: string | undefined;
+        readonly continuation?: {
+          readonly groupKey: string;
+        } | undefined;
+        readonly showInteractionModeToggle?: boolean | undefined;
+        readonly requiresNewThreadForModelChange?: boolean | undefined;
+        readonly enabled: boolean;
+        readonly installed: boolean;
+        readonly version: string | null;
+        readonly status: "disabled" | "error" | "ready" | "warning";
+        readonly auth: {
+          readonly status: "authenticated" | "unauthenticated" | "unknown";
+          readonly type?: string | undefined;
+          readonly label?: string | undefined;
+          readonly email?: string | undefined;
+        };
+        readonly checkedAt: string;
+        readonly message?: string | undefined;
+        readonly availability?: "available" | "unavailable" | undefined;
+        readonly unavailableReason?: string | undefined;
+        readonly models: readonly {
+          readonly slug: string;
+          readonly name: string;
+          readonly shortName?: string | undefined;
+          readonly subProvider?: string | undefined;
+          readonly isCustom: boolean;
+          readonly isDefault?: boolean | undefined;
+          readonly capabilities: {
+            readonly optionDescriptors?: readonly ({
+              readonly id: string;
+              readonly label: string;
+              readonly description?: string | undefined;
+              readonly type: "select";
+              readonly options: readonly {
+                readonly id: string;
+                readonly label: string;
+                readonly description?: string | undefined;
+                readonly isDefault?: boolean | undefined;
+              }[];
+              readonly currentValue?: string | undefined;
+              readonly promptInjectedValues?: readonly string[] | undefined;
+            } | {
+              readonly id: string;
+              readonly label: string;
+              readonly description?: string | undefined;
+              readonly type: "boolean";
+              readonly currentValue?: boolean | undefined;
+            })[] | undefined;
+          } | null;
+        }[];
+        readonly slashCommands: readonly {
+          readonly name: string;
+          readonly description?: string | undefined;
+          readonly input?: {
+            readonly hint: string;
+          } | undefined;
+        }[];
+        readonly skills: readonly {
+          readonly name: string;
+          readonly description?: string | undefined;
+          readonly path: string;
+          readonly scope?: string | undefined;
+          readonly enabled: boolean;
+          readonly displayName?: string | undefined;
+          readonly shortDescription?: string | undefined;
+        }[];
+        readonly versionAdvisory?: {
+          readonly status: "behind_latest" | "current" | "unknown";
+          readonly currentVersion: string | null;
+          readonly latestVersion: string | null;
+          readonly updateCommand: string | null;
+          readonly canUpdate: boolean;
+          readonly checkedAt: string | null;
+          readonly message: string | null;
+        };
+        readonly updateState?: {
+          readonly status: "failed" | "idle" | "queued" | "running" | "succeeded" | "unchanged";
+          readonly startedAt: string | null;
+          readonly finishedAt: string | null;
+          readonly message: string | null;
+          readonly output: string | null;
+        };
+      }[];
+      readonly availableEditors: readonly ("antigravity" | "aqua" | "clion" | "cursor" | "datagrip" | "dataspell" | "file-manager" | "goland" | "idea" | "kiro" | "phpstorm" | "pycharm" | "rider" | "rubymine" | "rustrover" | "trae" | "vscode" | "vscode-insiders" | "vscodium" | "webstorm" | "zed")[];
+      readonly observability: {
+        readonly logsDirectoryPath: string;
+        readonly localTracingEnabled: boolean;
+        readonly otlpTracesUrl?: string | undefined;
+        readonly otlpTracesEnabled: boolean;
+        readonly otlpMetricsUrl?: string | undefined;
+        readonly otlpMetricsEnabled: boolean;
+      };
+      readonly settings: {
+        readonly enableAssistantStreaming: boolean;
+        readonly enableProviderUpdateChecks: boolean;
+        readonly backgroundActivity: {
+          readonly schemaVersion: 1;
+          readonly profile: "balanced" | "battery-saver" | "custom" | "performance";
+          readonly baseProfile?: "balanced" | "battery-saver" | "performance";
+          readonly overrides: {
+            readonly automaticGitFetchInterval?: import("effect/Duration").Duration;
+            readonly providerHealthRefreshInterval?: import("effect/Duration").Duration;
+            readonly hostPowerMonitorActiveInterval?: import("effect/Duration").Duration;
+            readonly hostPowerMonitorIdleInterval?: import("effect/Duration").Duration;
+            readonly idleClientTtl?: import("effect/Duration").Duration;
+            readonly pauseWhenHostLocked?: boolean;
+            readonly pauseWhenHostLowPower?: boolean;
+            readonly pauseWhenClientLowPower?: boolean;
+            readonly pauseWhenOnBattery?: boolean;
+          };
+        };
+        readonly automaticGitFetchInterval: import("effect/Duration").Duration;
+        readonly providerHealthRefreshInterval: import("effect/Duration").Duration;
+        readonly backgroundActivityProfile: "balanced" | "battery-saver" | "performance";
+        readonly defaultThreadEnvMode: "local" | "worktree";
+        readonly newWorktreesStartFromOrigin: boolean;
+        readonly addProjectBaseDirectory: string;
+        readonly textGenerationModelSelection: {
+          readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+          readonly model: string;
+          readonly options?: readonly {
+            readonly id: string;
+            readonly value: string | boolean;
+          }[];
+        };
+        readonly sourceControlWritingStyle: {
+          readonly mode: "conventional_commits" | "custom" | "repo_conventions";
+          readonly customInstructions: string;
+          readonly followChangeRequestTemplates: boolean;
+        };
+        readonly sourceControlWriterModelSelection: {
+          readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+          readonly model: string;
+          readonly options?: readonly {
+            readonly id: string;
+            readonly value: string | boolean;
+          }[];
+        } | null;
+        readonly providers: {
+          readonly codex: {
+            readonly enabled: boolean;
+            readonly binaryPath: string;
+            readonly homePath: string;
+            readonly shadowHomePath: string;
+            readonly launchArgs: string;
+            readonly customModels: readonly string[];
+          };
+          readonly claudeAgent: {
+            readonly enabled: boolean;
+            readonly binaryPath: string;
+            readonly homePath: string;
+            readonly customModels: readonly string[];
+            readonly launchArgs: string;
+          };
+          readonly cursor: {
+            readonly enabled: boolean;
+            readonly binaryPath: string;
+            readonly apiEndpoint: string;
+            readonly customModels: readonly string[];
+          };
+          readonly grok: {
+            readonly enabled: boolean;
+            readonly binaryPath: string;
+            readonly customModels: readonly string[];
+          };
+          readonly opencode: {
+            readonly enabled: boolean;
+            readonly binaryPath: string;
+            readonly serverUrl: string;
+            readonly serverPassword: string;
+            readonly customModels: readonly string[];
+          };
+        };
+        readonly providerInstances: {
+          readonly [x: string & import("effect/Brand").Brand<"ProviderInstanceId">]: {
+            readonly driver: string & import("effect/Brand").Brand<"ProviderDriverKind">;
+            readonly displayName?: string | undefined;
+            readonly accentColor?: string | undefined;
+            readonly environment?: readonly {
+              readonly name: string;
+              readonly value: string;
+              readonly sensitive: boolean;
+              readonly valueRedacted?: boolean;
+            }[];
+            readonly enabled?: boolean;
+            readonly config?: unknown;
+          };
+        };
+        readonly observability: {
+          readonly otlpTracesUrl: string;
+          readonly otlpMetricsUrl: string;
+        };
+      };
+      readonly shellResumeCompletionMarker?: boolean;
+      readonly threadResumeCompletionMarker?: boolean;
+    } | null;
+  } | null>;
+  presentationsAtom: Atom.Atom<ReadonlyMap<string & import("effect/Brand").Brand<"EnvironmentId">, EnvironmentPresentation>>;
+};
+//#endregion
+export { createEnvironmentPresentationAtoms };

package/dist/client-runtime/state/presentation.js

@@ -0,0 +1,34 @@
+import { Fk as getOrElse, Gr as family, Xr as withLabel, na as presentEnvironmentConnection, qr as make, ti as value, us as AVAILABLE_CONNECTION_STATE } from "../../shared.js";
+//#region upstream-t3code/packages/client-runtime/src/state/presentation.ts
+function mapsEqual(left, right) {
+	if (left.size !== right.size) return false;
+	for (const [key, value] of left) if (right.get(key) !== value) return false;
+	return true;
+}
+function createEnvironmentPresentationAtoms(input) {
+	const presentationAtom = family((environmentId) => make((get) => {
+		const entry = get(input.catalogValueAtom).entries.get(environmentId);
+		if (entry === void 0) return null;
+		return {
+			entry,
+			connection: presentEnvironmentConnection(getOrElse(value(get(input.stateAtom(environmentId))), () => AVAILABLE_CONNECTION_STATE)),
+			serverConfig: get(input.serverConfigValueAtom(environmentId))
+		};
+	}).pipe(withLabel(`environment-presentation:${environmentId}`)));
+	let previous = /* @__PURE__ */ new Map();
+	return {
+		presentationAtom,
+		presentationsAtom: make((get) => {
+			const next = /* @__PURE__ */ new Map();
+			for (const environmentId of get(input.catalogValueAtom).entries.keys()) {
+				const presentation = get(presentationAtom(environmentId));
+				if (presentation !== null) next.set(environmentId, presentation);
+			}
+			if (mapsEqual(previous, next)) return previous;
+			previous = next;
+			return previous;
+		}).pipe(withLabel("environment-presentations"))
+	};
+}
+//#endregion
+export { createEnvironmentPresentationAtoms };