Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
import {
type EnvironmentId,
type ServerConfig,
type ServerConfigStreamEvent,
type ServerLifecycleWelcomePayload,
WS_METHODS,
} from "@akeru/contracts";
import * as Effect from "effect/Effect";
import * as Option from "effect/Option";
import * as Queue from "effect/Queue";
import * as Ref from "effect/Ref";
import * as Result from "effect/Result";
import * as Stream from "effect/Stream";
import * as SubscriptionRef from "effect/SubscriptionRef";
import { EnvironmentSupervisor } from "../connection/supervisor.ts";
import { safeErrorLogAttributes } from "../errors/safeLog.ts";
import { EnvironmentCacheStore } from "../platform/persistence.ts";
import { subscribe } from "../rpc/client.ts";
import { followStreamInEnvironment } from "./runtime.ts";
export interface ServerConfigProjection {
readonly config: ServerConfig;
readonly latestEvent: ServerConfigStreamEvent;
readonly source: "cache" | "live";
}
export function applyServerConfigProjection(
current: Option.Option<ServerConfigProjection>,
event: ServerConfigStreamEvent,
): Option.Option<ServerConfigProjection> {
switch (event.type) {
case "snapshot":
return Option.some({
config: event.config,
latestEvent: event,
source: "live",
});
case "keybindingsUpdated":
return Option.map(current, (projection) => ({
config: {
...projection.config,
keybindings: event.payload.keybindings,
issues: event.payload.issues,
},
latestEvent: event,
source: "live",
}));
case "providerStatuses":
return Option.map(current, (projection) => ({
config: {
...projection.config,
providers: event.payload.providers,
},
latestEvent: event,
source: "live",
}));
case "settingsUpdated":
return Option.map(current, (projection) => ({
config: {
...projection.config,
settings: event.payload.settings,
},
latestEvent: event,
source: "live",
}));
}
}
export function projectServerConfig(
current: Option.Option<ServerConfigProjection>,
event: ServerConfigStreamEvent,
): readonly [Option.Option<ServerConfigProjection>, ReadonlyArray<ServerConfigProjection>] {
const next = applyServerConfigProjection(current, event);
return [next, Option.toArray(next)];
}
const cachedConfigSnapshotEvent = (config: ServerConfig): ServerConfigStreamEvent => ({
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.
*/
export const makeEnvironmentServerConfigState = Effect.fn("EnvironmentServerConfigState.make")(
function* () {
const supervisor = yield* EnvironmentSupervisor;
const cache = yield* EnvironmentCacheStore;
const environmentId = supervisor.target.environmentId;
const cachedConfig = yield* cache.loadServerConfig(environmentId).pipe(
Effect.catch((error) =>
Effect.logWarning("Could not load cached server configuration.").pipe(
Effect.annotateLogs({
environmentId,
...safeErrorLogAttributes(error),
}),
Effect.as(Option.none<ServerConfig>()),
),
),
);
const state = yield* SubscriptionRef.make<Option.Option<ServerConfigProjection>>(
Option.map(cachedConfig, (config) => ({
config,
latestEvent: cachedConfigSnapshotEvent(config),
source: "cache" as const,
})),
);
const persistence = yield* Queue.sliding<ServerConfig>(1);
const pendingPersistence = yield* Ref.make<Option.Option<ServerConfig>>(Option.none());
const persist = Effect.fn("EnvironmentServerConfigState.persist")(function* (
config: ServerConfig,
) {
return yield* cache.saveServerConfig(environmentId, config).pipe(
Effect.as(true),
Effect.catch((error) =>
Effect.logWarning("Could not persist cached server configuration.").pipe(
Effect.annotateLogs({
environmentId,
...safeErrorLogAttributes(error),
}),
Effect.as(false),
),
),
);
});
const persistPending = Effect.fn("EnvironmentServerConfigState.persistPending")(function* (
config: ServerConfig,
) {
if (!(yield* persist(config))) {
return;
}
yield* Ref.update(pendingPersistence, (pending) =>
Option.isSome(pending) && pending.value === config ? Option.none() : pending,
);
});
yield* Stream.fromQueue(persistence).pipe(
Stream.debounce("500 millis"),
Stream.runForEach(persistPending),
Effect.forkScoped,
);
yield* subscribe(WS_METHODS.subscribeServerConfig, {}).pipe(
Stream.runForEach((event) =>
Effect.gen(function* () {
const next = applyServerConfigProjection(yield* SubscriptionRef.get(state), event);
if (Option.isNone(next)) {
return;
}
yield* Ref.set(pendingPersistence, Option.some(next.value.config));
yield* SubscriptionRef.set(state, next);
yield* Queue.offer(persistence, next.value.config);
}),
),
Effect.forkScoped,
);
yield* Effect.addFinalizer(() =>
Ref.get(pendingPersistence).pipe(
Effect.flatMap(
Option.match({
onNone: () => Effect.void,
onSome: (config) => persist(config).pipe(Effect.asVoid),
}),
),
),
);
return state;
},
);
export function serverConfigStateChanges(environmentId: EnvironmentId) {
return followStreamInEnvironment(
environmentId,
Stream.unwrap(
makeEnvironmentServerConfigState().pipe(
Effect.map((state) =>
SubscriptionRef.changes(state).pipe(
Stream.filterMap((projection) =>
Option.match(projection, {
onNone: () => Result.failVoid,
onSome: (value) => Result.succeed(value),
}),
),
),
),
),
),
);
}
export function projectServerWelcome(
current: Option.Option<ServerLifecycleWelcomePayload>,
event: {
readonly type: "welcome" | "ready";
readonly payload: unknown;
},
): readonly [
Option.Option<ServerLifecycleWelcomePayload>,
ReadonlyArray<ServerLifecycleWelcomePayload>,
] {
if (event.type !== "welcome") {
return [current, []];
}
// SAFETY: The lifecycle subscription decodes welcome payloads before this projection receives them.
const welcome = event.payload as ServerLifecycleWelcomePayload;
return [Option.some(welcome), [welcome]];
}
export function resolveServerConfigValue(
projection: ServerConfigProjection | null,
initialConfig: ServerConfig | null,
): ServerConfig | null {
if (
projection?.source === "live" &&
(initialConfig === null ||
projection.config.environment.serverVersion === initialConfig.environment.serverVersion)
) {
return projection.config;
}
return initialConfig ?? projection?.config ?? null;
}