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.

5.1 KB
Raw Blame
import * as NodeFSP from "node:fs/promises";
import * as NodeOS from "node:os";
import * as NodePath from "node:path";

import * as NodeServices from "@effect/platform-node/NodeServices";
import { afterEach, assert, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as FileSystem from "effect/FileSystem";
import { HostProcessPlatform } from "@akeru/shared/hostProcess";

import { writeFileStringAtomically } from "./atomicWrite.ts";

const NodeFS = NodeFSP;

const directories: string[] = [];

afterEach(async () => {
  await Promise.all(
    directories.splice(0).map((directory) => NodeFS.rm(directory, { recursive: true })),
  );
});

it.effect("syncs durable contents before publishing and the directory afterward", () =>
  Effect.gen(function* () {
    const directory = yield* Effect.promise(() =>
      NodeFS.mkdtemp(NodePath.join(NodeOS.tmpdir(), "akeru-atomic-write-")),
    );

    directories.push(directory);
    const filePath = NodePath.join(directory, "memory.md");
    const operations: string[] = [];
    const fs = yield* FileSystem.FileSystem;
    const platform = yield* HostProcessPlatform;

    const observedFs = {
      ...fs,
      open: (...args: Parameters<typeof fs.open>) =>
        fs.open(...args).pipe(
          Effect.map((file) => ({
            ...file,
            sync: Effect.sync(() => {
              operations.push(
                args[0] === directory ? "directory sync" : `file sync (${args[1]?.flag})`,
              );
            }).pipe(Effect.flatMap(() => file.sync)),
          })),
        ),
      rename: (...args: Parameters<typeof fs.rename>) =>
        Effect.sync(() => {
          operations.push("rename");
        }).pipe(Effect.flatMap(() => fs.rename(...args))),
    } satisfies FileSystem.FileSystem;

    yield* writeFileStringAtomically({
      filePath,
      contents: "saved",
      mode: 0o600,
      durable: true,
    }).pipe(Effect.provideService(FileSystem.FileSystem, observedFs));

    assert.deepEqual(
      operations,
      // Windows rejects a flush through a read-only handle, so the temporary file opens as r+.
      platform === "win32"
        ? ["file sync (r+)", "rename"]
        : ["file sync (r+)", "rename", "directory sync"],
    );
    assert.equal(yield* Effect.promise(() => NodeFS.readFile(filePath, "utf8")), "saved");

    if (platform !== "win32") {
      assert.equal((yield* Effect.promise(() => NodeFS.stat(filePath))).mode & 0o777, 0o600);
    }
  }).pipe(Effect.provide(NodeServices.layer)),
);

it.effect("keeps the previous file when syncing the replacement fails", () =>
  Effect.gen(function* () {
    const directory = yield* Effect.promise(() =>
      NodeFS.mkdtemp(NodePath.join(NodeOS.tmpdir(), "akeru-atomic-write-")),
    );

    directories.push(directory);
    const filePath = NodePath.join(directory, "memory.md");
    yield* Effect.promise(() => NodeFS.writeFile(filePath, "previous"));
    const fs = yield* FileSystem.FileSystem;

    const failingFs = {
      ...fs,
      open: (...args: Parameters<typeof fs.open>) =>
        fs
          .open(...args)
          .pipe(Effect.map((file) => ({ ...file, sync: Effect.die(new Error("sync failed")) }))),
    } satisfies FileSystem.FileSystem;

    const result = yield* Effect.exit(
      writeFileStringAtomically({ filePath, contents: "replacement", durable: true }).pipe(
        Effect.provideService(FileSystem.FileSystem, failingFs),
      ),
    );

    assert.isTrue(Exit.isFailure(result));
    assert.equal(yield* Effect.promise(() => NodeFS.readFile(filePath, "utf8")), "previous");
  }).pipe(Effect.provide(NodeServices.layer)),
);

it.effect("checks beforeReplace after syncing and keeps the previous file when it fails", () =>
  Effect.gen(function* () {
    const directory = yield* Effect.promise(() =>
      NodeFS.mkdtemp(NodePath.join(NodeOS.tmpdir(), "akeru-atomic-write-")),
    );

    directories.push(directory);
    const filePath = NodePath.join(directory, "memory.md");
    yield* Effect.promise(() => NodeFS.writeFile(filePath, "previous"));
    const operations: string[] = [];
    const fs = yield* FileSystem.FileSystem;

    const observedFs = {
      ...fs,
      open: (...args: Parameters<typeof fs.open>) =>
        fs.open(...args).pipe(
          Effect.map((file) => ({
            ...file,
            sync: Effect.sync(() => {
              operations.push("sync");
            }).pipe(Effect.flatMap(() => file.sync)),
          })),
        ),
    } satisfies FileSystem.FileSystem;

    const result = yield* Effect.exit(
      writeFileStringAtomically({
        filePath,
        contents: "replacement",
        durable: true,
        beforeReplace: Effect.suspend(() => {
          operations.push("beforeReplace");

          return Effect.fail("lock lost");
        }),
      }).pipe(Effect.provideService(FileSystem.FileSystem, observedFs)),
    );

    assert.isTrue(Exit.isFailure(result));
    assert.deepEqual(operations, ["sync", "beforeReplace"]);
    assert.equal(yield* Effect.promise(() => NodeFS.readFile(filePath, "utf8")), "previous");
  }).pipe(Effect.provide(NodeServices.layer)),
);