t3code-cli 0.13.0 → 0.14.0

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

@@ -0,0 +1,207 @@
+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";
+//#region upstream-t3code/packages/client-runtime/src/state/server.ts
+function applyServerConfigProjection(current, event) {
+	switch (event.type) {
+		case "snapshot": return some({
+			config: event.config,
+			latestEvent: event,
+			source: "live"
+		});
+		case "keybindingsUpdated": return map(current, (projection) => ({
+			config: {
+				...projection.config,
+				keybindings: event.payload.keybindings,
+				issues: event.payload.issues
+			},
+			latestEvent: event,
+			source: "live"
+		}));
+		case "providerStatuses": return map(current, (projection) => ({
+			config: {
+				...projection.config,
+				providers: event.payload.providers
+			},
+			latestEvent: event,
+			source: "live"
+		}));
+		case "settingsUpdated": return map(current, (projection) => ({
+			config: {
+				...projection.config,
+				settings: event.payload.settings
+			},
+			latestEvent: event,
+			source: "live"
+		}));
+	}
+}
+function projectServerConfig(current, event) {
+	const next = applyServerConfigProjection(current, event);
+	return [next, toArray(next)];
+}
+const cachedConfigSnapshotEvent = (config) => ({
+	version: 1,
+	type: "snapshot",
+	config
+});
+/**
+* Keeps a complete server configuration available during reconnects. Server
+* config carries the provider/model catalogue used by task creation, so it is
+* useful—and safe—to retain after a transport session ends.
+*/
+const makeEnvironmentServerConfigState = fn("EnvironmentServerConfigState.make")(function* () {
+	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({
+		environmentId,
+		...safeErrorLogAttributes(error)
+	}), as(none())))), (config) => ({
+		config,
+		latestEvent: cachedConfigSnapshotEvent(config),
+		source: "cache"
+	})));
+	const persistence = yield* sliding(1);
+	const pendingPersistence = yield* make$1(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,
+			...safeErrorLogAttributes(error)
+		}), as(false))));
+	});
+	const persistPending = fn("EnvironmentServerConfigState.persistPending")(function* (config) {
+		if (!(yield* persist(config))) return;
+		yield* update(pendingPersistence, (pending) => isSome(pending) && pending.value === config ? none() : pending);
+	});
+	yield* fromQueue(persistence).pipe(debounce("500 millis"), runForEach(persistPending), forkScoped);
+	yield* subscribe(WS_METHODS.subscribeServerConfig, {}).pipe(runForEach((event) => gen(function* () {
+		const next = applyServerConfigProjection(yield* get(state), event);
+		if (isNone(next)) return;
+		yield* set(pendingPersistence, some(next.value.config));
+		yield* set$1(state, next);
+		yield* offer(persistence, next.value.config);
+	})), forkScoped);
+	yield* addFinalizer(() => get$1(pendingPersistence).pipe(flatMap(match({
+		onNone: () => void_,
+		onSome: (config) => persist(config).pipe(asVoid)
+	}))));
+	return state;
+});
+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)
+	})))))));
+}
+function projectServerWelcome(current, event) {
+	if (event.type !== "welcome") return [current, []];
+	const welcome = event.payload;
+	return [some(welcome), [welcome]];
+}
+function resolveServerConfigValue(projection, initialConfig) {
+	if (projection?.source === "live") return projection.config;
+	return initialConfig ?? projection?.config ?? null;
+}
+function createServerEnvironmentAtoms(runtime, options) {
+	const configScheduler = 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 configValueAtom = family((environmentId) => {
+		if (environmentId === null) return emptyConfigAtom;
+		return make$2((get) => {
+			return resolveServerConfigValue(getOrNull(value(get(configProjection({
+				environmentId,
+				input: {}
+			})))), get(options.initialConfigValueAtom(environmentId)));
+		}).pipe(withLabel(`environment-data:server:config:${environmentId}`));
+	});
+	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}`))),
+		traceDiagnostics: createEnvironmentRpcQueryAtomFamily(runtime, {
+			label: "environment-data:server:trace-diagnostics",
+			tag: WS_METHODS.serverGetTraceDiagnostics
+		}),
+		processDiagnostics: createEnvironmentRpcQueryAtomFamily(runtime, {
+			label: "environment-data:server:process-diagnostics",
+			tag: WS_METHODS.serverGetProcessDiagnostics
+		}),
+		processResourceHistory: createEnvironmentRpcQueryAtomFamily(runtime, {
+			label: "environment-data:server:process-resource-history",
+			tag: WS_METHODS.serverGetProcessResourceHistory
+		}),
+		resourceTelemetry: createEnvironmentRpcSubscriptionAtomFamily(runtime, {
+			label: "environment-data:server:resource-telemetry",
+			tag: WS_METHODS.subscribeResourceTelemetry,
+			idleTtlMs: 0
+		}),
+		resourceTelemetryHistory: createEnvironmentRpcQueryAtomFamily(runtime, {
+			label: "environment-data:server:resource-telemetry-history",
+			tag: WS_METHODS.serverGetResourceTelemetryHistory,
+			staleTimeMs: 5e3
+		}),
+		configProjection,
+		welcome: createEnvironmentRpcSubscriptionAtomFamily(runtime, {
+			label: "environment-data:server:welcome",
+			tag: WS_METHODS.subscribeServerLifecycle,
+			transform: (stream) => stream.pipe(mapAccum(none, projectServerWelcome))
+		}),
+		refreshProviders: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:server:refresh-providers",
+			tag: WS_METHODS.serverRefreshProviders,
+			concurrency: {
+				mode: "singleFlight",
+				key: ({ environmentId }) => environmentId
+			}
+		}),
+		updateProvider: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:server:update-provider",
+			tag: WS_METHODS.serverUpdateProvider,
+			scheduler: configScheduler,
+			concurrency: configConcurrency
+		}),
+		updateServer: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:server:update-server",
+			tag: WS_METHODS.serverUpdateServer,
+			scheduler: configScheduler,
+			concurrency: configConcurrency
+		}),
+		upsertKeybinding: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:server:upsert-keybinding",
+			tag: WS_METHODS.serverUpsertKeybinding,
+			scheduler: configScheduler,
+			concurrency: configConcurrency
+		}),
+		removeKeybinding: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:server:remove-keybinding",
+			tag: WS_METHODS.serverRemoveKeybinding,
+			scheduler: configScheduler,
+			concurrency: configConcurrency
+		}),
+		updateSettings: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:server:update-settings",
+			tag: WS_METHODS.serverUpdateSettings,
+			scheduler: configScheduler,
+			concurrency: configConcurrency
+		}),
+		signalProcess: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:server:signal-process",
+			tag: WS_METHODS.serverSignalProcess
+		}),
+		retryResourceTelemetry: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:server:retry-resource-telemetry",
+			tag: WS_METHODS.serverRetryResourceTelemetry,
+			concurrency: {
+				mode: "singleFlight",
+				key: ({ environmentId }) => environmentId
+			}
+		})
+	};
+}
+//#endregion
+export { applyServerConfigProjection, createServerEnvironmentAtoms, makeEnvironmentServerConfigState, projectServerConfig, projectServerWelcome, resolveServerConfigValue, serverConfigStateChanges };