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 * as Data from "effect/Data";
import { hasTag } from "~/lib/taggedUnion";
import { PlatformConnectionSource } from "@akeru/client-runtime/platform";
import {
BearerConnectionCredential,
BearerConnectionProfile,
BearerConnectionRegistration,
BearerConnectionTarget,
ConnectionTransientError,
mapRemoteEnvironmentError,
type PlatformConnectionRegistration,
PrimaryConnectionRegistration,
PrimaryConnectionTarget,
} from "@akeru/client-runtime/connection";
import { bootstrapRemoteBearerSession } from "@akeru/client-runtime/authorization";
import { fetchRemoteEnvironmentDescriptor } from "@akeru/client-runtime/environment";
import {
AuthStandardClientScopes,
type DesktopEnvironmentBootstrap,
PRIMARY_LOCAL_ENVIRONMENT_ID,
} from "@akeru/contracts";
import * as Clock from "effect/Clock";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Ref from "effect/Ref";
import * as Stream from "effect/Stream";
import { FetchHttpClient } from "effect/unstable/http";
import { primaryEnvironmentHttpLayer } from "../environments/primary/httpLayer";
import {
readPrimaryEnvironmentTarget,
type PrimaryEnvironmentTarget,
} from "../environments/primary/target";
import {
desktopLocalConnectionId,
readDesktopSecondaryBootstrapsResult,
type DesktopSecondaryBootstrapsRead,
} from "./desktopLocal";
import { clientMetadata } from "./browserSignals";
const loadPrimaryConnectionRegistration = Effect.fn(
"web.connectionPlatform.loadPrimaryConnectionRegistration",
)(function* (resolved: PrimaryEnvironmentTarget) {
const descriptor = yield* fetchRemoteEnvironmentDescriptor({
httpBaseUrl: resolved.target.httpBaseUrl,
}).pipe(Effect.provide(primaryEnvironmentHttpLayer), Effect.mapError(mapRemoteEnvironmentError));
return new PrimaryConnectionRegistration({
target: new PrimaryConnectionTarget({
environmentId: descriptor.environmentId,
label: descriptor.label,
httpBaseUrl: resolved.target.httpBaseUrl,
wsBaseUrl: resolved.target.wsBaseUrl,
}),
});
});
// A desktop-local secondary backend (e.g. a parallel WSL backend) lives on its
// own loopback origin, so — unlike the same-origin primary — it authenticates
// with a bearer token minted from the bootstrap credential the desktop issues.
const loadSecondaryConnectionRegistration = Effect.fn(
"web.connectionPlatform.loadSecondaryConnectionRegistration",
)(function* (entry: DesktopEnvironmentBootstrap) {
if (
entry.httpBaseUrl === null ||
entry.wsBaseUrl === null ||
entry.bootstrapToken === undefined
) {
return yield* new ConnectionTransientError({
reason: "endpoint-unavailable",
detail: `Desktop-local backend ${entry.id} is not ready yet.`,
});
}
const httpBaseUrl = entry.httpBaseUrl;
const wsBaseUrl = entry.wsBaseUrl;
const descriptor = yield* fetchRemoteEnvironmentDescriptor({ httpBaseUrl }).pipe(
Effect.mapError(mapRemoteEnvironmentError),
);
const issuedAtEpochMs = yield* Clock.currentTimeMillis;
const access = yield* bootstrapRemoteBearerSession({
httpBaseUrl,
credential: entry.bootstrapToken,
scopes: AuthStandardClientScopes,
clientMetadata: clientMetadata(),
}).pipe(Effect.mapError(mapRemoteEnvironmentError));
// Keep the desktop pool's stable backend id in the connection id. The
// descriptor environment id still scopes projects and RPC state, while the
// backend id lets desktop-only operations (notably the WSL folder picker)
// route back to the instance that owns the environment.
const connectionId = desktopLocalConnectionId(entry.id);
// Prefer the desktop's bootstrap label (it identifies the backend and distro,
// e.g. "WSL: Ubuntu") over the generic descriptor label, so consumers can show
// a meaningful name without recovering it from the bootstrap list later.
const label = entry.label || descriptor.label;
return {
registration: new BearerConnectionRegistration({
target: new BearerConnectionTarget({
environmentId: descriptor.environmentId,
label,
connectionId,
}),
profile: new BearerConnectionProfile({
connectionId,
environmentId: descriptor.environmentId,
label,
httpBaseUrl,
wsBaseUrl,
}),
credential: new BearerConnectionCredential({ token: access.access_token }),
}),
expiresAtEpochMs: secondaryBearerExpiresAtEpochMs(issuedAtEpochMs, access.expires_in),
refreshAtEpochMs: secondaryBearerRefreshAtEpochMs(issuedAtEpochMs, access.expires_in),
};
});
// Poll cadence for the desktop bootstrap topology. There is no change event on
// the bridge, so the renderer polls; successful registrations are cached by a
// signature of their endpoint + token until bearer credentials approach expiry.
const PLATFORM_POLL_INTERVAL = "3 seconds";
const SECONDARY_BEARER_REFRESH_SKEW_MS = 5_000;
export function secondaryBearerExpiresAtEpochMs(
issuedAtEpochMs: number,
expiresInSeconds: number,
): number {
return issuedAtEpochMs + Math.max(0, expiresInSeconds * 1_000);
}
export function secondaryBearerRefreshAtEpochMs(
issuedAtEpochMs: number,
expiresInSeconds: number,
): number {
return Math.max(
issuedAtEpochMs,
secondaryBearerExpiresAtEpochMs(issuedAtEpochMs, expiresInSeconds) -
SECONDARY_BEARER_REFRESH_SKEW_MS,
);
}
interface CachedPlatformRegistration {
readonly signature: string;
readonly registration: PlatformConnectionRegistration;
readonly expiresAtEpochMs?: number;
readonly refreshAtEpochMs?: number;
}
export type PrimaryEnvironmentTargetRead =
| {
readonly _tag: "Success";
readonly target: PrimaryEnvironmentTarget | null;
}
| {
readonly _tag: "Failure";
readonly cause: unknown;
};
const PrimaryEnvironmentTargetRead = Data.taggedEnum<PrimaryEnvironmentTargetRead>();
export function readPrimaryEnvironmentTargetResult(
readTarget: () => PrimaryEnvironmentTarget | null = readPrimaryEnvironmentTarget,
): PrimaryEnvironmentTargetRead {
try {
return PrimaryEnvironmentTargetRead.Success({ target: readTarget() });
} catch (cause) {
return PrimaryEnvironmentTargetRead.Failure({ cause });
}
}
export function primaryRegistrationToRetainAfterTopologyRead(
previous: ReadonlyMap<string, CachedPlatformRegistration>,
topologyRead: PrimaryEnvironmentTargetRead,
): CachedPlatformRegistration | undefined {
return hasTag(topologyRead, "Failure") ? previous.get(PRIMARY_LOCAL_ENVIRONMENT_ID) : undefined;
}
export function canReuseCachedPlatformRegistration(
cached: CachedPlatformRegistration,
signature: string,
nowEpochMs: number,
): boolean {
return (
cached.signature === signature &&
(cached.refreshAtEpochMs === undefined || nowEpochMs < cached.refreshAtEpochMs)
);
}
export function canRetainCachedPlatformRegistrationAfterRefreshFailure(
cached: CachedPlatformRegistration,
signature: string,
nowEpochMs: number,
): boolean {
return (
cached.signature === signature &&
cached.expiresAtEpochMs !== undefined &&
nowEpochMs < cached.expiresAtEpochMs
);
}
export function secondaryRegistrationsToRetainAfterTopologyRead(
previous: ReadonlyMap<string, CachedPlatformRegistration>,
topologyRead: DesktopSecondaryBootstrapsRead,
nowEpochMs: number,
): ReadonlyMap<string, CachedPlatformRegistration> {
if (hasTag(topologyRead, "Success")) {
return new Map();
}
return new Map(
[...previous].filter(
([, cached]) => cached.expiresAtEpochMs !== undefined && nowEpochMs < cached.expiresAtEpochMs,
),
);
}
export const platformConnectionSourceLayer = Layer.effect(
PlatformConnectionSource,
Effect.gen(function* () {
const cacheRef = yield* Ref.make(new Map<string, CachedPlatformRegistration>());
// Resolve the full set of platform-managed environments the host currently
// reports: the primary (same-origin cookie auth) plus any desktop-local
// backends running alongside it (bearer auth). Reused registrations come
// from the cache; a failed entry is skipped and retried on the next poll.
const buildPlatformRegistrations = Effect.gen(function* () {
const previous = yield* Ref.get(cacheRef);
const nowEpochMs = yield* Clock.currentTimeMillis;
const next = new Map<string, CachedPlatformRegistration>();
const registrations: Array<PlatformConnectionRegistration> = [];
const primaryTopologyRead = readPrimaryEnvironmentTargetResult();
const retainedPrimary = primaryRegistrationToRetainAfterTopologyRead(
previous,
primaryTopologyRead,
);
if (retainedPrimary !== undefined) {
next.set(PRIMARY_LOCAL_ENVIRONMENT_ID, retainedPrimary);
registrations.push(retainedPrimary.registration);
}
if (hasTag(primaryTopologyRead, "Failure")) {
yield* Effect.logWarning("Could not read the primary environment topology.", {
cause: primaryTopologyRead.cause,
});
} else if (primaryTopologyRead.target !== null) {
const primaryTarget = primaryTopologyRead.target;
const signature = `primary|${primaryTarget.target.httpBaseUrl}|${primaryTarget.target.wsBaseUrl}`;
const cached = previous.get(PRIMARY_LOCAL_ENVIRONMENT_ID);
if (
cached !== undefined &&
canReuseCachedPlatformRegistration(cached, signature, nowEpochMs)
) {
next.set(PRIMARY_LOCAL_ENVIRONMENT_ID, cached);
registrations.push(cached.registration);
} else {
const built = yield* loadPrimaryConnectionRegistration(primaryTarget).pipe(
Effect.tapError((error) =>
Effect.logWarning("Could not discover the primary environment.", { error }),
),
Effect.option,
);
if (Option.isSome(built)) {
const cacheEntry = { signature, registration: built.value };
next.set(PRIMARY_LOCAL_ENVIRONMENT_ID, cacheEntry);
registrations.push(built.value);
}
}
}
const topologyRead = readDesktopSecondaryBootstrapsResult();
for (const [id, cached] of secondaryRegistrationsToRetainAfterTopologyRead(
previous,
topologyRead,
nowEpochMs,
)) {
next.set(id, cached);
registrations.push(cached.registration);
}
if (hasTag(topologyRead, "Failure")) {
yield* Effect.logWarning("Could not read the desktop-local backend topology.", {
cause: topologyRead.cause,
});
} else {
for (const bootstrap of topologyRead.bootstraps) {
const signature = `${bootstrap.httpBaseUrl}|${bootstrap.wsBaseUrl}|${bootstrap.bootstrapToken ?? ""}`;
const cached = previous.get(bootstrap.id);
if (
cached !== undefined &&
canReuseCachedPlatformRegistration(cached, signature, nowEpochMs)
) {
next.set(bootstrap.id, cached);
registrations.push(cached.registration);
continue;
}
const built = yield* loadSecondaryConnectionRegistration(bootstrap).pipe(
Effect.tapError((error) =>
Effect.logWarning("Could not connect a desktop-local backend.", {
id: bootstrap.id,
error,
}),
),
Effect.option,
);
if (Option.isSome(built)) {
const cacheEntry = { signature, ...built.value };
next.set(bootstrap.id, cacheEntry);
registrations.push(built.value.registration);
} else if (
cached !== undefined &&
canRetainCachedPlatformRegistrationAfterRefreshFailure(cached, signature, nowEpochMs)
) {
next.set(bootstrap.id, cached);
registrations.push(cached.registration);
}
}
}
yield* Ref.set(cacheRef, next);
return registrations;
}).pipe(Effect.provide(FetchHttpClient.layer));
return PlatformConnectionSource.of({
registrations: Stream.tick(PLATFORM_POLL_INTERVAL).pipe(
Stream.mapEffect(() => buildPlatformRegistrations),
),
});
}),
);