t3code-cli 0.12.0 → 0.14.0

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

@@ -0,0 +1,529 @@
+import { Ca as EnvironmentCacheStore, Cl as ExternalLauncherBrowserSpawnError, Dl as ExternalLauncherUnknownEditorError, Fl as ServerConfig, Ku as KeybindingWhenNode, Ol as ExternalLauncherUnsupportedEditorError, Tl as ExternalLauncherEditorSpawnError, Ua as RemoteEnvironmentRequestError, _a as EnvironmentSupervisor, at as EnvironmentThreadShell, bT as EnvironmentAuthorizationError, ct as scopeThreadShell, cv as OrchestrationShellSnapshot, es as PreparedConnection, f as AtomCommand, ha as EnvironmentRegistry, it as EnvironmentThread, lt as selectEnvironmentThreadShell, lv as OrchestrationShellStreamEvent, ma as EnvironmentNotRegisteredError, nt as EnvironmentMessage, on as EnvironmentRpcUnavailableError, ot as scopeProject, rt as EnvironmentProject, st as scopeThread, u as EnvironmentCatalogState, uo as ManagedRelayDpopSigner, wl as ExternalLauncherCommandNotFoundError, zT as EnvironmentId } from "../../shared.js";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Option from "effect/Option";
+import * as Layer from "effect/Layer";
+import { HttpClient } from "effect/unstable/http";
+import * as SubscriptionRef from "effect/SubscriptionRef";
+import * as Cause from "effect/Cause";
+import { AsyncResult, Atom } from "effect/unstable/reactivity";
+//#region upstream-t3code/packages/client-runtime/src/state/shellSnapshotHttp.d.ts
+/**
+ * Load the environment shell snapshot (projects + thread shells) over HTTP
+ * instead of as the WebSocket subscription's first frame. The response is
+ * gzip-compressible by the transport and keeps the (potentially large) list off
+ * the socket.
+ */
+declare const fetchEnvironmentShellSnapshot: (input: {
+  readonly prepared: PreparedConnection;
+  readonly signer: Option.Option<ManagedRelayDpopSigner["Service"]>;
+  readonly timeoutMs?: number;
+}) => Effect.Effect<{
+  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;
+}, RemoteEnvironmentRequestError, HttpClient.HttpClient>;
+declare const ShellSnapshotLoader_base: Context.ServiceClass<ShellSnapshotLoader, "@t3tools/client-runtime/state/shellSnapshotHttp/ShellSnapshotLoader", {
+  readonly load: (prepared: PreparedConnection) => Effect.Effect<Option.Option<OrchestrationShellSnapshot>>;
+}>;
+/**
+ * Loads the environment shell snapshot over HTTP, returning `Option.none()` when
+ * it cannot be loaded (so the caller falls back to the socket-embedded snapshot).
+ * Decouples the shell state machine from the underlying HTTP + DPoP details and
+ * keeps them out of test contexts.
+ */
+declare class ShellSnapshotLoader extends ShellSnapshotLoader_base {}
+declare const shellSnapshotLoaderLayer: Layer.Layer<ShellSnapshotLoader, never, HttpClient.HttpClient>;
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/shellCommands.d.ts
+declare function createShellEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>): {
+  openInEditor: AtomCommand<{
+    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 editor: import("effect/Schema").Literals<("antigravity" | "aqua" | "clion" | "cursor" | "datagrip" | "dataspell" | "file-manager" | "goland" | "idea" | "kiro" | "phpstorm" | "pycharm" | "rider" | "rubymine" | "rustrover" | "trae" | "vscode" | "vscode-insiders" | "vscodium" | "webstorm" | "zed")[]>;
+    }>;
+  }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | ExternalLauncherBrowserSpawnError | ExternalLauncherCommandNotFoundError | ExternalLauncherEditorSpawnError | ExternalLauncherUnknownEditorError | ExternalLauncherUnsupportedEditorError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+};
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/shellReducer.d.ts
+/**
+ * Reduce a single shell stream event into an existing snapshot, returning a new
+ * snapshot with the event's changes applied. This is a pure reducer that both
+ * web and mobile can use to keep their local shell snapshot in sync.
+ *
+ * Returns the original snapshot reference unchanged if the event is not
+ * recognized (forward-compatible).
+ */
+declare function applyShellStreamEvent(snapshot: OrchestrationShellSnapshot, event: OrchestrationShellStreamEvent): OrchestrationShellSnapshot;
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/snapshots.d.ts
+declare function createEnvironmentSnapshotAtom<E>(shellStateAtom: (environmentId: EnvironmentId) => Atom.Atom<AsyncResult.AsyncResult<EnvironmentShellState, E>>): (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<{
+  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;
+} | null>;
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/shell.d.ts
+type EnvironmentShellStatus = "empty" | "cached" | "synchronizing" | "live";
+interface EnvironmentShellState {
+  readonly snapshot: Option.Option<OrchestrationShellSnapshot>;
+  readonly status: EnvironmentShellStatus;
+  readonly error: Option.Option<string>;
+}
+declare const makeEnvironmentShellState: () => Effect.Effect<SubscriptionRef.SubscriptionRef<EnvironmentShellState>, never, EnvironmentCacheStore | EnvironmentSupervisor | import("effect/Scope").Scope | ShellSnapshotLoader>;
+declare function shellStateChanges(environmentId: EnvironmentId): Stream.Stream<EnvironmentShellState, never, EnvironmentCacheStore | EnvironmentRegistry | ShellSnapshotLoader>;
+interface EnvironmentShellSummary {
+  readonly hasSnapshot: boolean;
+  readonly hasSynchronizingShell: boolean;
+  readonly hasCachedShell: boolean;
+  readonly hasLiveShell: boolean;
+  readonly firstError: string | null;
+  readonly latestSnapshotUpdatedAt: string | null;
+}
+declare function createEnvironmentShellSummaryAtom(input: {
+  readonly catalogValueAtom: Atom.Atom<EnvironmentCatalogState>;
+  readonly shellStateValueAtom: (environmentId: EnvironmentId) => Atom.Atom<EnvironmentShellState>;
+}): Atom.Atom<EnvironmentShellSummary>;
+declare function createEnvironmentServerConfigsAtom(input: {
+  readonly catalogValueAtom: Atom.Atom<EnvironmentCatalogState>;
+  readonly serverConfigValueAtom: (environmentId: EnvironmentId) => Atom.Atom<ServerConfig | null>;
+}): Atom.Atom<ReadonlyMap<string & import("effect/Brand").Brand<"EnvironmentId">, {
+  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;
+}>>;
+declare function createEnvironmentShellAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | EnvironmentCacheStore | ShellSnapshotLoader | R, E>): {
+  stateAtom: (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<AsyncResult.AsyncResult<EnvironmentShellState, E | Cause.NoSuchElementError>>;
+  stateValueAtom: (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<EnvironmentShellState>;
+};
+//#endregion
+export { EnvironmentMessage, EnvironmentProject, EnvironmentShellState, EnvironmentShellStatus, EnvironmentShellSummary, EnvironmentThread, EnvironmentThreadShell, ShellSnapshotLoader, applyShellStreamEvent, createEnvironmentServerConfigsAtom, createEnvironmentShellAtoms, createEnvironmentShellSummaryAtom, createEnvironmentSnapshotAtom, createShellEnvironmentAtoms, fetchEnvironmentShellSnapshot, makeEnvironmentShellState, scopeProject, scopeThread, scopeThreadShell, selectEnvironmentThreadShell, shellSnapshotLoaderLayer, shellStateChanges };

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

@@ -0,0 +1,2 @@
+import { $n as createEnvironmentShellAtoms, Mr as ShellSnapshotLoader, Nr as fetchEnvironmentShellSnapshot, Pr as shellSnapshotLoaderLayer, Qn as createEnvironmentServerConfigsAtom, ar as scopeProject, cr as selectEnvironmentThreadShell, er as createEnvironmentShellSummaryAtom, ir as createShellEnvironmentAtoms, jr as applyShellStreamEvent, nr as shellStateChanges, or as scopeThread, rr as createEnvironmentSnapshotAtom, sr as scopeThreadShell, tr as makeEnvironmentShellState } from "../../shared.js";
+export { ShellSnapshotLoader, applyShellStreamEvent, createEnvironmentServerConfigsAtom, createEnvironmentShellAtoms, createEnvironmentShellSummaryAtom, createEnvironmentSnapshotAtom, createShellEnvironmentAtoms, fetchEnvironmentShellSnapshot, makeEnvironmentShellState, scopeProject, scopeThread, scopeThreadShell, selectEnvironmentThreadShell, shellSnapshotLoaderLayer, shellStateChanges };

package/dist/client-runtime/state/source-control.d.ts

@@ -0,0 +1,92 @@
+import { Ca as EnvironmentCacheStore, SC as SourceControlRepositoryError, bT as EnvironmentAuthorizationError, f as AtomCommand, 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/sourceControl.d.ts
+declare function createSourceControlEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | EnvironmentCacheStore | R, E>): {
+  discovery: (target: {
+    readonly environmentId: EnvironmentId;
+    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{}>;
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly versionControlSystems: readonly {
+      readonly label: string;
+      readonly executable?: string | undefined;
+      readonly status: "available" | "missing";
+      readonly version: import("effect/Option").Option<string>;
+      readonly installHint: string;
+      readonly detail: import("effect/Option").Option<string>;
+      readonly kind: "git" | "jj" | "unknown";
+      readonly implemented: boolean;
+    }[];
+    readonly sourceControlProviders: readonly {
+      readonly label: string;
+      readonly executable?: string | undefined;
+      readonly status: "available" | "missing";
+      readonly version: import("effect/Option").Option<string>;
+      readonly installHint: string;
+      readonly detail: import("effect/Option").Option<string>;
+      readonly kind: "azure-devops" | "bitbucket" | "github" | "gitlab" | "unknown";
+      readonly auth: {
+        readonly status: "authenticated" | "unauthenticated" | "unknown";
+        readonly account: import("effect/Option").Option<string>;
+        readonly host: import("effect/Option").Option<string>;
+        readonly detail: import("effect/Option").Option<string>;
+      };
+    }[];
+  }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
+  repository: (target: {
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly provider: "azure-devops" | "bitbucket" | "github" | "gitlab" | "unknown";
+      readonly repository: string;
+      readonly cwd?: string | undefined;
+    };
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly provider: "azure-devops" | "bitbucket" | "github" | "gitlab" | "unknown";
+    readonly nameWithOwner: string;
+    readonly url: string;
+    readonly sshUrl: string;
+  }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | import("effect/unstable/rpc/RpcClientError").RpcClientError | SourceControlRepositoryError>>;
+  cloneRepository: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly provider?: "azure-devops" | "bitbucket" | "github" | "gitlab" | "unknown" | undefined;
+      readonly repository?: string | undefined;
+      readonly remoteUrl?: string | undefined;
+      readonly destinationPath: string;
+      readonly protocol?: "auto" | "https" | "ssh" | undefined;
+    };
+  }, {
+    readonly cwd: string;
+    readonly remoteUrl: string;
+    readonly repository: {
+      readonly provider: "azure-devops" | "bitbucket" | "github" | "gitlab" | "unknown";
+      readonly nameWithOwner: string;
+      readonly url: string;
+      readonly sshUrl: string;
+    } | null;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError | SourceControlRepositoryError>;
+  publishRepository: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly cwd: string;
+      readonly provider: "azure-devops" | "bitbucket" | "github" | "gitlab" | "unknown";
+      readonly repository: string;
+      readonly visibility: "private" | "public";
+      readonly remoteName?: string | undefined;
+      readonly protocol?: "auto" | "https" | "ssh" | undefined;
+    };
+  }, {
+    readonly repository: {
+      readonly provider: "azure-devops" | "bitbucket" | "github" | "gitlab" | "unknown";
+      readonly nameWithOwner: string;
+      readonly url: string;
+      readonly sshUrl: string;
+    };
+    readonly remoteName: string;
+    readonly remoteUrl: string;
+    readonly branch: string;
+    readonly upstreamBranch?: string | undefined;
+    readonly status: "pushed" | "remote_added";
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError | SourceControlRepositoryError>;
+};
+//#endregion
+export { createSourceControlEnvironmentAtoms };

package/dist/client-runtime/state/source-control.js

@@ -0,0 +1,36 @@
+import { Fs as WS_METHODS, St as vcsCommandScheduler, dr as createEnvironmentRpcCommand, fr as createEnvironmentRpcQueryAtomFamily, lr as createAtomCommandScheduler, vt as invalidateCachedVcsRefs, xt as vcsCommandConcurrency } from "../../shared.js";
+//#region upstream-t3code/packages/client-runtime/src/state/sourceControl.ts
+function createSourceControlEnvironmentAtoms(runtime) {
+	const commandScheduler = createAtomCommandScheduler();
+	return {
+		discovery: createEnvironmentRpcQueryAtomFamily(runtime, {
+			label: "environment-data:server:source-control-discovery",
+			tag: WS_METHODS.serverDiscoverSourceControl
+		}),
+		repository: createEnvironmentRpcQueryAtomFamily(runtime, {
+			label: "environment-data:source-control:repository",
+			tag: WS_METHODS.sourceControlLookupRepository
+		}),
+		cloneRepository: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:source-control:clone-repository",
+			tag: WS_METHODS.sourceControlCloneRepository,
+			scheduler: commandScheduler,
+			concurrency: {
+				mode: "serial",
+				key: ({ environmentId }) => environmentId
+			}
+		}),
+		publishRepository: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:source-control:publish-repository",
+			tag: WS_METHODS.sourceControlPublishRepository,
+			scheduler: vcsCommandScheduler,
+			concurrency: vcsCommandConcurrency,
+			onSettled: (target, registry) => invalidateCachedVcsRefs(registry, {
+				environmentId: target.environmentId,
+				cwd: target.input.cwd
+			})
+		})
+	};
+}
+//#endregion
+export { createSourceControlEnvironmentAtoms };