Skip to content

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.

8.3 KB
Raw Blame
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;
      }
    },
  };
}