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.

9.8 KB
Raw Blame
import * as NodeFS from "node:fs";
import * as NodeOS from "node:os";
import * as NodePath from "node:path";

import * as NodeServices from "@effect/platform-node/NodeServices";
import { describe, expect, it } from "@effect/vitest";
import { afterEach, vi } from "vite-plus/test";
import * as Effect from "effect/Effect";
import * as Logger from "effect/Logger";
import { FetchHttpClient } from "effect/unstable/http";

import {
  collectDevStatus,
  describeStatusClients,
  formatDevStatus,
  probeStatusOrigin,
  resolveDevStatusHome,
  statusOrigin,
} from "./dev-status.ts";

const directories: string[] = [];

function fixture(linked = true) {
  const root = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-dev-status-"));
  directories.push(root);

  if (linked) {
    NodeFS.writeFileSync(NodePath.join(root, ".git"), "gitdir: /repo/.git/worktrees/status\n");
  } else {
    NodeFS.mkdirSync(NodePath.join(root, ".git"));
  }

  return root;
}

function writeRuntime(root: string, extra = {}) {
  const dir = NodePath.join(root, ".akeru", "userdata");
  NodeFS.mkdirSync(dir, { recursive: true });
  const file = NodePath.join(dir, "server-runtime.json");
  NodeFS.writeFileSync(
    file,
    JSON.stringify({
      version: 1,
      pid: 123,
      port: 15432,
      origin: "http://127.0.0.1:15432",
      devUrl: "http://localhost:6543",
      startedAt: "2026-09-04T00:00:00.000Z",
      ...extra,
    }),
  );

  return file;
}

afterEach(() => {
  for (const dir of directories.splice(0)) {
    NodeFS.rmSync(dir, { recursive: true, force: true });
  }
});

describe("dev status home", () => {
  it.effect("uses the linked worktree ahead of ambient homes", () =>
    Effect.gen(function* () {
      const root = fixture();
      const cwd = NodePath.join(root, "scripts");
      NodeFS.mkdirSync(cwd);

      const status = yield* resolveDevStatusHome({
        cwd,
        userHome: "/users/test",
        env: { T3CODE_HOME: "/live", AKERU_HOME: "/other-live" },
      });

      expect(status).toEqual({
        worktree: root,
        home: NodePath.join(root, ".akeru"),
        dataDir: NodePath.join(root, ".akeru/userdata"),
      });
      expect(NodeFS.existsSync(status.home)).toBe(false);
    }).pipe(Effect.provide(NodeServices.layer)),
  );

  it.effect("uses dev for the implicit main checkout home", () =>
    Effect.gen(function* () {
      const root = fixture(false);

      const status = yield* resolveDevStatusHome({
        cwd: root,
        userHome: "/users/test",
        env: { AKERU_HOME: "/ignored-by-dev-runner" },
      });

      expect(status.dataDir).toBe("/users/test/.akeru/dev");
    }).pipe(Effect.provide(NodeServices.layer)),
  );

  it.effect("uses userdata for explicit and ambient homes", () =>
    Effect.gen(function* () {
      const root = fixture(false);

      const resolve = (homeDir?: string) =>
        resolveDevStatusHome({
          cwd: root,
          homeDir,
          userHome: "/users/test",
          env: { T3CODE_HOME: "/configured" },
        });

      expect((yield* resolve()).dataDir).toBe("/configured/userdata");
      expect((yield* resolve("local")).dataDir).toBe(NodePath.join(root, "local/userdata"));
      expect((yield* resolve("~/sandbox")).dataDir).toBe("/users/test/sandbox/userdata");
      const linked = fixture();

      const explicit = yield* resolveDevStatusHome({
        cwd: linked,
        homeDir: "/explicit",
        userHome: "/users/test",
        env: {},
      });

      expect(explicit.dataDir).toBe("/explicit/userdata");

      const blank = yield* resolveDevStatusHome({
        cwd: linked,
        homeDir: "  ",
        userHome: "/users/test",
        env: {},
      });

      expect(blank.dataDir).toBe(NodePath.join(linked, ".akeru/userdata"));
    }).pipe(Effect.provide(NodeServices.layer)),
  );
});

