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 Exit from "effect/Exit";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { ProjectId, ThreadId, TurnId, ProviderInstanceId } from "@akeru/contracts";
import * as Clock from "effect/Clock";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as ManagedRuntime from "effect/ManagedRuntime";
import * as Option from "effect/Option";
import * as Scope from "effect/Scope";
import { vi } from "vite-plus/test";
import { ProjectionSnapshotQuery } from "../../../orchestration/Services/ProjectionSnapshotQuery.ts";
import { SqlitePersistenceMemory } from "../../../persistence/Layers/Sqlite.ts";
import * as ProviderSessionRuntime from "../../../persistence/ProviderSessionRuntime.ts";
import { AgentController, type AgentControllerShape } from "../../Services/AgentController.ts";
import { ProviderSessionReaper } from "../../Services/ProviderSessionReaper.ts";
import { ProviderSessionDirectoryLive } from "../ProviderSessionDirectory.ts";
import { providerSessionReaperLayerWith } from "../ProviderSessionReaper.ts";
export const defaultModelSelection = {
instanceId: ProviderInstanceId.make("codex"),
model: "gpt-5-codex",
} as const;
export const drainFibers = Effect.forEach(Array.from({ length: 10 }), () => Effect.yieldNow, {
discard: true,
});
export function makeReadModel(
threads: ReadonlyArray<{
readonly id: ThreadId;
readonly session: {
readonly threadId: ThreadId;
readonly status: "starting" | "running" | "ready" | "interrupted" | "stopped" | "error";
readonly providerName: "codex" | "claudeAgent";
readonly runtimeMode: "approval-required" | "full-access" | "auto-accept-edits";
readonly activeTurnId: TurnId | null;
readonly lastError: string | null;
readonly updatedAt: string;
} | null;
readonly backgroundLiveness?: "working" | "monitoring" | null;
}>,
) {
const now = "2026-01-01T00:00:00.000Z";
const projectId = ProjectId.make("project-provider-session-reaper");
return {
snapshotSequence: 0,
updatedAt: now,
projects: [
{
id: projectId,
title: "Provider Reaper Project",
workspaceRoot: "/tmp/provider-reaper-project",
defaultModelSelection,
scripts: [],
createdAt: now,
updatedAt: now,
deletedAt: null,
},
],
threads: threads.map((thread) => ({
id: thread.id,
projectId,
title: `Thread ${thread.id}`,
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,
latestUserMessageAt: null,
hasPendingApprovals: false,
hasPendingUserInput: false,
hasActionableProposedPlan: false,
latestTurn: null,
messages: [],
session: thread.session,
backgroundLiveness: thread.backgroundLiveness ?? null,
activities: [],
proposedPlans: [],
checkpoints: [],
deletedAt: null,
})),
};
}
export function createReaperSupport() {
let runtime: ManagedRuntime.ManagedRuntime<
ProviderSessionReaper | ProviderSessionRuntime.ProviderSessionRuntimeRepository,
unknown
> | null = null;
let scope: Scope.Closeable | null = null;
async function startReaper() {
await runtime!.runPromise(
Effect.gen(function* () {
const reaper = yield* ProviderSessionReaper;
scope = yield* Scope.make("sequential");
yield* reaper.start().pipe(Scope.provide(scope));
}),
);
}
async function sweepAt(nowMs: number) {
await runtime!.runPromise(
Effect.gen(function* () {
const reaper = yield* ProviderSessionReaper;
const clock = yield* Clock.Clock;
const swept = yield* Deferred.make<void>();
yield* reaper.start().pipe(
Effect.provideService(Clock.Clock, {
currentTimeMillis: Effect.succeed(nowMs),
currentTimeMillisUnsafe: () => nowMs,
currentTimeNanos: Effect.succeed(BigInt(nowMs) * 1_000_000n),
currentTimeNanosUnsafe: () => BigInt(nowMs) * 1_000_000n,
monotonicTimeNanos: clock.monotonicTimeNanos,
monotonicTimeNanosUnsafe: () => clock.monotonicTimeNanosUnsafe(),
sleep: () => Deferred.succeed(swept, undefined).pipe(Effect.andThen(Effect.never)),
}),
);
yield* Deferred.await(swept);
}).pipe(Effect.scoped),
);
}
async function createHarness(input: {
readonly readModel: ReturnType<typeof makeReadModel>;
readonly stopSessionImplementation?: (input: {
readonly threadId: ThreadId;
}) => ReturnType<AgentControllerShape["stopSession"]>;
}) {
const stoppedThreadIds = new Set<ThreadId>();
const stopWaiters = new Map<number, () => void>();
const stopSession = vi.fn<AgentControllerShape["stopSession"]>((request) => {
const operation = input.stopSessionImplementation
? input.stopSessionImplementation(request)
: Effect.sync(() => stoppedThreadIds.add(request.threadId));
return operation.pipe(
Effect.ensuring(
Effect.sync(() => {
for (const [count, resolve] of stopWaiters) {
if (stopSession.mock.calls.length >= count) {
stopWaiters.delete(count);
resolve();
}
}
}),
),
) as ReturnType<AgentControllerShape["stopSession"]>;
});
const runtimeRepositoryLayer = ProviderSessionRuntime.layer.pipe(
Layer.provide(SqlitePersistenceMemory),
);
const providerSessionDirectoryLayer = ProviderSessionDirectoryLive.pipe(
Layer.provide(runtimeRepositoryLayer),
);
const layer = providerSessionReaperLayerWith({
inactivityThresholdMs: 1_000,
sweepIntervalMs: 60_000,
}).pipe(
Layer.provideMerge(providerSessionDirectoryLayer),
Layer.provideMerge(runtimeRepositoryLayer),
Layer.provideMerge(Layer.mock(AgentController)({ stopSession })),
Layer.provideMerge(
Layer.succeed(ProjectionSnapshotQuery, {
getCommandReadModel: () => Effect.die("unused"),
getSnapshot: () => Effect.die("unused"),
getShellSnapshot: () => Effect.die("unused"),
getArchivedShellSnapshot: () => Effect.die("unused"),
getSnapshotSequence: () =>
Effect.succeed({ snapshotSequence: input.readModel.snapshotSequence }),
getCounts: () => Effect.die("unused"),
getEventReplayStats: () => Effect.die("unused"),
getOriginalProjectIdByWorkspaceRoot: () => Effect.die("unused"),
getActiveProjectByWorkspaceRoot: () => Effect.die("unused"),
getProjectShellById: () => Effect.die("unused"),
getFirstActiveThreadIdByProjectId: () => Effect.die("unused"),
getThreadCheckpointContext: () => Effect.die("unused"),
getFullThreadDiffContext: () => Effect.die("unused"),
getThreadShellById: (threadId) =>
Effect.succeed(
input.readModel.threads.find((thread) => thread.id === threadId)
? Option.some(input.readModel.threads.find((thread) => thread.id === threadId)!)
: Option.none(),
),
getThreadRuntimeContext: () => Effect.die("unused"),
getTurnStartMessage: () => Effect.die("unused"),
getThreadDetailById: () => Effect.die("unused"),
getThreadDetailSnapshot: () => Effect.die("unused"),
searchThreads: () => Effect.succeed({ matches: [] }),
}),
),
Layer.provideMerge(NodeServices.layer),
);
const waitForStopCount = (count: number) => {
if (stopSession.mock.calls.length >= count) {
return Promise.resolve();
}
return new Promise<void>((resolve) => stopWaiters.set(count, resolve));
};
runtime = ManagedRuntime.make(layer);
return { stopSession, stoppedThreadIds, waitForStopCount };
}
return {
get runtime() {
return runtime;
},
startReaper,
sweepAt,
createHarness,
async close() {
if (scope) {
await Effect.runPromise(Scope.close(scope, Exit.void));
scope = null;
}
if (runtime) {
await runtime.dispose();
runtime = null;
}
},
};
}