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.

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

import { describe, expect, it } from "vite-plus/test";

import { BOOT_SERVICE_UNIT_FILE } from "../cloud/bootService.ts";
import { runRemoteDoctor, writeRemoteSupportBundle } from "./diagnostics.ts";

describe("Akeru Remote diagnostics", () => {
  it("repairs a fresh container without an update token", async () => {
    const baseDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-container-repair-"));
    NodeFS.mkdirSync(NodePath.join(baseDir, "userdata"), { recursive: true });
    const prior = process.env.AKERU_REMOTE_CONTAINER;
    process.env.AKERU_REMOTE_CONTAINER = "1";

    try {
      await expect(
        runRemoteDoctor({ baseDir, repair: true, platform: "linux" }),
      ).resolves.toBeDefined();
    } finally {
      if (prior === undefined) delete process.env.AKERU_REMOTE_CONTAINER;
      else process.env.AKERU_REMOTE_CONTAINER = prior;
      NodeFS.rmSync(baseDir, { recursive: true, force: true });
    }
  });

  it("reports a healthy Compose container without systemd or launcher state", async () => {
    const baseDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-container-doctor-"));
    const binDir = NodePath.join(baseDir, "bin");
    NodeFS.mkdirSync(NodePath.join(baseDir, "userdata"), { recursive: true });
    NodeFS.mkdirSync(binDir);
    NodeFS.writeFileSync(NodePath.join(binDir, "curl"), "#!/bin/sh\nexit 0\n", { mode: 0o755 });
    const priorContainer = process.env.AKERU_REMOTE_CONTAINER;
    const priorPath = process.env.PATH;
    process.env.AKERU_REMOTE_CONTAINER = "1";
    process.env.PATH = `${binDir}:${priorPath ?? ""}`;

    try {
      const report = await runRemoteDoctor({ baseDir, repair: false, platform: "linux" });
      expect(report.checks.find((check) => check.id === "service")?.status).toBe("pass");
      expect(report.checks.find((check) => check.id === "image-lifecycle")?.status).toBe("pass");
      expect(report.checks.some((check) => check.id === "boot-persistence")).toBe(false);
      expect(report.checks.some((check) => check.id === "update-credential")).toBe(false);
      expect(report.checks.some((check) => check.id === "update-state")).toBe(false);
      expect(report.overall).not.toBe("fail");
    } finally {
      if (priorContainer === undefined) delete process.env.AKERU_REMOTE_CONTAINER;
      else process.env.AKERU_REMOTE_CONTAINER = priorContainer;
      process.env.PATH = priorPath;
      NodeFS.rmSync(baseDir, { recursive: true, force: true });
    }
  });

  it("probes a Windows server over HTTP instead of systemd", async () => {
    const baseDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-win32-doctor-"));
    const binDir = NodePath.join(baseDir, "bin");
    NodeFS.mkdirSync(NodePath.join(baseDir, "userdata"), { recursive: true });
    NodeFS.mkdirSync(binDir);
    NodeFS.writeFileSync(
      NodePath.join(baseDir, "userdata", "server-runtime.json"),
      JSON.stringify({ port: 4555 }),
    );
    const probed = NodePath.join(baseDir, "probed");
    NodeFS.writeFileSync(NodePath.join(binDir, "curl"), `#!/bin/sh\necho "$@" > "${probed}"\n`, {
      mode: 0o755,
    });
    NodeFS.writeFileSync(NodePath.join(binDir, "systemctl"), "#!/bin/sh\nexit 1\n", {
      mode: 0o755,
    });
    const priorContainer = process.env.AKERU_REMOTE_CONTAINER;
    const priorPath = process.env.PATH;
    const priorPort = process.env.T3CODE_PORT;
    delete process.env.AKERU_REMOTE_CONTAINER;
    delete process.env.T3CODE_PORT;
    process.env.PATH = `${binDir}:${priorPath ?? ""}`;

    try {
      const report = await runRemoteDoctor({ baseDir, repair: false, platform: "win32" });
      expect(report.checks.find((check) => check.id === "service")).toMatchObject({
        status: "pass",
        message: "Akeru server answers its HTTP health check.",
      });
      expect(NodeFS.readFileSync(probed, "utf8")).toContain(
        "http://127.0.0.1:4555/.well-known/t3/environment",
      );
    } finally {
      if (priorContainer !== undefined) process.env.AKERU_REMOTE_CONTAINER = priorContainer;

      if (priorPort !== undefined) process.env.T3CODE_PORT = priorPort;
      process.env.PATH = priorPath;
      NodeFS.rmSync(baseDir, { recursive: true, force: true });
    }
  });

  it("reports storage health and repairs private binding permissions", async () => {
    const baseDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-doctor-"));
    const stateDir = NodePath.join(baseDir, "userdata");
    NodeFS.mkdirSync(NodePath.join(baseDir, "runtime"), { recursive: true });
    NodeFS.mkdirSync(stateDir, { recursive: true });
    const db = new NodeSqlite.DatabaseSync(NodePath.join(stateDir, "state.sqlite"));
    db.exec("CREATE TABLE health(value TEXT)");
    db.close();
    const bindingPath = NodePath.join(stateDir, "remote-directory.json");
    NodeFS.writeFileSync(
      bindingPath,
      JSON.stringify({
        endpointKind: "custom-https",
        credential: "super-secret",
        accountId: "acct-1",
        linkGeneration: "generation-1",
      }),
      { mode: 0o644 },
    );
    NodeFS.writeFileSync(
      NodePath.join(baseDir, "runtime", "service-state.json"),
      JSON.stringify({ activeVersion: "1.2.3", update: { status: "idle" } }),
    );

    const report = await runRemoteDoctor({
      baseDir,
      repair: true,
      platform: "linux",
      now: new Date("2026-09-13T12:00:00.000Z"),
    });

    expect(report.checks.find((check) => check.id === "database")?.status).toBe("pass");
    expect(report.checks.find((check) => check.id === "binding-permissions")?.status).toBe("pass");
    expect(report.repairsApplied).toContain("binding-permissions");
    expect(NodeFS.statSync(bindingPath).mode & 0o077).toBe(0);

    const bundlePath = NodePath.join(baseDir, "support.json");
    NodeFS.writeFileSync(bundlePath, "old", { mode: 0o644 });
    NodeFS.chmodSync(bundlePath, 0o644);
    writeRemoteSupportBundle(bundlePath, report, { platform: "linux", arch: "x64" });
    expect(NodeFS.statSync(bundlePath).mode & 0o077).toBe(0);
    expect(NodeFS.readFileSync(bundlePath, "utf8")).not.toContain("super-secret");
    NodeFS.rmSync(baseDir, { recursive: true, force: true });
  });

  it("formats free disk space for people", async () => {
    const baseDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-disk-format-"));
    const stateDir = NodePath.join(baseDir, "userdata");
    NodeFS.mkdirSync(stateDir, { recursive: true });
    const report = await runRemoteDoctor({ baseDir, repair: false });
    const disk = report.checks.find((check) => check.id === "disk");
    expect(disk?.message).toMatch(/\d+(\.\d+)? (B|KB|MB|GB|TB) available\./);
    expect(disk?.message).not.toContain("MiB");
    NodeFS.rmSync(baseDir, { recursive: true, force: true });
  });

  it("reports a missing optional account link as pass", async () => {
    const baseDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-binding-optional-"));
    const stateDir = NodePath.join(baseDir, "userdata");
    NodeFS.mkdirSync(stateDir, { recursive: true });
    const report = await runRemoteDoctor({ baseDir, repair: false });
    const binding = report.checks.find((check) => check.id === "account-binding");
    expect(binding).toMatchObject({ status: "pass" });
    expect(binding?.message).toContain("not configured");
    NodeFS.rmSync(baseDir, { recursive: true, force: true });
  });

  it("reports a fresh home as not created yet instead of raw file errors", async () => {
    const baseDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-fresh-home-"));
    const prior = process.env.AKERU_REMOTE_CONTAINER;
    delete process.env.AKERU_REMOTE_CONTAINER;

    try {
      const report = await runRemoteDoctor({ baseDir, repair: false });
      const disk = report.checks.find((check) => check.id === "disk");
      const updateState = report.checks.find((check) => check.id === "update-state");
      expect(disk).toMatchObject({ status: "warning" });
      expect(disk?.message).toContain("not been created yet");
      expect(updateState).toMatchObject({ status: "warning" });
      expect(updateState?.message).toContain("not been created yet");
      expect(JSON.stringify(report.checks)).not.toContain("ENOENT");
      const providers = report.checks.find((check) => check.id === "providers");
      expect(providers?.message).toContain("Kimi For Coding");
      expect(providers?.details?.inServer).toBe("kimi,opencodeGo");
    } finally {
      if (prior !== undefined) process.env.AKERU_REMOTE_CONTAINER = prior;
      NodeFS.rmSync(baseDir, { recursive: true, force: true });
    }
  });

  it("repairs only the checks it was asked to repair", async () => {
    const baseDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-selective-repair-"));
    const stateDir = NodePath.join(baseDir, "userdata");
    NodeFS.mkdirSync(stateDir, { recursive: true });
    const bindingPath = NodePath.join(stateDir, "remote-directory.json");
    NodeFS.writeFileSync(bindingPath, JSON.stringify({ endpointKind: "custom-https" }), {
      mode: 0o644,
    });
    const prior = process.env.AKERU_REMOTE_CONTAINER;
    process.env.AKERU_REMOTE_CONTAINER = "1";

    try {
      const untouched = await runRemoteDoctor({ baseDir, repair: new Set(["logs"]) });
      expect(untouched.repairsApplied).not.toContain("binding-permissions");
      expect(NodeFS.statSync(bindingPath).mode & 0o077).not.toBe(0);

      const repaired = await runRemoteDoctor({
        baseDir,
        repair: new Set(["binding-permissions"]),
      });

      expect(repaired.repairsApplied).toEqual(["binding-permissions"]);
      expect(NodeFS.statSync(bindingPath).mode & 0o077).toBe(0);
    } finally {
      if (prior === undefined) delete process.env.AKERU_REMOTE_CONTAINER;
      else process.env.AKERU_REMOTE_CONTAINER = prior;
      NodeFS.rmSync(baseDir, { recursive: true, force: true });
    }
  });

  it("names the systemd unit that `akeru service install` writes in every remote script", () => {
    // The installer health check and `akeru remote logs` query systemd by name. A stale name makes
    // them silently miss the running service.
    const scripts = ["install-remote.sh", "akeru-remote-admin.sh"].map((name) =>
      NodeFS.readFileSync(new URL(`../../../../scripts/${name}`, import.meta.url), "utf8"),
    );

    for (const script of scripts) {
      expect(script).toContain(BOOT_SERVICE_UNIT_FILE);
      expect(script).not.toContain("akeru.service");
    }
  });
});