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 { ConnectionTransientError } from "@akeru/client-runtime/connection";
import { ConnectionCatalogDocument } from "@akeru/client-runtime/platform";
import { describe, expect, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";
import { afterEach, vi } from "vite-plus/test";
import {
catalogBackendForDatabase,
cachedCatalogStore,
migrateLegacyConnectionDatabase,
} from "./storage";
const emptyCatalog = {
schemaVersion: 1,
targets: [],
profiles: [],
credentials: [],
} as const;
const decodeCatalog = Schema.decodeUnknownSync(Schema.fromJsonString(ConnectionCatalogDocument));
afterEach(() => {
vi.unstubAllGlobals();
vi.restoreAllMocks();
});
describe("cachedCatalogStore", () => {
it.effect("quarantines malformed catalogs and starts from an empty document", () =>
Effect.gen(function* () {
const writes: string[] = [];
const quarantined: string[] = [];
const store = yield* cachedCatalogStore({
read: Effect.succeed("{not-json"),
write: (raw) => Effect.sync(() => writes.push(raw)),
quarantine: (raw) => Effect.sync(() => quarantined.push(raw)),
});
expect(yield* store.read).toEqual(emptyCatalog);
expect(quarantined).toEqual(["{not-json"]);
expect(writes).toHaveLength(1);
expect(decodeCatalog(writes[0]!)).toEqual(emptyCatalog);
}),
);
it.effect("does not hide catalog read failures", () =>
Effect.gen(function* () {
const failure = new ConnectionTransientError({
reason: "remote-unavailable",
detail: "permission denied",
});
const store = yield* cachedCatalogStore({
read: Effect.fail(failure),
write: () => Effect.void,
});
expect(yield* Effect.flip(store.read)).toBe(failure);
}),
);
});
describe("catalogBackendForDatabase", () => {
it.effect("fails writes when desktop secure storage declines the catalog", () =>
Effect.gen(function* () {
const setConnectionCatalog = vi.fn().mockResolvedValue(false);
vi.stubGlobal("window", {
desktopBridge: {
getConnectionCatalog: vi.fn().mockResolvedValue(null),
setConnectionCatalog,
},
});
const backend = catalogBackendForDatabase({} as IDBDatabase);
const error = yield* backend.write("{}").pipe(Effect.flip);
expect(error).toBeInstanceOf(ConnectionTransientError);
expect(error.message).toContain("Desktop secure storage is unavailable");
expect(setConnectionCatalog).toHaveBeenCalledWith("{}");
}),
);
});
describe("migrateLegacyConnectionDatabase", () => {
it.effect("fills missing records without replacing numeric-keyed current data", () =>
Effect.gen(function* () {
const fakeIndexedDB = yield* Effect.promise(() =>
import("fake-indexeddb").then((module) => new module.IDBFactory()),
);
vi.stubGlobal("indexedDB", fakeIndexedDB);
vi.stubGlobal(
"IDBKeyRange",
yield* Effect.promise(() => import("fake-indexeddb").then((m) => m.IDBKeyRange)),
);
// Seed the legacy database exactly the way the pre-rebrand client did.
const legacyOpen = indexedDB.open("t3code:connection-runtime", 4);
const legacy = yield* Effect.promise(
() =>
new Promise<IDBDatabase>((resolve, reject) => {
legacyOpen.addEventListener("upgradeneeded", () => {
for (const name of ["catalog", "shell", "thread", "server-config", "vcs-refs"]) {
legacyOpen.result.createObjectStore(name);
}
});
legacyOpen.addEventListener("success", () => resolve(legacyOpen.result));
legacyOpen.addEventListener("error", () => reject(legacyOpen.error));
}),
);
yield* Effect.promise(
() =>
new Promise<void>((resolve, reject) => {
const tx = legacy.transaction(["catalog", "shell"], "readwrite");
tx.addEventListener("complete", () => resolve());
tx.addEventListener("error", () => reject(tx.error));
tx.objectStore("catalog").put("legacy-catalog-doc", "document");
tx.objectStore("shell").put("legacy-shell", "env-1");
tx.objectStore("shell").put("legacy-numeric", 1);
tx.objectStore("shell").put("legacy-second", 2);
}),
);
legacy.close();
// Open the new database (empty) the same way the layer does.
const migratedOpen = indexedDB.open("akeru:connection-runtime", 4);
const migrated = yield* Effect.promise(
() =>
new Promise<IDBDatabase>((resolve, reject) => {
migratedOpen.addEventListener("upgradeneeded", () => {
for (const name of ["catalog", "shell", "thread", "server-config", "vcs-refs"]) {
migratedOpen.result.createObjectStore(name);
}
});
migratedOpen.addEventListener("success", () => resolve(migratedOpen.result));
migratedOpen.addEventListener("error", () => reject(migratedOpen.error));
}),
);
yield* Effect.promise(
() =>
new Promise<void>((resolve, reject) => {
const tx = migrated.transaction("shell", "readwrite");
tx.addEventListener("complete", () => resolve());
tx.addEventListener("error", () => reject(tx.error));
tx.objectStore("shell").put("current-numeric", 1);
}),
);
yield* migrateLegacyConnectionDatabase(migrated);
const read = (store: string, key: IDBValidKey) =>
Effect.promise(
() =>
new Promise<unknown>((resolve, reject) => {
const request = migrated.transaction(store, "readonly").objectStore(store).get(key);
request.addEventListener("success", () => resolve(request.result));
request.addEventListener("error", () => reject(request.error));
}),
);
expect(yield* read("catalog", "document")).toBe("legacy-catalog-doc");
expect(yield* read("shell", "env-1")).toBe("legacy-shell");
expect(yield* read("shell", 1)).toBe("current-numeric");
expect(yield* read("shell", 2)).toBe("legacy-second");
migrated.close();
// Legacy database is retired; reopening it yields a fresh empty DB.
const deletedCheck = indexedDB.open("t3code:connection-runtime", 4);
let created = false;
const legacyAfter = yield* Effect.promise(
() =>
new Promise<IDBDatabase>((resolve, reject) => {
deletedCheck.addEventListener("upgradeneeded", () => {
created = true;
});
deletedCheck.addEventListener("success", () => resolve(deletedCheck.result));
deletedCheck.addEventListener("error", () => reject(deletedCheck.error));
}),
);
expect(created).toBe(true);
expect(Array.from(legacyAfter.objectStoreNames)).toHaveLength(0);
legacyAfter.close();
indexedDB.deleteDatabase("t3code:connection-runtime");
}),
);
it.effect("does not restore records removed after an earlier migration", () =>
Effect.gen(function* () {
const fakeIndexedDB = yield* Effect.promise(() =>
import("fake-indexeddb").then((module) => new module.IDBFactory()),
);
vi.stubGlobal("indexedDB", fakeIndexedDB);
const stores = ["catalog", "shell", "thread", "server-config", "vcs-refs"];
const open = (name: string) =>
Effect.promise(
() =>
new Promise<IDBDatabase>((resolve, reject) => {
const request = indexedDB.open(name, 4);
request.addEventListener("upgradeneeded", () => {
for (const store of stores) request.result.createObjectStore(store);
});
request.addEventListener("success", () => resolve(request.result));
request.addEventListener("error", () => reject(request.error));
}),
);
const change = (database: IDBDatabase, apply: (store: IDBObjectStore) => void) =>
Effect.promise(
() =>
new Promise<void>((resolve, reject) => {
const tx = database.transaction("shell", "readwrite");
tx.addEventListener("complete", () => resolve());
tx.addEventListener("error", () => reject(tx.error));
apply(tx.objectStore("shell"));
}),
);
const seedLegacy = Effect.gen(function* () {
const legacy = yield* open("t3code:connection-runtime");
yield* change(legacy, (store) => store.put("legacy-shell", "env-1"));
legacy.close();
});
yield* seedLegacy;
const migrated = yield* open("akeru:connection-runtime");
yield* migrateLegacyConnectionDatabase(migrated);
yield* change(migrated, (store) => store.delete("env-1"));
// A blocked deletion leaves the legacy database behind for the next start.
yield* seedLegacy;
yield* migrateLegacyConnectionDatabase(migrated);
const restored = yield* Effect.promise(
() =>
new Promise<unknown>((resolve, reject) => {
const request = migrated
.transaction("shell", "readonly")
.objectStore("shell")
.get("env-1");
request.addEventListener("success", () => resolve(request.result));
request.addEventListener("error", () => reject(request.error));
}),
);
expect(restored).toBeUndefined();
migrated.close();
}),
);
});