feat(xai): add xAI Grok provider with OAuth + API key auth + image

Adapted from PR #1286 (mugnimaestra/feat/xai-grok-provider) to match
existing app architecture. Includes:

- OAuth 2.0 with PKCE on loopback port 56121 (Grok Build)
- API key auth path (console.x.ai)
- Token refresh wiring (open-sse + sse tokenRefresh)
- Dashboard OAuth modal with fixed-port flow + manual code fallback
- Provider registry entries (OAuth + API key)
- xAI image generation via OpenAI-compatible adapter
  (grok-2-image-1212 model, no size/quality/style params)

Excludes (intentionally, to match app patterns):
- Custom xAI Responses executor (DefaultExecutor handles /chat/completions)
- xAI-specific translators (app uses OpenAI as intermediate format)
- Image edits (not supported by current imageGenerationCore)
- Video endpoints (app has no video subsystem yet)
- CLI xai-login command

Refs decolua#1286

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
Muhammad Mugni Hadi
2026-05-21 11:33:18 +07:00
committed by decolua
co-authored by Cursor
parent 0654d7bb35
commit d976f4cc87
21 changed files with 1058 additions and 72 deletions
+125
View File
@@ -0,0 +1,125 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
describe("xai/oauth service", () => {
beforeEach(() => {
vi.resetModules();
vi.restoreAllMocks();
vi.stubGlobal("fetch", vi.fn());
});
it("validates discovered endpoints are https x.ai URLs", async () => {
const { validateOAuthEndpoint } = await import("../../src/lib/oauth/services/xai.js");
expect(validateOAuthEndpoint("https://auth.x.ai/oauth2/authorize", "authorization_endpoint")).toBe(
"https://auth.x.ai/oauth2/authorize"
);
expect(() => validateOAuthEndpoint("http://auth.x.ai/oauth2/authorize", "authorization_endpoint")).toThrow(
/must use https/
);
expect(() => validateOAuthEndpoint("https://example.com/oauth2/authorize", "authorization_endpoint")).toThrow(
/is not on x\.ai/
);
});
it("discovers endpoints without custom user-agent headers", async () => {
fetch.mockResolvedValueOnce({
ok: true,
json: async () => ({
authorization_endpoint: "https://auth.x.ai/oauth2/authorize",
token_endpoint: "https://auth.x.ai/oauth2/token",
}),
});
const { discoverEndpoints } = await import("../../src/lib/oauth/services/xai.js");
await expect(discoverEndpoints()).resolves.toEqual({
authorizeUrl: "https://auth.x.ai/oauth2/authorize",
tokenUrl: "https://auth.x.ai/oauth2/token",
});
expect(fetch).toHaveBeenCalledWith(
"https://auth.x.ai/.well-known/openid-configuration",
expect.objectContaining({ headers: { Accept: "application/json" } })
);
});
it("builds authorize URLs with CLIProxyAPI query extras", async () => {
const { XaiService } = await import("../../src/lib/oauth/services/xai.js");
const authUrl = new XaiService().buildXaiAuthUrl(
"http://127.0.0.1:56121/callback",
"state-1",
"challenge-1",
"https://auth.x.ai/oauth2/authorize"
);
const parsed = new URL(authUrl);
expect(parsed.origin + parsed.pathname).toBe("https://auth.x.ai/oauth2/authorize");
expect(parsed.searchParams.get("response_type")).toBe("code");
expect(parsed.searchParams.get("client_id")).toBe("b1a00492-073a-47ea-816f-4c329264a828");
expect(parsed.searchParams.get("redirect_uri")).toBe("http://127.0.0.1:56121/callback");
expect(parsed.searchParams.get("code_challenge")).toBe("challenge-1");
expect(parsed.searchParams.get("code_challenge_method")).toBe("S256");
expect(parsed.searchParams.get("state")).toBe("state-1");
expect(parsed.searchParams.get("nonce")).toMatch(/^[a-f0-9]{32}$/);
expect(parsed.searchParams.get("plan")).toBe("generic");
expect(parsed.searchParams.get("referrer")).toBe("cli-proxy-api");
});
it("generates dashboard auth data with CLIProxyAPI PKCE size and discovered endpoints", async () => {
fetch.mockResolvedValueOnce({
ok: true,
json: async () => ({
authorization_endpoint: "https://auth.x.ai/oauth2/authorize-from-discovery",
token_endpoint: "https://auth.x.ai/oauth2/token-from-discovery",
}),
});
const { generateAuthData } = await import("../../src/lib/oauth/providers.js");
const data = await generateAuthData("xai", "http://127.0.0.1:56121/callback");
const parsed = new URL(data.authUrl);
expect(data.codeVerifier).toHaveLength(128);
expect(parsed.origin + parsed.pathname).toBe("https://auth.x.ai/oauth2/authorize-from-discovery");
expect(parsed.searchParams.get("redirect_uri")).toBe("http://127.0.0.1:56121/callback");
expect(parsed.searchParams.get("code_challenge_method")).toBe("S256");
expect(parsed.searchParams.get("plan")).toBe("generic");
expect(parsed.searchParams.get("referrer")).toBe("cli-proxy-api");
});
it("exchanges dashboard codes against the discovered xAI token endpoint", async () => {
const fetchMock = fetch;
fetchMock
.mockResolvedValueOnce({
ok: true,
json: async () => ({
authorization_endpoint: "https://auth.x.ai/oauth2/authorize",
token_endpoint: "https://auth.x.ai/oauth2/token-from-discovery",
}),
})
.mockResolvedValueOnce({
ok: true,
json: async () => ({
access_token: "access-token",
refresh_token: "refresh-token",
expires_in: 3600,
}),
});
const { exchangeTokens } = await import("../../src/lib/oauth/providers.js");
const tokens = await exchangeTokens(
"xai",
"auth-code",
"http://127.0.0.1:56121/callback",
"verifier-1",
"state-1"
);
expect(fetchMock.mock.calls[1][0]).toBe("https://auth.x.ai/oauth2/token-from-discovery");
expect(fetchMock.mock.calls[1][1].body.get("grant_type")).toBe("authorization_code");
expect(fetchMock.mock.calls[1][1].body.get("code")).toBe("auth-code");
expect(fetchMock.mock.calls[1][1].body.get("code_verifier")).toBe("verifier-1");
expect(tokens).toMatchObject({
accessToken: "access-token",
refreshToken: "refresh-token",
expiresIn: 3600,
});
});
});
+63
View File
@@ -0,0 +1,63 @@
import { describe, it, expect, vi } from "vitest";
// We can't easily import the open-sse switch logic without real PROVIDERS config,
// so verify the wrapper function shape directly via dynamic import.
describe("xai/token-refresh wrapper", () => {
it("refreshXaiToken module loads without throwing", async () => {
// Just verify the file imports cleanly. The actual wrapper is internal.
const mod = await import("../../open-sse/services/tokenRefresh.js");
expect(typeof mod.refreshTokenByProvider).toBe("function");
expect(typeof mod.formatProviderCredentials).toBe("function");
});
it("formatProviderCredentials returns Bearer-shape for xai", async () => {
const mod = await import("../../open-sse/services/tokenRefresh.js");
const out = mod.formatProviderCredentials(
"xai",
{ apiKey: "k", accessToken: "t", refreshToken: "r" },
null
);
expect(out).toEqual({ apiKey: "k", accessToken: "t" });
});
it("refreshTokenByProvider returns null when refreshToken missing", async () => {
const mod = await import("../../open-sse/services/tokenRefresh.js");
const out = await mod.refreshTokenByProvider("xai", { refreshToken: "" }, null);
expect(out).toBeNull();
});
it("refreshTokenByProvider returns expiresIn for refreshed xai tokens", async () => {
vi.resetModules();
vi.doMock("../../src/lib/oauth/services/xai.js", () => ({
XaiService: class {
async refreshAccessToken(refreshToken) {
return {
access_token: "new-access",
refresh_token: `${refreshToken}-rotated`,
expires_in: 900,
id_token: "id-token",
};
}
},
}));
const mod = await import("../../open-sse/services/tokenRefresh.js");
const out = await mod.refreshTokenByProvider(
"xai",
{ refreshToken: "old-refresh" },
null
);
expect(out).toEqual({
accessToken: "new-access",
refreshToken: "old-refresh-rotated",
expiresIn: 900,
idToken: "id-token",
});
expect(out).not.toHaveProperty("expiresAt");
vi.doUnmock("../../src/lib/oauth/services/xai.js");
vi.resetModules();
});
});