Skip to content

Garry's Opinionated OpenClaw/Hermes Agent Brain

TypeScript
4.0 KB
Raw Blame
import { authorizeAsOwner, pgliteOAuthTransaction, TEST_PKCE_VERIFIER, TEST_PKCE_CHALLENGE } from './helpers/oauth.ts';
// #4532 — exchangeRefreshToken failures must be InvalidGrantError, not bare
// Error.
//
// The MCP SDK's token handler maps OAuthError subclasses to their RFC 6749
// wire shape (HTTP 400 + {"error":"invalid_grant"}) and any non-OAuthError to
// a 500 Internal Server Error. Pre-fix, a refresh with a rotated or expired
// token (a routine client condition — RFC 6749 §5.2 invalid_grant) threw bare
// Error and surfaced as a 500, so well-behaved MCP clients treated it as a
// server outage instead of re-running the authorization flow.

import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
import { PGlite } from '@electric-sql/pglite';
import { vector } from '@electric-sql/pglite/vector';
import { pg_trgm } from '@electric-sql/pglite/contrib/pg_trgm';
import { GBrainOAuthProvider } from '../src/core/oauth-provider.ts';
import { hashToken } from '../src/core/utils.ts';
import { PGLITE_SCHEMA_SQL } from '../src/core/pglite-schema.ts';
import { InvalidGrantError, ServerError, OAuthError } from '@modelcontextprotocol/sdk/server/auth/errors.js';

let db: PGlite;
let sql: (strings: TemplateStringsArray, ...values: unknown[]) => Promise<any>;
let provider: GBrainOAuthProvider;

beforeAll(async () => {
  db = new PGlite({ extensions: { vector, pg_trgm } });
  await db.exec(PGLITE_SCHEMA_SQL);
  sql = async (strings: TemplateStringsArray, ...values: unknown[]) => {
    const query = strings.reduce((acc, str, i) => acc + str + (i < values.length ? `$${i + 1}` : ''), '');
    const result = await db.query(query, values as any[]);
    return result.rows;
  };
  provider = new GBrainOAuthProvider({ transaction: pgliteOAuthTransaction(db), sql, tokenTtl: 60, refreshTtl: 300 });
}, 120_000);

afterAll(async () => {
  if (db) await db.close();
}, 15_000);

async function mintTokens() {
  const { clientId } = await provider.registerClientManual(
    'invalid-grant-test', ['authorization_code'], 'read write',
    ['http://localhost:3000/callback'],
  );
  const client = (await provider.clientsStore.getClient(clientId))!;
  let redirectUrl = '';
  const mockRes = { redirect: (url: string) => { redirectUrl = url; } } as any;
  await authorizeAsOwner(provider, client, {
    codeChallenge: TEST_PKCE_CHALLENGE,
    redirectUri: 'http://localhost:3000/callback',
    scopes: ['read', 'write'],
  }, mockRes);
  const code = new URL(redirectUrl).searchParams.get('code')!;
  const tokens = await provider.exchangeAuthorizationCode(client, code, TEST_PKCE_VERIFIER, client.redirect_uris![0]);
  return { client, tokens };
}

describe('exchangeRefreshToken error typing (#4532)', () => {
  test('unknown/rotated refresh token throws InvalidGrantError (400 invalid_grant on the wire)', async () => {
    const { client } = await mintTokens();
    let caught: unknown;
    try {
      await provider.exchangeRefreshToken(client, 'gbr_definitely-not-a-real-token');
    } catch (e) {
      caught = e;
    }
    expect(caught).toBeInstanceOf(InvalidGrantError);
    // The SDK token handler's mapping: OAuthError-but-not-ServerError → 400.
    expect(caught).toBeInstanceOf(OAuthError);
    expect(caught).not.toBeInstanceOf(ServerError);
    expect((caught as InvalidGrantError).toResponseObject().error).toBe('invalid_grant');
  });

  test('expired refresh token throws InvalidGrantError', async () => {
    const { client, tokens } = await mintTokens();
    // Age the refresh row past expiry (fail-closed NULL also counts, but the
    // routine path is a real timestamp in the past).
    await db.query(
      `UPDATE oauth_tokens SET expires_at = 1 WHERE token_type = 'refresh' AND client_id = $1`,
      [client.client_id],
    );
    let caught: unknown;
    try {
      await provider.exchangeRefreshToken(client, tokens.refresh_token!);
    } catch (e) {
      caught = e;
    }
    expect(caught).toBeInstanceOf(InvalidGrantError);
    expect((caught as InvalidGrantError).toResponseObject().error).toBe('invalid_grant');
  });
});