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.
import * as NodePath from "node:path";
import * as NodeURL from "node:url";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { describe, expect, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Path from "effect/Path";
import * as Schema from "effect/Schema";
import { GrokSettings } from "@akeru/contracts";
import {
buildGrokModelsFromSessionModelState,
buildInitialGrokProviderSnapshot,
checkGrokProviderStatus,
parseGrokModelsCliOutput,
} from "./GrokProvider.ts";
const decodeGrokSettings = Schema.decodeSync(GrokSettings);
const __dirname = NodePath.dirname(NodeURL.fileURLToPath(import.meta.url));
const LOGGED_IN_MODELS_OUTPUT = [
"You are logged in with grok.com.",
"",
"Default model: grok-4.6",
"",
"Available models:",
" * grok-4.6 (default)",
" - grok-4.5",
"",
].join("\n");
const LOGGED_OUT_MODELS_OUTPUT = LOGGED_IN_MODELS_OUTPUT.replace(
"You are logged in with grok.com.",
"You are not authenticated.",
);
describe("parseGrokModelsCliOutput", () => {
it("reads login state and model slugs, marking the default", () => {
const parsed = parseGrokModelsCliOutput(LOGGED_IN_MODELS_OUTPUT);
expect(parsed.authenticated).toBe(true);
expect(parsed.models.map((model) => [model.slug, model.isDefault ?? false])).toEqual([
["grok-4.6", true],
["grok-4.5", false],
]);
});
it("detects a logged-out CLI even though it exits 0", () => {
expect(parseGrokModelsCliOutput(LOGGED_OUT_MODELS_OUTPUT).authenticated).toBe(false);
});
it("reads the plain one-model-per-line output from current CLIs", () => {
const parsed = parseGrokModelsCliOutput("grok-4.6\ncodex-1/gpt-5.6-sol\n");
expect(parsed.authenticated).toBeNull();
expect(parsed.models.map((model) => model.slug)).toEqual(["grok-4.6", "codex-1/gpt-5.6-sol"]);
});
it("returns unknown auth for unrecognized output", () => {
expect(parseGrokModelsCliOutput("grok 9.9.9\n").authenticated).toBeNull();
});
});
describe("buildGrokModelsFromSessionModelState", () => {
it("marks the agent's current model as default", () => {
const models = buildGrokModelsFromSessionModelState({
currentModelId: "grok-4.6",
availableModels: [
{ modelId: "grok-4.6", name: "Grok 4.6" },
{ modelId: "grok-4.5", name: "Grok 4.5" },
],
});
expect(models.map((model) => [model.slug, model.isDefault ?? false])).toEqual([
["grok-4.6", true],
["grok-4.5", false],
]);
});
});
describe("buildInitialGrokProviderSnapshot", () => {
it.effect("returns a disabled snapshot when settings.enabled is false", () =>
Effect.gen(function* () {
const snapshot = yield* buildInitialGrokProviderSnapshot(
decodeGrokSettings({ enabled: false }),
);
expect(snapshot.enabled).toBe(false);
expect(snapshot.status).toBe("disabled");
expect(snapshot.installed).toBe(false);
expect(snapshot.message).toContain("disabled");
}),
);
it.effect("returns a disabled snapshot by default — Grok is opt-in", () =>
Effect.gen(function* () {
const snapshot = yield* buildInitialGrokProviderSnapshot(decodeGrokSettings({}));
expect(snapshot.enabled).toBe(false);
expect(snapshot.status).toBe("disabled");
}),
);
it.effect("returns a pending snapshot when enabled", () =>
Effect.gen(function* () {
const snapshot = yield* buildInitialGrokProviderSnapshot(
decodeGrokSettings({ enabled: true }),
);
expect(snapshot.enabled).toBe(true);
expect(snapshot.installed).toBe(true);
expect(snapshot.status).toBe("warning");
expect(snapshot.version).toBeNull();
expect(snapshot.message).toContain("Checking Grok");
expect(snapshot.requiresNewThreadForModelChange).toBeUndefined();
}),
);
});
it.layer(NodeServices.layer)("checkGrokProviderStatus", (it) => {
it.effect("reports the binary as missing when the binary path does not resolve", () =>
Effect.gen(function* () {
const snapshot = yield* checkGrokProviderStatus(
decodeGrokSettings({
enabled: true,
binaryPath: "/definitely/not/installed/grok-binary",
}),
);
expect(snapshot.enabled).toBe(true);
expect(snapshot.installed).toBe(false);
expect(snapshot.status).toBe("error");
expect(snapshot.message).toMatch(/not installed|not on PATH|Failed to execute/);
}),
);
it.effect("reports an installed CLI as unhealthy when --version exits non-zero", () =>
Effect.gen(function* () {
const secretStderr = "broken grok install: secret-token-value";
const snapshot = yield* Effect.scoped(
Effect.gen(function* () {
const fs = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const dir = yield* fs.makeTempDirectoryScoped({ prefix: "t3code-grok-version-" });
const grokPath = path.join(dir, "grok");
yield* fs.writeFileString(
grokPath,
["#!/bin/sh", `printf "%s\\n" "${secretStderr}" >&2`, "exit 2", ""].join("\n"),
);
yield* fs.chmod(grokPath, 0o755);
return yield* checkGrokProviderStatus(
decodeGrokSettings({ enabled: true, binaryPath: grokPath }),
);
}),
);
expect(snapshot.enabled).toBe(true);
expect(snapshot.installed).toBe(true);
expect(snapshot.status).toBe("error");
expect(snapshot.message).toBe("Grok CLI is installed but failed to run.");
expect(snapshot.message).not.toContain(secretStderr);
}),
);
// Single-quotes a path for /bin/sh. Temp dirs and execPath never contain quotes.
const shellQuote = (value: string) => `'${value.replaceAll("'", `'\\''`)}'`;
// A shell stand-in for the Grok CLI: `--version` and `models` print canned text,
// and `agent stdio` execs the mock ACP agent so `initialize` returns model metadata.
const writeFakeGrokCli = (input: { readonly modelsOutput: string; readonly acp: boolean }) =>
Effect.gen(function* () {
const fs = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const dir = yield* fs.makeTempDirectoryScoped({ prefix: "t3code-grok-probe-" });
const modelsPath = path.join(dir, "models.txt");
yield* fs.writeFileString(modelsPath, input.modelsOutput);
const grokPath = path.join(dir, "grok");
const mockAgentPath = path.resolve(__dirname, "../../../scripts/acp-mock-agent.ts");
yield* fs.writeFileString(
grokPath,
[
"#!/bin/sh",
'case "$1" in',
' --version) printf "grok 1.0.13\\n"; exit 0;;',
` models) cat ${shellQuote(modelsPath)}; exit 0;;`,
input.acp
? ` agent) exec ${shellQuote(process.execPath)} ${shellQuote(mockAgentPath)};;`
: " agent) exit 3;;",
"esac",
"exit 1",
"",
].join("\n"),
);
yield* fs.chmod(grokPath, 0o755);
return grokPath;
});
it.effect("reports ready with ACP-discovered models when logged in", () =>
Effect.gen(function* () {
const snapshot = yield* Effect.scoped(
Effect.gen(function* () {
const grokPath = yield* writeFakeGrokCli({
modelsOutput: LOGGED_IN_MODELS_OUTPUT,
acp: true,
});
return yield* checkGrokProviderStatus(
decodeGrokSettings({ enabled: true, binaryPath: grokPath }),
{ ...process.env, XAI_API_KEY: "" },
);
}),
);
expect(snapshot.status).toBe("ready");
expect(snapshot.version).toBe("1.0.13");
expect(snapshot.auth).toEqual({
status: "authenticated",
type: "cached_token",
label: "Grok account",
});
expect(snapshot.models.map((model) => model.slug)).toEqual(["grok-4.6", "grok-mock-alt"]);
expect(snapshot.models[0]?.isDefault).toBe(true);
}),
);
it.effect("reports unauthenticated from `grok models` without starting a session", () =>
Effect.gen(function* () {
const snapshot = yield* Effect.scoped(
Effect.gen(function* () {
const grokPath = yield* writeFakeGrokCli({
modelsOutput: LOGGED_OUT_MODELS_OUTPUT,
acp: true,
});
return yield* checkGrokProviderStatus(
decodeGrokSettings({ enabled: true, binaryPath: grokPath }),
{ ...process.env, XAI_API_KEY: "" },
);
}),
);
expect(snapshot.status).toBe("error");
expect(snapshot.auth.status).toBe("unauthenticated");
expect(snapshot.message).toContain("grok login");
expect(snapshot.models.map((model) => model.slug)).toEqual(["grok-4.6", "grok-mock-alt"]);
}),
);
it.effect("warns while using the CLI model list when ACP initialize fails", () =>
Effect.gen(function* () {
const snapshot = yield* Effect.scoped(
Effect.gen(function* () {
const grokPath = yield* writeFakeGrokCli({
modelsOutput: LOGGED_IN_MODELS_OUTPUT,
acp: false,
});
return yield* checkGrokProviderStatus(
decodeGrokSettings({ enabled: true, binaryPath: grokPath }),
{ ...process.env, XAI_API_KEY: "" },
);
}),
);
expect(snapshot.status).toBe("warning");
expect(snapshot.installed).toBe(true);
expect(snapshot.auth.status).toBe("authenticated");
expect(snapshot.models.map((model) => [model.slug, model.isDefault ?? false])).toEqual([
["grok-4.6", true],
["grok-4.5", false],
]);
expect(snapshot.message).toContain("ACP initialize failed");
}),
);
it.effect("treats XAI_API_KEY as authenticated regardless of CLI login state", () =>
Effect.gen(function* () {
const snapshot = yield* Effect.scoped(
Effect.gen(function* () {
const grokPath = yield* writeFakeGrokCli({
modelsOutput: LOGGED_OUT_MODELS_OUTPUT,
acp: false,
});
return yield* checkGrokProviderStatus(
decodeGrokSettings({ enabled: true, binaryPath: grokPath }),
{ ...process.env, XAI_API_KEY: "xai-test-key" },
);
}),
);
expect(snapshot.auth).toEqual({
status: "authenticated",
type: "api_key",
label: "xAI API key",
});
expect(snapshot.status).toBe("warning");
}),
);
});
describe.runIf(process.env.T3_GROK_ACP_PROBE === "1")("checkGrokProviderStatus live CLI", () => {
it.effect("reports ready from initialize without requiring a new thread for model changes", () =>
Effect.gen(function* () {
const snapshot = yield* checkGrokProviderStatus(
decodeGrokSettings({
enabled: true,
binaryPath: process.env.T3_GROK_BINARY || "grok",
}),
);
expect(snapshot.status).toBe("ready");
expect(["authenticated", "unknown"]).toContain(snapshot.auth.status);
expect(snapshot.requiresNewThreadForModelChange).toBeUndefined();
expect(snapshot.models.length).toBeGreaterThan(0);
expect(snapshot.models.some((model) => model.slug === "grok-build")).toBe(false);
}).pipe(Effect.provide(NodeServices.layer)),
);
});