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 Predicate from "effect/Predicate";
import {
ConnectionCatalogDocument,
type ConnectionCatalogDocument as ConnectionCatalogDocumentType,
EMPTY_CONNECTION_CATALOG_DOCUMENT,
} from "@akeru/client-runtime/platform";
import { ConnectionTransientError } from "@akeru/client-runtime/connection";
import * as Effect from "effect/Effect";
import * as Option from "effect/Option";
import * as Ref from "effect/Ref";
import * as Schema from "effect/Schema";
import * as Semaphore from "effect/Semaphore";
import {
CATALOG_STORE_NAME,
catalogError,
readDatabaseValue,
writeDatabaseValue,
} from "./indexedDbStorage";
const CATALOG_KEY = "document";
const ConnectionCatalogDocumentJson = Schema.fromJsonString(ConnectionCatalogDocument);
const decodeConnectionCatalogDocument = Schema.decodeUnknownEffect(ConnectionCatalogDocumentJson);
const encodeConnectionCatalogDocument = Schema.encodeEffect(ConnectionCatalogDocumentJson);
const decodeCatalog = Effect.fn("web.connectionStorage.decodeCatalog")(function* (raw: string) {
return yield* decodeConnectionCatalogDocument(raw).pipe(
Effect.mapError((cause) => catalogError("decode", cause)),
);
});
const encodeCatalog = Effect.fn("web.connectionStorage.encodeCatalog")(function* (
catalog: ConnectionCatalogDocumentType,
) {
return yield* encodeConnectionCatalogDocument(catalog).pipe(
Effect.mapError((cause) => catalogError("encode", cause)),
);
});
export interface CatalogBackend {
readonly read: Effect.Effect<string | null, ConnectionTransientError>;
readonly write: (raw: string) => Effect.Effect<void, ConnectionTransientError>;
readonly quarantine?: (raw: string) => Effect.Effect<void, ConnectionTransientError>;
}
/** Desktop secure storage when the bridge offers it; otherwise the catalog store in this database. */
export function catalogBackendForDatabase(database: IDBDatabase): CatalogBackend {
const bridge = window.desktopBridge;
if (bridge?.getConnectionCatalog !== undefined && bridge.setConnectionCatalog !== undefined) {
return {
read: Effect.tryPromise({
try: () => bridge.getConnectionCatalog!(),
catch: (cause) => catalogError("load", cause),
}),
write: (raw) =>
Effect.tryPromise({
try: () => bridge.setConnectionCatalog!(raw),
catch: (cause) => catalogError("save", cause),
}).pipe(
Effect.flatMap((stored) =>
stored
? Effect.void
: Effect.fail(
catalogError(
"save",
"Desktop secure storage is unavailable in this system context.",
),
),
),
),
};
}
return {
read: readDatabaseValue(database, CATALOG_STORE_NAME, CATALOG_KEY).pipe(
Effect.map((value) => (Predicate.isString(value) ? value : null)),
),
write: (raw) => writeDatabaseValue(database, CATALOG_STORE_NAME, CATALOG_KEY, raw),
quarantine: (raw) =>
writeDatabaseValue(database, CATALOG_STORE_NAME, `${CATALOG_KEY}:corrupt:${Date.now()}`, raw),
};
}
interface CatalogStore {
readonly read: Effect.Effect<ConnectionCatalogDocumentType, ConnectionTransientError>;
readonly update: (
transform: (catalog: ConnectionCatalogDocumentType) => ConnectionCatalogDocumentType,
) => Effect.Effect<void, ConnectionTransientError>;
}
/** Serializes catalog reads and writes over a backend and caches the decoded document. */
export const cachedCatalogStore = Effect.fn("web.connectionStorage.makeCatalogStore")(function* (
backend: CatalogBackend,
) {
const state = yield* Ref.make<Option.Option<ConnectionCatalogDocumentType>>(Option.none());
const lock = yield* Semaphore.make(1);
const loadUnlocked = Effect.fn("web.connectionStorage.loadCatalog")(function* () {
const cached = yield* Ref.get(state);
if (Option.isSome(cached)) {
return cached.value;
}
const raw = yield* backend.read;
let catalog = EMPTY_CONNECTION_CATALOG_DOCUMENT;
if (raw !== null && raw.trim() !== "") {
catalog = yield* decodeCatalog(raw).pipe(
Effect.catch((error) =>
Effect.gen(function* () {
yield* Effect.logWarning("Discarding a corrupt web connection catalog.", {
error: error.message,
});
if (backend.quarantine !== undefined) {
yield* backend.quarantine(raw).pipe(
Effect.catch((cause) =>
Effect.logWarning("Could not quarantine the corrupt web connection catalog.", {
error: cause.message,
}),
),
);
}
const encoded = yield* encodeCatalog(EMPTY_CONNECTION_CATALOG_DOCUMENT);
yield* backend.write(encoded).pipe(
Effect.catch((cause) =>
Effect.logWarning("Could not persist the recovered web connection catalog.", {
error: cause.message,
}),
),
);
return EMPTY_CONNECTION_CATALOG_DOCUMENT;
}),
),
);
}
yield* Ref.set(state, Option.some(catalog));
return catalog;
});
const read = lock.withPermits(1)(loadUnlocked());
const update: CatalogStore["update"] = Effect.fn("web.connectionStorage.updateCatalog")(
function* (transform) {
yield* lock.withPermits(1)(
Effect.gen(function* () {
const next = transform(yield* loadUnlocked());
yield* backend.write(yield* encodeCatalog(next));
yield* Ref.set(state, Option.some(next));
}),
);
},
);
return { read, update } satisfies CatalogStore;
});