t3code-cli 0.14.1 → 0.15.0

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

@@ -1,5 +1,97 @@
-import { $D as flatMap, Aa as EnvironmentSupervisor, Bk as isSome, Cv as get, Fs as WS_METHODS, GC as set, Gk as toArray, Gr as family, HD as as, Hk as match, IE as debounce, Ik as getOrNull, Jr as setIdleTTL, KC as update, La as EnvironmentCacheStore, Na as safeErrorLogAttributes, RD as addFinalizer, RO as void_, Sv as changes, Tv as set$1, UC as get$1, UD as asVoid, Uk as none, Ur as subscribe, VD as annotateLogs, VE as filterMap, Vk as map, WC as make$1, WE as fromQueue, Wk as some, Xr as withLabel, YD as catch_, aO as gen, bk as failVoid, dr as createEnvironmentRpcCommand, eO as fn, fr as createEnvironmentRpcQueryAtomFamily, iO as forkScoped, lD as unwrap, lO as logWarning, lr as createAtomCommandScheduler, mr as createEnvironmentRpcSubscriptionAtomFamily, qE as mapAccum, qr as make$2, tD as runForEach, ti as value, uO as map$1, vD as offer, wk as succeed, wv as make, xD as sliding, xr as followStreamInEnvironment, zk as isNone } from "../../shared.js";
+import { $A as runHead, $j as ignore, Aj as andThen, By as changes, CM as sync, DD as set, DN as seconds, Dr as followStreamInEnvironment, ED as make$2, EM as timeoutOption, EN as minutes, GM as hasInterruptsOnly, GN as none, Gj as flatMap, HN as isSome, Ha as safeErrorLogAttributes, Hj as exit, Hy as make$1, Ia as EnvironmentRegistry, JM as squash, KM as isFailReason, KN as some, Ka as EnvironmentCacheStore, Kj as fn, Kr as make, LA as filter, Lk as String, Mj as as, NA as debounce, NM as void_, Nj as asVoid, Nk as Literals, OD as update, Oj as addFinalizer, PN as flatten, Pr as scheduleAtomCommandEffect, QA as runForEach, Qj as gen, RA as filterMap, RN as getOrNull, Ra as EnvironmentSupervisor, SN as succeed$1, Sr as createRuntimeCommand, TD as get$1, UN as map, Uj as fail, Uy as set$1, VA as fromQueue, VN as isNone, Vy as get, WA as mapAccum, WN as match, Wj as failCause, Wr as family, Xj as forkChild, Xk as optional, Yr as withLabel, Zj as forkScoped, _r as createEnvironmentRpcCommand, ai as isRpcClientError, bM as sleep, bj as sliding, br as createEnvironmentRpcSubscriptionAtomFamily, cM as onExit, cN as isFailure, ci as subscribe, ei as value, gj as offer, jj as annotateLogs, lN as isSuccess, lc as WS_METHODS, mr as createAtomCommandScheduler, nM as logWarning, oi as request, qN as toArray, qr as setIdleTTL, rM as map$1, si as runStream, sj as unwrap, vN as failVoid, vr as createEnvironmentRpcQueryAtomFamily, xM as succeed, zj as catch_, zk as TaggedErrorClass } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/server.ts
+const IDLE_SERVER_UPDATE_STATE = { status: "idle" };
+const EMPTY_SERVER_UPDATE_STATE_ATOM = make(IDLE_SERVER_UPDATE_STATE).pipe(withLabel("environment-data:server:update-state:empty"));
+const serverUpdateStateAtom = family((environmentId) => make(IDLE_SERVER_UPDATE_STATE).pipe(withLabel(`environment-data:server:update-state:${environmentId}`)));
+var ServerUpdateResumeTimeoutError = class extends TaggedErrorClass()("ServerUpdateResumeTimeoutError", {
+	environmentId: String,
+	targetVersion: String
+}) {
+	get message() {
+		return `The server did not resume on t3@${this.targetVersion}.`;
+	}
+};
+var ServerUpdateProgressIncompleteError = class extends TaggedErrorClass()("ServerUpdateProgressIncompleteError", { targetVersion: String }) {
+	get message() {
+		return `The t3@${this.targetVersion} update ended before the server accepted the restart.`;
+	}
+};
+var ServerUpdateTerminalError = class extends TaggedErrorClass()("ServerUpdateTerminalError", {
+	targetVersion: String,
+	status: Literals([
+		"committed",
+		"rolled-back",
+		"failed"
+	]),
+	reason: optional(String)
+}) {
+	get message() {
+		return this.reason ?? `The t3@${this.targetVersion} update ${this.status}.`;
+	}
+};
+const SERVER_UPDATE_RESUME_TIMEOUT = minutes(4);
+function matchesServerUpdateReadyEvent(result, event) {
+	return result.updateId === void 0 ? event.payload.environment.serverVersion === result.targetVersion : event.payload.updateOutcome?.id === result.updateId;
+}
+function validateServerUpdateReadyEvent(result, event) {
+	if (result.updateId === void 0) return void_;
+	const outcome = event.payload.updateOutcome;
+	if (outcome?.id === result.updateId && outcome.status === "committed" && outcome.targetVersion === result.targetVersion && event.payload.environment.serverVersion === result.targetVersion) return void_;
+	return fail(new ServerUpdateTerminalError({
+		targetVersion: result.targetVersion,
+		status: outcome?.status ?? "failed",
+		reason: outcome?.reason ?? "The service launcher resumed without committing the requested server version."
+	}));
+}
+/**
+* Keeps reconnect attempts ~1s apart for the whole update restart.
+*
+* A restart takes the server down for ~15 seconds, but the supervisor's normal
+* backoff ladder (1/2/4/8/16s) assumes an unexpected failure and lands attempts
+* at ~3, 5, 9, 17 and 33 seconds — so a 15-second restart is observed as a
+* 33-second "Resuming". Nudging on every backoff entry (not just the first)
+* holds the retry cadence flat until the server answers again. The sleep before
+* each nudge is the pacer: a connection that fails instantly re-enters backoff
+* immediately and would otherwise spin a tight retry loop.
+*
+* Callers fork this as a child of the update command so it is interrupted as
+* soon as the update settles, whether it succeeds, fails, or times out.
+*/
+function nudgeReconnectDuringUpdateRestart(input) {
+	return input.stateChanges.pipe(filter((state) => state.phase === "backoff"), runForEach(() => sleep(input.interval ?? seconds(1)).pipe(andThen(input.retryNow))), timeoutOption(SERVER_UPDATE_RESUME_TIMEOUT), ignore);
+}
+function serverUpdateStateForProgressEvent(fromVersion, targetVersion, event) {
+	return {
+		status: "running",
+		stage: event.type === "complete" ? "resuming" : event.stage,
+		fromVersion,
+		targetVersion
+	};
+}
+function serverUpdateStateForServerVersion(state, serverVersion) {
+	return state.status === "idle" || state.status === "running" || serverVersion === null || state.fromVersion === serverVersion ? state : IDLE_SERVER_UPDATE_STATE;
+}
+function serverUpdateFailureMessage(error) {
+	return error instanceof Error ? error.message : "Server update failed.";
+}
+function isRpcSocketError(error) {
+	if (!isRpcClientError(error)) return false;
+	switch (error.reason._tag) {
+		case "SocketReadError":
+		case "SocketWriteError":
+		case "SocketCloseError": return true;
+		default: return false;
+	}
+}
+function isLegacyUpdateHandoffLoss(cause) {
+	if (hasInterruptsOnly(cause)) return true;
+	return cause.reasons.length > 0 && cause.reasons.every((reason) => isFailReason(reason) && isRpcSocketError(reason.error));
+}
+function resolveServerUpdateProgressResult(targetVersion, terminal, streamExit) {
+	if (isSome(terminal) && (isSuccess(streamExit) || isLegacyUpdateHandoffLoss(streamExit.cause))) return succeed(terminal.value);
+	if (isFailure(streamExit)) return failCause(streamExit.cause);
+	return fail(new ServerUpdateProgressIncompleteError({ targetVersion }));
+}
 function applyServerConfigProjection(current, event) {
 	switch (event.type) {
 		case "snapshot": return some({
@@ -52,7 +144,7 @@ const makeEnvironmentServerConfigState = fn("EnvironmentServerConfigState.make")
 	const supervisor = yield* EnvironmentSupervisor;
 	const cache = yield* EnvironmentCacheStore;
 	const environmentId = supervisor.target.environmentId;
-	const state = yield* make(map(yield* cache.loadServerConfig(environmentId).pipe(catch_((error) => logWarning("Could not load cached server configuration.").pipe(annotateLogs({
+	const state = yield* make$1(map(yield* cache.loadServerConfig(environmentId).pipe(catch_((error) => logWarning("Could not load cached server configuration.").pipe(annotateLogs({
 		environmentId,
 		...safeErrorLogAttributes(error)
 	}), as(none())))), (config) => ({
@@ -61,7 +153,7 @@ const makeEnvironmentServerConfigState = fn("EnvironmentServerConfigState.make")
 		source: "cache"
 	})));
 	const persistence = yield* sliding(1);
-	const pendingPersistence = yield* make$1(none());
+	const pendingPersistence = yield* make$2(none());
 	const persist = fn("EnvironmentServerConfigState.persist")(function* (config) {
 		return yield* cache.saveServerConfig(environmentId, config).pipe(as(true), catch_((error) => logWarning("Could not persist cached server configuration.").pipe(annotateLogs({
 			environmentId,
@@ -89,7 +181,7 @@ const makeEnvironmentServerConfigState = fn("EnvironmentServerConfigState.make")
 function serverConfigStateChanges(environmentId) {
 	return followStreamInEnvironment(environmentId, unwrap(makeEnvironmentServerConfigState().pipe(map$1((state) => changes(state).pipe(filterMap((projection) => match(projection, {
 		onNone: () => failVoid,
-		onSome: (value) => succeed(value)
+		onSome: (value) => succeed$1(value)
 	})))))));
 }
 function projectServerWelcome(current, event) {
@@ -98,31 +190,115 @@ function projectServerWelcome(current, event) {
 	return [some(welcome), [welcome]];
 }
 function resolveServerConfigValue(projection, initialConfig) {
-	if (projection?.source === "live") return projection.config;
+	if (projection?.source === "live" && (initialConfig === null || projection.config.environment.serverVersion === initialConfig.environment.serverVersion)) return projection.config;
 	return initialConfig ?? projection?.config ?? null;
 }
 function createServerEnvironmentAtoms(runtime, options) {
 	const configScheduler = createAtomCommandScheduler();
+	const updateScheduler = createAtomCommandScheduler();
 	const configConcurrency = {
 		mode: "serial",
 		key: ({ environmentId }) => environmentId
 	};
 	const configProjectionFamily = family((environmentId) => runtime.atom(serverConfigStateChanges(environmentId)).pipe(setIdleTTL(5 * 6e4), withLabel(`environment-data:server:config-projection:${environmentId}`)));
 	const configProjection = (target) => configProjectionFamily(target.environmentId);
-	const emptyConfigAtom = make$2(null).pipe(withLabel("environment-data:server:config:empty"));
+	const emptyConfigAtom = make(null).pipe(withLabel("environment-data:server:config:empty"));
 	const configValueAtom = family((environmentId) => {
 		if (environmentId === null) return emptyConfigAtom;
-		return make$2((get) => {
+		return make((get) => {
 			return resolveServerConfigValue(getOrNull(value(get(configProjection({
 				environmentId,
 				input: {}
 			})))), get(options.initialConfigValueAtom(environmentId)));
 		}).pipe(withLabel(`environment-data:server:config:${environmentId}`));
 	});
+	const updateStateValueAtom = family((environmentId) => make((get) => serverUpdateStateForServerVersion(get(serverUpdateStateAtom(environmentId)), get(configValueAtom(environmentId))?.environment.serverVersion ?? null)).pipe(withLabel(`environment-data:server:update-state-value:${environmentId}`)));
+	const updateStateAtom = (environmentId) => environmentId === null ? EMPTY_SERVER_UPDATE_STATE_ATOM : updateStateValueAtom(environmentId);
+	const updateServer = createRuntimeCommand(runtime, {
+		label: "environment-data:server:update-server",
+		scheduler: updateScheduler,
+		concurrency: configConcurrency,
+		execute: (target, atomRegistry) => {
+			const stateAtom = serverUpdateStateAtom(target.environmentId);
+			const targetVersion = target.input.targetVersion;
+			let fromVersion = atomRegistry.get(configValueAtom(target.environmentId))?.environment.serverVersion ?? targetVersion;
+			let currentStage = "downloading";
+			atomRegistry.set(stateAtom, {
+				status: "running",
+				stage: currentStage,
+				fromVersion,
+				targetVersion
+			});
+			return gen(function* () {
+				const environmentRegistry = yield* EnvironmentRegistry;
+				const result = yield* scheduleAtomCommandEffect(atomRegistry, configScheduler, configConcurrency, target, gen(function* () {
+					const currentConfig = atomRegistry.get(configValueAtom(target.environmentId));
+					fromVersion = currentConfig?.environment.serverVersion ?? targetVersion;
+					atomRegistry.set(stateAtom, {
+						status: "running",
+						stage: currentStage,
+						fromVersion,
+						targetVersion
+					});
+					const updateResult = currentConfig?.environment.capabilities.serverSelfUpdateProgress === true ? yield* gen(function* () {
+						const terminal = yield* make$2(none());
+						const streamExit = yield* environmentRegistry.runStream(target.environmentId, runStream(WS_METHODS.serverUpdateServerWithProgress, target.input)).pipe(runForEach((event) => sync(() => {
+							currentStage = event.type === "complete" ? "resuming" : event.stage;
+							atomRegistry.set(stateAtom, serverUpdateStateForProgressEvent(fromVersion, targetVersion, event));
+						}).pipe(andThen(event.type === "complete" ? set(terminal, some(event.result)) : void_))), exit);
+						return yield* resolveServerUpdateProgressResult(targetVersion, yield* get$1(terminal), streamExit);
+					}) : yield* gen(function* () {
+						const selfUpdateMethod = currentConfig?.environment.capabilities.serverSelfUpdate;
+						const exit$1 = yield* environmentRegistry.run(target.environmentId, request(WS_METHODS.serverUpdateServer, target.input)).pipe(exit);
+						if (isSuccess(exit$1)) return exit$1.value;
+						if ((selfUpdateMethod === "boot-service" || selfUpdateMethod === "respawn") && isLegacyUpdateHandoffLoss(exit$1.cause)) return {
+							targetVersion,
+							method: selfUpdateMethod
+						};
+						return yield* failCause(exit$1.cause);
+					});
+					currentStage = "resuming";
+					atomRegistry.set(stateAtom, {
+						status: "running",
+						stage: currentStage,
+						fromVersion,
+						targetVersion
+					});
+					return updateResult;
+				}));
+				yield* nudgeReconnectDuringUpdateRestart({
+					stateChanges: environmentRegistry.stateChanges(target.environmentId),
+					retryNow: environmentRegistry.retryNow(target.environmentId)
+				}).pipe(forkChild);
+				const resumed = yield* environmentRegistry.followStream(target.environmentId, subscribe(WS_METHODS.subscribeServerLifecycle, {})).pipe(filter((event) => event.type === "ready" && matchesServerUpdateReadyEvent(result, event)), runHead, timeoutOption(SERVER_UPDATE_RESUME_TIMEOUT), map$1(flatten));
+				if (isNone(resumed)) return yield* new ServerUpdateResumeTimeoutError({
+					environmentId: target.environmentId,
+					targetVersion
+				});
+				yield* validateServerUpdateReadyEvent(result, resumed.value);
+				atomRegistry.set(stateAtom, IDLE_SERVER_UPDATE_STATE);
+				return result;
+			}).pipe(onExit((exit) => sync(() => {
+				if (isSuccess(exit)) return;
+				if (hasInterruptsOnly(exit.cause)) {
+					atomRegistry.set(stateAtom, IDLE_SERVER_UPDATE_STATE);
+					return;
+				}
+				atomRegistry.set(stateAtom, {
+					status: "failed",
+					stage: currentStage,
+					fromVersion,
+					targetVersion,
+					message: serverUpdateFailureMessage(squash(exit.cause))
+				});
+			})));
+		}
+	});
 	return {
 		configValueAtom,
-		settingsValueAtom: family((environmentId) => make$2((get) => get(configValueAtom(environmentId))?.settings ?? null).pipe(withLabel(`environment-data:server:settings:${environmentId}`))),
-		providersValueAtom: family((environmentId) => make$2((get) => get(configValueAtom(environmentId))?.providers ?? null).pipe(withLabel(`environment-data:server:providers:${environmentId}`))),
+		updateStateAtom,
+		settingsValueAtom: family((environmentId) => make((get) => get(configValueAtom(environmentId))?.settings ?? null).pipe(withLabel(`environment-data:server:settings:${environmentId}`))),
+		providersValueAtom: family((environmentId) => make((get) => get(configValueAtom(environmentId))?.providers ?? null).pipe(withLabel(`environment-data:server:providers:${environmentId}`))),
 		traceDiagnostics: createEnvironmentRpcQueryAtomFamily(runtime, {
 			label: "environment-data:server:trace-diagnostics",
 			tag: WS_METHODS.serverGetTraceDiagnostics
@@ -145,6 +321,11 @@ function createServerEnvironmentAtoms(runtime, options) {
 			tag: WS_METHODS.serverGetResourceTelemetryHistory,
 			staleTimeMs: 5e3
 		}),
+		usageSummary: createEnvironmentRpcQueryAtomFamily(runtime, {
+			label: "environment-data:server:usage-summary",
+			tag: WS_METHODS.serverGetUsageSummary,
+			staleTimeMs: 6e4
+		}),
 		configProjection,
 		welcome: createEnvironmentRpcSubscriptionAtomFamily(runtime, {
 			label: "environment-data:server:welcome",
@@ -165,12 +346,7 @@ function createServerEnvironmentAtoms(runtime, options) {
 			scheduler: configScheduler,
 			concurrency: configConcurrency
 		}),
-		updateServer: createEnvironmentRpcCommand(runtime, {
-			label: "environment-data:server:update-server",
-			tag: WS_METHODS.serverUpdateServer,
-			scheduler: configScheduler,
-			concurrency: configConcurrency
-		}),
+		updateServer,
 		upsertKeybinding: createEnvironmentRpcCommand(runtime, {
 			label: "environment-data:server:upsert-keybinding",
 			tag: WS_METHODS.serverUpsertKeybinding,
@@ -204,4 +380,4 @@ function createServerEnvironmentAtoms(runtime, options) {
 	};
 }
 //#endregion
-export { applyServerConfigProjection, createServerEnvironmentAtoms, makeEnvironmentServerConfigState, projectServerConfig, projectServerWelcome, resolveServerConfigValue, serverConfigStateChanges };
+export { ServerUpdateProgressIncompleteError, ServerUpdateResumeTimeoutError, ServerUpdateTerminalError, applyServerConfigProjection, createServerEnvironmentAtoms, isLegacyUpdateHandoffLoss, makeEnvironmentServerConfigState, matchesServerUpdateReadyEvent, nudgeReconnectDuringUpdateRestart, projectServerConfig, projectServerWelcome, resolveServerConfigValue, resolveServerUpdateProgressResult, serverConfigStateChanges, serverUpdateStateForProgressEvent, serverUpdateStateForServerVersion, validateServerUpdateReadyEvent };

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

@@ -1,10 +1,32 @@
-import { Fl as ServerConfig, Ku as KeybindingWhenNode, es as PreparedConnection, ha as EnvironmentRegistry } from "../../shared.js";
+import { Id as KeybindingWhenNode, Oa as EnvironmentRegistry, Su as ServerConfig, ms as PreparedConnection, no as RemoteEnvironmentRequestError, wo as ManagedRelayDpopSigner } from "../../shared.js";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
+import { HttpClient } from "effect/unstable/http";
 import { AsyncResult, Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/session.d.ts
 declare function initialConfigOption<E>(initialConfig: Effect.Effect<ServerConfig, E>): Effect.Effect<Option.Option<ServerConfig>>;
-declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>): {
+/**
+ * Read the granted scopes of this client's session on one environment via its
+ * `/api/auth/session` endpoint, authenticated with whatever credential the
+ * connection was prepared with (cookie, bearer, or DPoP).
+ */
+declare const fetchEnvironmentSessionState: (input: {
+  readonly prepared: PreparedConnection;
+  readonly signer: Option.Option<ManagedRelayDpopSigner["Service"]>;
+  readonly timeoutMs?: number;
+}) => Effect.Effect<{
+  readonly authenticated: boolean;
+  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 scopes?: readonly ("access:read" | "access:write" | "orchestration:operate" | "orchestration:read" | "relay:read" | "relay:write" | "review:write" | "terminal:operate")[];
+  readonly sessionMethod?: "bearer-access-token" | "browser-session-cookie" | "dpop-access-token";
+  readonly expiresAt?: import("effect/DateTime").Utc;
+}, RemoteEnvironmentRequestError, HttpClient.HttpClient>;
+declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | HttpClient.HttpClient | R, E>): {
   initialConfigAtom: (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<AsyncResult.AsyncResult<Option.Option<{
     readonly environment: {
       readonly environmentId: string & import("effect/Brand").Brand<"EnvironmentId">;
@@ -17,9 +39,15 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
       readonly capabilities: {
         readonly repositoryIdentity: boolean;
         readonly connectionProbe?: boolean;
+        readonly pullRequests?: boolean;
         readonly threadSettlement?: boolean;
         readonly threadSnooze?: boolean;
+        readonly threadPinning?: boolean;
+        readonly threadPinReorder?: boolean;
+        readonly threadTitleRegeneration?: boolean;
         readonly serverSelfUpdate?: "boot-service" | "desktop-managed" | "respawn";
+        readonly serverSelfUpdateProgress?: boolean;
+        readonly agentActivityPublishing?: boolean;
       };
     };
     readonly auth: {
@@ -31,7 +59,7 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
     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 command: "chat.new" | "chat.newLocal" | "commandPalette.toggle" | "composer.stash" | "diff.toggle" | "editor.openFavorite" | "filePicker.toggle" | "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" | "projectSearch.toggle" | "rightPanel.toggle" | "sidebar.toggle" | "terminal.close" | "terminal.new" | "terminal.split" | "terminal.splitVertical" | "terminal.toggle" | "themeEditor.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;
@@ -96,6 +124,7 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
         readonly subProvider?: string | undefined;
         readonly isCustom: boolean;
         readonly isDefault?: boolean | undefined;
+        readonly isLegacy?: boolean | undefined;
         readonly capabilities: {
           readonly optionDescriptors?: readonly ({
             readonly id: string;
@@ -153,6 +182,10 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
       };
     }[];
     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 remoteOpenTargets?: readonly {
+      readonly kind: "mdns" | "tailscale";
+      readonly host: string;
+    }[];
     readonly observability: {
       readonly logsDirectoryPath: string;
       readonly localTracingEnabled: boolean;
@@ -162,7 +195,7 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
       readonly otlpMetricsEnabled: boolean;
     };
     readonly settings: {
-      readonly enableAssistantStreaming: boolean;
+      readonly enableLegacyTokenStreaming: boolean;
       readonly enableProviderUpdateChecks: boolean;
       readonly backgroundActivity: {
         readonly schemaVersion: 1;
@@ -264,6 +297,7 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
     };
     readonly shellResumeCompletionMarker?: boolean;
     readonly threadResumeCompletionMarker?: boolean;
+    readonly threadSnapshotPagination?: boolean;
   }>, E | import("effect/Cause").NoSuchElementError>>;
   initialConfigValueAtom: (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<{
     readonly environment: {
@@ -277,9 +311,15 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
       readonly capabilities: {
         readonly repositoryIdentity: boolean;
         readonly connectionProbe?: boolean;
+        readonly pullRequests?: boolean;
         readonly threadSettlement?: boolean;
         readonly threadSnooze?: boolean;
+        readonly threadPinning?: boolean;
+        readonly threadPinReorder?: boolean;
+        readonly threadTitleRegeneration?: boolean;
         readonly serverSelfUpdate?: "boot-service" | "desktop-managed" | "respawn";
+        readonly serverSelfUpdateProgress?: boolean;
+        readonly agentActivityPublishing?: boolean;
       };
     };
     readonly auth: {
@@ -291,7 +331,7 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
     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 command: "chat.new" | "chat.newLocal" | "commandPalette.toggle" | "composer.stash" | "diff.toggle" | "editor.openFavorite" | "filePicker.toggle" | "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" | "projectSearch.toggle" | "rightPanel.toggle" | "sidebar.toggle" | "terminal.close" | "terminal.new" | "terminal.split" | "terminal.splitVertical" | "terminal.toggle" | "themeEditor.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;
@@ -356,6 +396,7 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
         readonly subProvider?: string | undefined;
         readonly isCustom: boolean;
         readonly isDefault?: boolean | undefined;
+        readonly isLegacy?: boolean | undefined;
         readonly capabilities: {
           readonly optionDescriptors?: readonly ({
             readonly id: string;
@@ -413,6 +454,10 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
       };
     }[];
     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 remoteOpenTargets?: readonly {
+      readonly kind: "mdns" | "tailscale";
+      readonly host: string;
+    }[];
     readonly observability: {
       readonly logsDirectoryPath: string;
       readonly localTracingEnabled: boolean;
@@ -422,7 +467,7 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
       readonly otlpMetricsEnabled: boolean;
     };
     readonly settings: {
-      readonly enableAssistantStreaming: boolean;
+      readonly enableLegacyTokenStreaming: boolean;
       readonly enableProviderUpdateChecks: boolean;
       readonly backgroundActivity: {
         readonly schemaVersion: 1;
@@ -524,9 +569,34 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
     };
     readonly shellResumeCompletionMarker?: boolean;
     readonly threadResumeCompletionMarker?: boolean;
+    readonly threadSnapshotPagination?: boolean;
   } | null>;
   preparedConnectionAtom: (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<AsyncResult.AsyncResult<Option.Option<PreparedConnection>, E | import("effect/Cause").NoSuchElementError>>;
   preparedConnectionValueAtom: (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<Option.Option<PreparedConnection>>;
+  sessionStateAtom: (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<AsyncResult.AsyncResult<{
+    readonly authenticated: boolean;
+    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 scopes?: readonly ("access:read" | "access:write" | "orchestration:operate" | "orchestration:read" | "relay:read" | "relay:write" | "review:write" | "terminal:operate")[];
+    readonly sessionMethod?: "bearer-access-token" | "browser-session-cookie" | "dpop-access-token";
+    readonly expiresAt?: import("effect/DateTime").Utc;
+  }, E | RemoteEnvironmentRequestError>>;
+  sessionStateValueAtom: (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<{
+    readonly authenticated: boolean;
+    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 scopes?: readonly ("access:read" | "access:write" | "orchestration:operate" | "orchestration:read" | "relay:read" | "relay:write" | "review:write" | "terminal:operate")[];
+    readonly sessionMethod?: "bearer-access-token" | "browser-session-cookie" | "dpop-access-token";
+    readonly expiresAt?: import("effect/DateTime").Utc;
+  } | null>;
 };
 //#endregion
-export { createEnvironmentSessionAtoms, initialConfigOption };
+export { createEnvironmentSessionAtoms, fetchEnvironmentSessionState, initialConfigOption };

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

@@ -1,8 +1,20 @@
-import { Aa as EnvironmentSupervisor, EO as succeed, Fk as getOrElse, Gr as family, HD as as, Hk as match, Ik as getOrNull, JE as mapEffect, Na as safeErrorLogAttributes, Sv as changes, Uk as none, VD as annotateLogs, Wk as some, Xr as withLabel, YD as catch_, lD as unwrap, lO as logWarning, qr as make, ti as value, uO as map, xr as followStreamInEnvironment } from "../../shared.js";
+import { By as changes, Dr as followStreamInEnvironment, GA as mapEffect, GN as none, Ha as safeErrorLogAttributes, Ho as makeEnvironmentHttpApiClient, Hr as buildEnvironmentAuthHeaders, Jr as swr, KN as some, Kj as fn, Ko as environmentEndpointUrl, Kr as make, LN as getOrElse, Mj as as, Qj as gen, RN as getOrNull, Ra as EnvironmentSupervisor, Ur as withEnvironmentCredentials, Vo as executeEnvironmentHttpRequest, WN as match, Wr as family, Yr as withLabel, ei as value, jj as annotateLogs, nM as logWarning, qr as setIdleTTL, rM as map, ro as ManagedRelayDpopSigner, sM as never, sj as unwrap, xM as succeed, yM as serviceOption, zj as catch_ } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/session.ts
 function initialConfigOption(initialConfig) {
 	return initialConfig.pipe(map(some), catch_((error) => logWarning("Could not load the initial environment configuration.").pipe(annotateLogs({ ...safeErrorLogAttributes(error) }), as(none()))));
 }
+const DEFAULT_SESSION_STATE_TIMEOUT_MS = 6e3;
+/**
+* Read the granted scopes of this client's session on one environment via its
+* `/api/auth/session` endpoint, authenticated with whatever credential the
+* connection was prepared with (cookie, bearer, or DPoP).
+*/
+const fetchEnvironmentSessionState = fn("clientRuntime.state.fetchEnvironmentSessionState")(function* (input) {
+	const requestUrl = environmentEndpointUrl(input.prepared.httpBaseUrl, "/api/auth/session");
+	const client = yield* makeEnvironmentHttpApiClient(input.prepared.httpBaseUrl);
+	const headers = yield* buildEnvironmentAuthHeaders(input.prepared.httpAuthorization, "GET", requestUrl, input.signer);
+	return yield* executeEnvironmentHttpRequest(requestUrl, input.timeoutMs ?? DEFAULT_SESSION_STATE_TIMEOUT_MS, withEnvironmentCredentials(input.prepared.httpAuthorization, client.auth.session({ headers })));
+});
 function createEnvironmentSessionAtoms(runtime) {
 	const initialConfigAtom = family((environmentId) => runtime.atom(followStreamInEnvironment(environmentId, unwrap(EnvironmentSupervisor.pipe(map((supervisor) => changes(supervisor.session).pipe(mapEffect(match({
 		onNone: () => succeed(none()),
@@ -10,12 +22,29 @@ function createEnvironmentSessionAtoms(runtime) {
 	}))))))), { initialValue: none() }));
 	const initialConfigValueAtom = family((environmentId) => make((get) => getOrNull(getOrElse(value(get(initialConfigAtom(environmentId))), () => none()))).pipe(withLabel(`environment-config-value:${environmentId}`)));
 	const preparedConnectionAtom = family((environmentId) => runtime.atom(followStreamInEnvironment(environmentId, unwrap(EnvironmentSupervisor.pipe(map((supervisor) => changes(supervisor.prepared))))), { initialValue: none() }));
+	const preparedConnectionValueAtom = family((environmentId) => make((get) => getOrElse(value(get(preparedConnectionAtom(environmentId))), () => none())).pipe(withLabel(`environment-prepared-connection:${environmentId}`)));
+	const sessionStateAtom = family((environmentId) => runtime.atom((get) => {
+		const prepared = getOrNull(get(preparedConnectionValueAtom(environmentId)));
+		if (prepared === null) return never;
+		return gen(function* () {
+			const signer = yield* serviceOption(ManagedRelayDpopSigner);
+			return yield* fetchEnvironmentSessionState({
+				prepared,
+				signer
+			});
+		});
+	}).pipe(swr({
+		staleTime: 3e4,
+		revalidateOnMount: true
+	}), setIdleTTL(5 * 6e4), withLabel(`environment-session-state:${environmentId}`)));
 	return {
 		initialConfigAtom,
 		initialConfigValueAtom,
 		preparedConnectionAtom,
-		preparedConnectionValueAtom: family((environmentId) => make((get) => getOrElse(value(get(preparedConnectionAtom(environmentId))), () => none())).pipe(withLabel(`environment-prepared-connection:${environmentId}`)))
+		preparedConnectionValueAtom,
+		sessionStateAtom,
+		sessionStateValueAtom: family((environmentId) => make((get) => getOrNull(value(get(sessionStateAtom(environmentId)))) ?? null).pipe(withLabel(`environment-session-state-value:${environmentId}`)))
 	};
 }
 //#endregion
-export { createEnvironmentSessionAtoms, initialConfigOption };
+export { createEnvironmentSessionAtoms, fetchEnvironmentSessionState, initialConfigOption };