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.

3.9 KB
Raw Blame
import { afterEach, expect, vi } from "vite-plus/test";
import { it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Logger from "effect/Logger";
import * as Tracer from "effect/Tracer";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { makeLocalFileTracer, traceSink } from "@akeru/shared/observability";
import { DesktopTraceShutdown } from "./DesktopObservability.ts";
import * as DesktopShutdown from "./DesktopShutdown.ts";

const writer = vi.hoisted(() => ({ append: vi.fn<(data: string) => Promise<void>>() }));

vi.mock("node:fs/promises", async (importOriginal) => {
  const original = await importOriginal<typeof import("node:fs/promises")>();

  return {
    ...original,
    appendFile: (_path: Parameters<typeof original.appendFile>[0], data: Uint8Array) =>
      writer.append(Buffer.from(data).toString()),
  };
});

afterEach(() => vi.clearAllMocks());

for (const fail of [false, true]) {
  it.effect(
    `waits for real trace writer acknowledgement before fake native exit (failure=${fail})`,
    () => {
      const entered = Promise.withResolvers<void>();
      const release = Promise.withResolvers<void>();
      const events: string[] = [];
      const records: string[] = [];
      writer.append.mockImplementation(async (data) => {
        records.push(data);
        entered.resolve();
        await release.promise;
        events.push(fail ? "write-error" : "write-complete");

        if (fail) throw new Error("blocked writer failed");
      });

      return Effect.scoped(
        Effect.gen(function* () {
          const fs = yield* FileSystem.FileSystem;
          const directory = yield* fs.makeTempDirectoryScoped();

          const sink = yield* traceSink({
            filePath: `${directory}/desktop.trace.ndjson`,
            maxBytes: 100_000,
            maxFiles: 1,
            batchWindowMs: 60_000,
          });

          const tracer = yield* makeLocalFileTracer({
            filePath: sink.filePath,
            maxBytes: 100_000,
            maxFiles: 1,
            batchWindowMs: 60_000,
            sink,
          });

          const shutdown = yield* DesktopShutdown.DesktopShutdown;

          const exit = yield* shutdown.awaitComplete.pipe(
            Effect.andThen(
              Effect.sync(() => {
                events.push("native-exit");
              }),
            ),
            Effect.forkChild,
          );

          const program = yield* Effect.void.pipe(
            Effect.withSpan("desktop.app"),
            Effect.provideService(Tracer.Tracer, tracer),
            Effect.ensuring(
              DesktopShutdown.acknowledgeShutdown.pipe(
                Effect.provideService(DesktopTraceShutdown, { close: sink.close() }),
              ),
            ),
            Effect.forkChild,
          );

          yield* Effect.promise(() => entered.promise);
          expect(yield* shutdown.isComplete).toBe(false);
          expect(events).toEqual([]);
          release.resolve();
          yield* Fiber.join(program);
          yield* Fiber.join(exit);
          expect(yield* shutdown.isComplete).toBe(true);
          expect(records.join("")).toContain('"name":"desktop.app"');
          expect(events).toEqual(
            fail
              ? ["write-error", "error-reported", "native-exit"]
              : ["write-complete", "native-exit"],
          );
        }),
      ).pipe(
        Effect.provide(
          Layer.mergeAll(
            DesktopShutdown.layer,
            NodeServices.layer,
            Logger.layer([
              Logger.make(({ message }) => {
                if (String(message).includes("could not be persisted"))
                  events.push("error-reported");
              }),
            ]),
          ),
        ),
      );
    },
  );
}