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 * as NodeHttpServer from "@effect/platform-node/NodeHttpServer";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { CommandId, ORCHESTRATION_WS_METHODS, ProjectId, ThreadId } from "@akeru/contracts";
import { assert, it } from "@effect/vitest";
import { assertTrue } from "@effect/vitest/utils";
import * as Effect from "effect/Effect";
import * as Stream from "effect/Stream";
import { PersistenceSqlError } from "./persistence/Errors.ts";
import { defaultModelSelection } from "./serverTestFixtures.ts";
import { buildAppUnderTest } from "./serverTestApp.ts";
import { getWsServerUrl, withWsRpcClient } from "./serverTestClients.ts";
it.layer(NodeServices.layer)("server router seam", (it) => {
it.effect("routes websocket rpc orchestration methods", () =>
Effect.gen(function* () {
const now = "2026-01-01T00:00:00.000Z";
const snapshot = {
snapshotSequence: 1,
updatedAt: now,
bots: [],
groups: [],
delegations: [],
projects: [
{
id: ProjectId.make("project-a"),
title: "Project A",
workspaceRoot: "/tmp/project-a",
defaultModelSelection,
scripts: [],
createdAt: now,
updatedAt: now,
deletedAt: null,
},
],
threads: [
{
id: ThreadId.make("thread-1"),
projectId: ProjectId.make("project-a"),
title: "Thread A",
modelSelection: defaultModelSelection,
interactionMode: "default" as const,
runtimeMode: "full-access" as const,
branch: null,
worktreePath: null,
createdAt: now,
updatedAt: now,
archivedAt: null,
settledOverride: null,
settledAt: null,
latestTurn: null,
messages: [],
session: null,
activities: [],
proposedPlans: [],
checkpoints: [],
deletedAt: null,
},
],
};
yield* buildAppUnderTest({
layers: {
projectionSnapshotQuery: {
getSnapshot: () => Effect.succeed(snapshot),
searchThreads: () =>
Effect.succeed({
matches: [
{
threadId: ThreadId.make("thread-1"),
projectId: ProjectId.make("project-a"),
source: "assistant",
snippet: "Search reached the final response.",
messageCreatedAt: now,
},
],
}),
},
orchestrationEngine: {
dispatch: () => Effect.succeed({ sequence: 7 }),
readEvents: () => Stream.empty,
},
checkpointDiffQuery: {
getTurnDiff: () =>
Effect.succeed({
threadId: ThreadId.make("thread-1"),
fromTurnCount: 0,
toTurnCount: 1,
diff: "turn-diff",
}),
getFullThreadDiff: () =>
Effect.succeed({
threadId: ThreadId.make("thread-1"),
fromTurnCount: 0,
toTurnCount: 1,
diff: "full-diff",
}),
},
},
});
const wsUrl = yield* getWsServerUrl("/ws");
const dispatchResult = yield* Effect.scoped(
withWsRpcClient(wsUrl, (client) =>
client[ORCHESTRATION_WS_METHODS.dispatchCommand]({
type: "thread.session.stop",
commandId: CommandId.make("cmd-1"),
threadId: ThreadId.make("thread-1"),
createdAt: now,
}),
),
);
assert.equal(dispatchResult.sequence, 7);
const turnDiffResult = yield* Effect.scoped(
withWsRpcClient(wsUrl, (client) =>
client[ORCHESTRATION_WS_METHODS.getTurnDiff]({
threadId: ThreadId.make("thread-1"),
fromTurnCount: 0,
toTurnCount: 1,
}),
),
);
assert.equal(turnDiffResult.diff, "turn-diff");
const fullDiffResult = yield* Effect.scoped(
withWsRpcClient(wsUrl, (client) =>
client[ORCHESTRATION_WS_METHODS.getFullThreadDiff]({
threadId: ThreadId.make("thread-1"),
toTurnCount: 1,
}),
),
);
assert.equal(fullDiffResult.diff, "full-diff");
const searchResult = yield* Effect.scoped(
withWsRpcClient(wsUrl, (client) =>
client[ORCHESTRATION_WS_METHODS.searchThreads]({
query: "final response",
}),
),
);
assert.deepEqual(searchResult.matches, [
{
threadId: ThreadId.make("thread-1"),
projectId: ProjectId.make("project-a"),
source: "assistant",
snippet: "Search reached the final response.",
messageCreatedAt: now,
},
]);
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
it.effect("routes websocket rpc orchestration shell snapshot errors", () =>
Effect.gen(function* () {
const projectionError = new PersistenceSqlError({
operation: "ProjectionSnapshotQuery.getShellSnapshot:test",
detail: "failed to read projection shell snapshot",
});
yield* buildAppUnderTest({
layers: {
projectionSnapshotQuery: {
getShellSnapshot: () => Effect.fail(projectionError),
},
},
});
const wsUrl = yield* getWsServerUrl("/ws");
const result = yield* Effect.scoped(
withWsRpcClient(wsUrl, (client) =>
client[ORCHESTRATION_WS_METHODS.subscribeShell]({}).pipe(Stream.runCollect),
).pipe(Effect.result),
);
assertTrue(Predicate.isTagged(result, "Failure"));
assertTrue(Predicate.isTagged(result.failure, "OrchestrationGetSnapshotError"));
assertTrue(result.failure.cause instanceof Error);
assert.include(result.failure.cause.message, projectionError.message);
}).pipe(Effect.provide(NodeHttpServer.layerTest)),
);
});