describe("dev status discovery", () => {
  it.effect("reports missing runtime without writes or guessed ports", () =>
    Effect.gen(function* () {
      const root = fixture();
      const probe = vi.fn(() => Effect.succeed("unexpected"));
      const status = yield* collectDevStatus({ cwd: root, env: {}, probe });
      expect(status.server.origin).toBeUndefined();
      expect(status.missing).toContain("usable server-runtime.json");
      expect(probe).not.toHaveBeenCalled();
      expect(NodeFS.readdirSync(root)).toEqual([".git"]);
    }).pipe(Effect.provide(NodeServices.layer)),
  );

  it.effect("reports stale runtime and leaves the file unchanged", () =>
    Effect.gen(function* () {
      const root = fixture();
      const file = writeRuntime(root);
      const before = NodeFS.readFileSync(file, "utf8");
      const probe = vi.fn(() => Effect.succeed("unexpected"));

      const status = yield* collectDevStatus({
        cwd: root,
        env: {},
        isProcessAlive: () => false,
        probe,
      });

      expect(status.descriptor).toContain("stale");
      expect(status.server.origin).toBe("http://127.0.0.1:15432");
      expect(status.server.readiness).toContain("unavailable");
      expect(probe).not.toHaveBeenCalled();
      expect(NodeFS.readFileSync(file, "utf8")).toBe(before);
    }).pipe(Effect.provide(NodeServices.layer)),
  );

  it.effect("redacts credentials and uses recorded origins", () =>
    Effect.gen(function* () {
      const root = fixture();
      writeRuntime(root, {
        origin: "http://user:[email protected]:15432/private?token=secret#secret",
        devUrl: "http://user:password@localhost:6543/pair?token=secret#secret",
        token: "secret",
      });
      const probe = vi.fn((_origin: string) => Effect.succeed("responding"));

      const status = yield* collectDevStatus({
        cwd: root,
        env: { OPENAI_API_KEY: "secret", T3CODE_DESKTOP_REMOTE_DEBUGGING_PORT: "secret" },
        isProcessAlive: () => true,
        probe,
      });

      expect(probe.mock.calls).toEqual([["http://127.0.0.1:15432"], ["http://localhost:6543"]]);
      const output = formatDevStatus(status);

      for (const value of ["password", "secret", "/private", "?token", "OPENAI_API_KEY"]) {
        expect(output).not.toContain(value);
      }

      expect(status.desktop).toContain("running unknown");
      expect(status.mobile).toContain("installed/running unknown");
    }).pipe(Effect.provide(NodeServices.layer)),
  );

  it.effect("does not log malformed runtime contents", () =>
    Effect.gen(function* () {
      const root = fixture();
      const file = writeRuntime(root);
      NodeFS.writeFileSync(file, '{"token":"never-print-this",');
      const log = vi.fn();

      const status = yield* collectDevStatus({ cwd: root, env: {} }).pipe(
        Effect.provideService(Logger.CurrentLoggers, new Set([Logger.make(log)])),
      );

      expect(formatDevStatus(status)).not.toContain("never-print-this");
      expect(log).not.toHaveBeenCalled();
      expect(NodeFS.readFileSync(file, "utf8")).toContain("never-print-this");
    }).pipe(Effect.provide(NodeServices.layer)),
  );
});

describe("dev status HTTP checks and client configuration", () => {
  it.effect("never fetches non-loopback or non-HTTP URLs", () =>
    Effect.gen(function* () {
      const fetch = vi.fn();

      const probe = (origin: string) =>
        probeStatusOrigin(origin).pipe(Effect.provideService(FetchHttpClient.Fetch, fetch));

      expect(yield* probe("https://example.com:443/pair?token=secret")).toContain("not checked");
      expect(yield* probe("file:///tmp/secret")).toContain("invalid");
      expect(statusOrigin("not-a-url-secret")).toBeUndefined();
      expect(fetch).not.toHaveBeenCalled();
    }),
  );

  it.effect("uses credential-free HEAD requests without redirects", () =>
    Effect.gen(function* () {
      const fetch = vi.fn(
        async () =>
          new Response(null, {
            status: 302,
            headers: { location: "https://example.com" },
          }),
      );

      const result = yield* probeStatusOrigin(
        "http://user:secret@localhost:6543/pair?token=secret",
      ).pipe(Effect.provideService(FetchHttpClient.Fetch, fetch));

      expect(result).toContain("readiness unverified");
      expect(fetch).toHaveBeenCalledWith(
        new URL("http://127.0.0.1:6543"),
        expect.objectContaining({
          method: "HEAD",
          redirect: "manual",
          credentials: "omit",
        }),
      );
    }),
  );

  it.effect("reports failed checks without exposing errors", () =>
    Effect.gen(function* () {
      const fetch = vi.fn(async () => {
        throw new Error("secret");
      });

      const result = yield* probeStatusOrigin("http://127.0.0.1:6543").pipe(
        Effect.provideService(FetchHttpClient.Fetch, fetch),
      );

      expect(result).toBe("unavailable (loopback HTTP check failed)");
    }),
  );

  it.effect("checks IPv6 when localhost is not listening on IPv4", () =>
    Effect.gen(function* () {
      const fetch = vi
        .fn()
        .mockRejectedValueOnce(new Error("IPv4 unavailable"))
        .mockResolvedValueOnce(new Response(null, { status: 200 }));

      const result = yield* probeStatusOrigin("http://localhost:6543").pipe(
        Effect.provideService(FetchHttpClient.Fetch, fetch),
      );

      expect(result).toContain("HTTP 200");
      expect(fetch.mock.calls.map(([url]) => String(url))).toEqual([
        "http://127.0.0.1:6543/",
        "http://[::1]:6543/",
      ]);
    }),
  );

  it("reports debug configuration and points to the mobile identity source", () => {
    const status = describeStatusClients({
      T3CODE_DESKTOP_REMOTE_DEBUGGING_PORT: "9222",
      APP_VARIANT: "development",
      T3CODE_IOS_PERSONAL_TEAM: "1",
      T3CODE_IOS_PERSONAL_TEAM_BUNDLE_ID: "dev.example.personal",
    });

    expect(status.desktop).toBe("debug port 9222 configured; running unknown");
    expect(status.mobile).toContain("app-identity.mjs");
    expect(status.mobile).toContain("installed/running unknown");
    expect(status.mobile).not.toContain("dev.example.personal");
  });
});