Fully autonomous AI Agents system capable of performing complex penetration testing tasks
Go ai-agentsai-security-toolanthropicautonomous-agentsgolanggptgraphqlmulti-agent-systemoffensive-securityopen-sourceopenaipenetration-testingpenetration-testing-toolsreactsecurity-automationsecurity-testingsecurity-toolsself-hosted
import type { Client } from 'graphql-ws';
import { createClient } from 'graphql-ws';
import { afterEach, describe, expect, it, vi } from 'vitest';
import { WebSocket, WebSocketServer } from 'ws';
import type { Cassette } from './cassette.ts';
import { MockWorld } from './world.ts';
import { handleWsConnection } from './ws-graphql.ts';
/**
* Protocol-contract suite: a real graphql-ws client (configured like the app's
* in src/lib/apollo.ts — infinite retries, shouldRetry always) driven against
* a real ws server backed by the exact `handleWsConnection` the Playwright
* mock uses. Violations of these invariants otherwise only surface as
* reconnect storms inside flaky browser specs.
*/
interface Harness {
client: Client;
world: MockWorld;
}
const disposers: Array<() => Promise<void> | void> = [];
afterEach(async () => {
while (disposers.length) {
await disposers.pop()?.();
}
});
const start = async (cassette: Cassette, onConnected?: (wasRetry: boolean) => void): Promise<Harness> => {
const world = new MockWorld(cassette);
const server = new WebSocketServer({
handleProtocols: (protocols) => (protocols.has('graphql-transport-ws') ? 'graphql-transport-ws' : false),
port: 0,
});
server.on('connection', (socket) => {
const connection = handleWsConnection(world, {
close: ({ code = 1000, reason = '' } = {}) => socket.close(code, reason),
send: (data) => socket.send(data),
});
socket.on('message', (raw) => connection.onMessage(String(raw)));
socket.on('close', () => connection.onClose());
});
await new Promise<void>((resolve) => server.on('listening', resolve));
const address = server.address();
const port = typeof address === 'object' && address ? address.port : 0;
const client = createClient({
lazy: true,
on: { connected: (_socket, _payload, wasRetry) => onConnected?.(wasRetry) },
retryAttempts: Infinity,
retryWait: () => new Promise((resolve) => setTimeout(resolve, 10)),
shouldRetry: () => true,
url: `ws://127.0.0.1:${port}/api/v1/graphql`,
webSocketImpl: WebSocket,
});
disposers.push(async () => {
await Promise.resolve(client.dispose()).catch(() => undefined);
await new Promise<void>((resolve) => server.close(() => resolve()));
});
return { client, world };
};
const collect = (client: Client, operationName: string, variables?: Record<string, unknown>) => {
const received: unknown[] = [];
const errors: unknown[] = [];
let isComplete = false;
const unsubscribe = client.subscribe(
{ operationName, query: `subscription ${operationName} { stub }`, variables },
{
complete: () => {
isComplete = true;
},
error: (error) => errors.push(error),
next: (value) => received.push(value),
},
);
return { errors, isComplete: () => isComplete, received, unsubscribe };
};
describe('graphql-ws mock protocol contract', () => {
it('acks the handshake and delivers a matched subscription frame', async () => {
const { client } = await start({
subscriptions: { demo: [{ frames: [{ payload: { data: { demo: 1 } } }] }] },
});
const sink = collect(client, 'demo');
await vi.waitFor(() => expect(sink.received).toEqual([{ data: { demo: 1 } }]));
expect(sink.errors).toEqual([]);
});
it('answers an unmatched subscription with recorded silence — no error, no complete', async () => {
const { client, world } = await start({});
const sink = collect(client, 'unknownOp', { id: '9' });
await vi.waitFor(() => expect(world.unmatchedSubscriptions).toEqual(['subscription unknownOp {"id":"9"}']));
await new Promise((resolve) => setTimeout(resolve, 50));
expect(sink.received).toEqual([]);
expect(sink.errors).toEqual([]);
expect(sink.isComplete()).toBe(false);
});
it('completes the sink only for streams that opt into complete', async () => {
const { client } = await start({
subscriptions: {
finite: [{ complete: true, frames: [{ payload: { data: { finite: 1 } } }] }],
open: [{ frames: [{ payload: { data: { open: 1 } } }] }],
},
});
const finite = collect(client, 'finite');
const open = collect(client, 'open');
await vi.waitFor(() => expect(finite.isComplete()).toBe(true));
expect(finite.received).toEqual([{ data: { finite: 1 } }]);
// A stream without `complete` delivers its frames but must stay open — the real server
// never completes live subscriptions, so flipping the default to complete would fail here.
await vi.waitFor(() => expect(open.received).toEqual([{ data: { open: 1 } }]));
await new Promise((resolve) => setTimeout(resolve, 50));
expect(open.isComplete()).toBe(false);
});
it('recovers from a 1001 drop and never replays already-delivered frames', async () => {
const retries: boolean[] = [];
const { client, world } = await start(
{
queries: { raise: [{ data: {}, setFlag: 'later' }] },
subscriptions: {
stream: [
{
frames: [
{ payload: { data: { seq: 1 } } },
{ payload: { data: { seq: 2 } }, whenFlag: 'later' },
],
},
],
},
},
(wasRetry) => retries.push(wasRetry),
);
const sink = collect(client, 'stream');
await vi.waitFor(() => expect(sink.received).toEqual([{ data: { seq: 1 } }]));
world.dropSockets();
// graphql-ws resubscribes active sinks in a microtask AFTER the retry connect, so gating on
// the reconnect alone races the resubscribe: raising the flag before the sink re-registers
// delivers seq:2 to an empty subscriber set and the no-replay contract loses it. Gate on the
// server-side resubscription instead.
await vi.waitFor(() => expect(retries).toEqual([false, true]));
await vi.waitFor(() => expect(world.subscriberCount('sub:stream:{}')).toBe(1));
world.matchGraphQL('raise');
await vi.waitFor(() => expect(sink.received).toEqual([{ data: { seq: 1 } }, { data: { seq: 2 } }]));
expect(sink.errors).toEqual([]);
});
});