feat(runtime): add fail-closed Hermes management adapter and contract gates

This commit is contained in:
devops committed 2026-10-22 18:54:24 +00:00
1 parent c8a3f35b0a
commit 8c8ae66c7d
12 files changed
+1013

No files matched your search

@@ -0,0 +1,149 @@
import { HermesIntegrationService } from './hermes-integration.service';
import { HermesAdapter } from './hermes.adapter';
describe('backend-owned runtime authorization', () => {
const ctx = { subject: 'admin', profiles: ['seo'] };
const make = (allow = true, enabled = false) => {
const fetcher = jest
.fn()
.mockResolvedValue(
new Response(
JSON.stringify({ id: 'j', profile: 'seo', enabled: false }),
),
);
const authorize = jest.fn().mockResolvedValue(allow);
return {
fetcher,
authorize,
s: new HermesIntegrationService(
new HermesAdapter(
{
origin: 'http://canina-hermes:9119',
token: () => Promise.resolve('secret'),
},
fetcher,
),
{ authorize },
enabled,
),
};
};
it('denies missing principal, missing profile, denied policy before upstream IO', async () => {
const { s, fetcher } = make(false);
await expect(s.pauseCron(ctx, 'seo', 'j')).rejects.toMatchObject({
code: 'FORBIDDEN',
});
await expect(
s.pauseCron({ ...ctx, subject: '' }, 'seo', 'j'),
).rejects.toMatchObject({ code: 'FORBIDDEN' });
await expect(s.pauseCron(ctx, 'dev', 'j')).rejects.toMatchObject({
code: 'FORBIDDEN',
});
expect(fetcher).not.toHaveBeenCalled();
});
it('allows authorized pause but leaves resume disabled by default', async () => {
const { s, fetcher, authorize } = make();
await s.pauseCron(ctx, 'seo', 'j');
expect(authorize).toHaveBeenCalledWith(ctx, 'cron.pause', 'seo');
await expect(s.resumeCron(ctx, 'seo', 'j')).rejects.toMatchObject({
code: 'FORBIDDEN',
});
expect(fetcher).toHaveBeenCalledTimes(1);
});
it('fails closed on all execution and never forwards arbitrary events or RPC', async () => {
const { s, fetcher } = make();
expect(s.capabilities()).toMatchObject({
chat: false,
control: false,
eventDispatch: false,
cronResume: false,
});
await expect(s.chat(ctx, 'seo', 'hello')).rejects.toMatchObject({
code: 'UNSUPPORTED',
});
await expect(s.control(ctx, 'seo', 'interrupt')).rejects.toMatchObject({
code: 'UNSUPPORTED',
});
await expect(
s.dispatchEvent(ctx, 'seo', { type: 'order.created' }),
).rejects.toMatchObject({ code: 'FORBIDDEN' });
expect(fetcher).not.toHaveBeenCalled();
});
it('fails closed when authorization provider throws', async () => {
const a = new HermesAdapter({
origin: 'http://canina-hermes:9119',
token: () => Promise.resolve('secret'),
});
const s = new HermesIntegrationService(a, {
authorize: () => Promise.reject(new Error('private')),
});
await expect(s.health(ctx)).rejects.toMatchObject({ code: 'FORBIDDEN' });
});
});
it('checks every read capability and filters the global profile roster', async () => {
const fetcher = jest.fn().mockImplementation((input: URL) => {
const payloads: Record<string, unknown> = {
'/api/health': {
ok: true,
version: 'x',
commit: 'x',
auth_required: true,
},
'/api/status': {
version: 'x',
gateway_running: false,
gateway_state: null,
overall: 'degraded',
active_agents: 0,
},
'/api/profiles': {
profiles: [
{ name: 'seo', is_default: false, gateway_running: false },
{ name: 'dev', is_default: false, gateway_running: false },
],
},
'/api/model/info': {
model: 'm',
provider: 'p',
effective_context_length: 1,
},
'/api/model/options': { providers: [] },
'/api/analytics/usage': {
period_days: 30,
totals: {
total_input: 0,
total_output: 0,
total_sessions: 0,
total_estimated_cost: 0,
},
},
'/api/sessions': { sessions: [], total: 0 },
'/api/cron/jobs': [],
};
return Promise.resolve(
new Response(JSON.stringify(payloads[input.pathname])),
);
});
const authorize = jest.fn().mockResolvedValue(true);
const s = new HermesIntegrationService(
new HermesAdapter(
{
origin: 'http://canina-hermes:9119',
token: () => Promise.resolve('secret'),
},
fetcher,
),
{ authorize },
);
const p = { subject: 'verified', profiles: ['seo'] };
await s.health(p);
await s.status(p, 'seo');
expect(await s.profiles(p)).toHaveLength(1);
await s.modelInfo(p, 'seo');
await s.modelOptions(p, 'seo');
await s.usage(p, 'seo');
await s.sessions(p, 'seo');
await s.crons(p, 'seo');
expect(authorize).toHaveBeenCalledTimes(8);
expect(authorize.mock.calls.every((c) => c[1] === 'runtime.read')).toBe(true);
});
@@ -0,0 +1,126 @@
import { HermesAdapter, HermesError, Json } from './hermes.adapter';
/** Context MUST be constructed from verified backend identity, never request bodies. */
export interface RuntimePrincipal {
subject: string;
profiles: readonly string[];
}
export type RuntimePermission =
| 'runtime.read'
| 'cron.pause'
| 'cron.resume'
| 'chat'
| 'control'
| 'event.dispatch';
export interface RuntimeAuthorizer {
authorize(
principal: RuntimePrincipal,
permission: RuntimePermission,
profile?: string,
): Promise<boolean>;
}
/** No controller or socket is registered: only the backend gatekeeper can call this seam. */
export class HermesIntegrationService {
constructor(
private readonly adapter: HermesAdapter,
private readonly policy: RuntimeAuthorizer,
private readonly resumeEnabled = false,
) {}
capabilities() {
return {
inventory: true,
cronPause: true,
cronResume: this.resumeEnabled,
chat: false,
control: false,
eventDispatch: false,
} as const;
}
private async check(
principal: RuntimePrincipal,
permission: RuntimePermission,
profile?: string,
): Promise<void> {
if (
!principal?.subject ||
!Array.isArray(principal.profiles) ||
(profile && !principal.profiles.includes(profile))
)
throw new HermesError('FORBIDDEN');
try {
if (
(await this.policy.authorize(principal, permission, profile)) !== true
)
throw new HermesError('FORBIDDEN');
} catch {
throw new HermesError('FORBIDDEN');
}
}
async health(p: RuntimePrincipal) {
await this.check(p, 'runtime.read');
return this.adapter.health();
}
async status(p: RuntimePrincipal, profile: string) {
await this.check(p, 'runtime.read', profile);
return this.adapter.status(profile);
}
async profiles(p: RuntimePrincipal) {
await this.check(p, 'runtime.read');
return (await this.adapter.profiles()).filter(
(r) => typeof r.name === 'string' && p.profiles.includes(r.name),
);
}
async modelInfo(p: RuntimePrincipal, profile: string) {
await this.check(p, 'runtime.read', profile);
return this.adapter.modelInfo(profile);
}
async modelOptions(p: RuntimePrincipal, profile: string) {
await this.check(p, 'runtime.read', profile);
return this.adapter.modelOptions(profile);
}
async usage(p: RuntimePrincipal, profile: string, days = 30) {
await this.check(p, 'runtime.read', profile);
return this.adapter.usage(profile, days);
}
async sessions(p: RuntimePrincipal, profile: string, limit = 20, offset = 0) {
await this.check(p, 'runtime.read', profile);
return this.adapter.sessions(profile, limit, offset);
}
async crons(p: RuntimePrincipal, profile: string) {
await this.check(p, 'runtime.read', profile);
return this.adapter.crons(profile);
}
async pauseCron(p: RuntimePrincipal, profile: string, id: string) {
await this.check(p, 'cron.pause', profile);
return this.adapter.pauseCron(profile, id);
}
async resumeCron(p: RuntimePrincipal, profile: string, id: string) {
await this.check(p, 'cron.resume', profile);
if (!this.resumeEnabled) throw new HermesError('FORBIDDEN');
return this.adapter.resumeCron(profile, id);
}
async chat(
p: RuntimePrincipal,
profile: string,
_text: string,
): Promise<never> {
await this.check(p, 'chat', profile);
throw new HermesError('UNSUPPORTED');
}
async control(
p: RuntimePrincipal,
profile: string,
_command: 'interrupt',
): Promise<never> {
await this.check(p, 'control', profile);
throw new HermesError('UNSUPPORTED');
}
/** Disabled independently of policy: no unreviewed event may become an agent prompt. */
async dispatchEvent(
p: RuntimePrincipal,
profile: string,
_event: Json,
): Promise<never> {
await this.check(p, 'event.dispatch', profile);
throw new HermesError('FORBIDDEN');
}
}
@@ -0,0 +1,18 @@
import { Test } from '@nestjs/testing';
import { HermesManagementModule } from './hermes-management.module';
import { HermesIntegrationService } from './hermes-integration.service';
it('requires explicit registration and denies by default without publishing controllers', async () => {
const module = await Test.createTestingModule({
imports: [
HermesManagementModule.register({
origin: 'http://canina-hermes:9119',
token: () => Promise.resolve('secret'),
}),
],
}).compile();
const service = module.get(HermesIntegrationService);
await expect(
service.health({ subject: 'admin', profiles: [] }),
).rejects.toMatchObject({ code: 'FORBIDDEN' });
await module.close();
});
@@ -0,0 +1,27 @@
import { DynamicModule, Module } from '@nestjs/common';
import { HermesAdapter, HermesConfig } from './hermes.adapter';
import {
HermesIntegrationService,
RuntimeAuthorizer,
} from './hermes-integration.service';
@Module({})
export class HermesManagementModule {
static register(
config: HermesConfig,
policy: RuntimeAuthorizer = { authorize: () => Promise.resolve(false) },
): DynamicModule {
return {
module: HermesManagementModule,
providers: [
{ provide: HermesAdapter, useFactory: () => new HermesAdapter(config) },
{
provide: HermesIntegrationService,
useFactory: (adapter: HermesAdapter) =>
new HermesIntegrationService(adapter, policy, false),
inject: [HermesAdapter],
},
],
exports: [HermesIntegrationService],
};
}
}
@@ -0,0 +1,240 @@
import { HermesAdapter, HermesError } from './hermes.adapter';
const health = {
ok: true,
version: '0.13',
commit: 'abc',
auth_required: true,
};
describe('installed Hermes health contract', () => {
it('uses pinned internal origin, bearer only server side and strips extra fields', async () => {
const fetcher = jest
.fn()
.mockResolvedValue(
new Response(
JSON.stringify({ ...health, token: 'never', home: '/secret' }),
),
);
const adapter = new HermesAdapter(
{
origin: 'http://canina-hermes:9119',
token: () => Promise.resolve('private'),
},
fetcher,
);
expect(await adapter.health()).toEqual(health);
expect(fetcher.mock.calls[0][0].toString()).toBe(
'http://canina-hermes:9119/api/health',
);
expect(fetcher.mock.calls[0][1].headers.Authorization).toBe(
'Bearer private',
);
expect(fetcher.mock.calls[0][1].redirect).toBe('error');
});
it('fails closed for bad origin, auth errors, malformed contract and oversized bodies', async () => {
expect(
() =>
new HermesAdapter({
origin: 'https://evil.test',
token: () => Promise.resolve(''),
}),
).toThrow(HermesError);
for (const response of [
new Response('private', { status: 401 }),
new Response('{}'),
new Response('x'.repeat(262145)),
]) {
const a = new HermesAdapter(
{
origin: 'http://canina-hermes:9119',
token: () => Promise.resolve('secret'),
},
jest.fn().mockResolvedValue(response),
);
await expect(a.health()).rejects.toBeInstanceOf(HermesError);
}
});
});
describe('bounded profile-scoped REST inventory', () => {
const create = (payload: unknown) => {
const fetcher = jest
.fn()
.mockResolvedValue(new Response(JSON.stringify(payload)));
return {
a: new HermesAdapter(
{
origin: 'http://canina-hermes:9119',
token: () => Promise.resolve('secret'),
},
fetcher,
),
fetcher,
};
};
it('projects status, profiles, models and usage without raw paths, prompts or credentials', async () => {
expect(
await create({
version: 'x',
gateway_running: false,
gateway_state: null,
overall: 'degraded',
active_agents: 0,
}).a.status('seo'),
).toEqual({
version: 'x',
gateway_running: false,
gateway_state: null,
overall: 'degraded',
active_agents: 0,
});
expect(
await create({
profiles: [
{
name: 'seo',
is_default: false,
gateway_running: false,
path: '/private',
description: 'token=secret',
},
],
}).a.profiles(),
).toEqual([{ name: 'seo', is_default: false, gateway_running: false }]);
expect(
await create({
model: 'm',
provider: 'p',
effective_context_length: 0,
api_key: 'secret',
}).a.modelInfo('seo'),
).toEqual({ model: 'm', provider: 'p', effective_context_length: 0 });
expect(
await create({
providers: [
{ slug: 'p', name: 'Provider', models: ['m'], api_key: 'secret' },
],
current: { api_key: 'secret' },
}).a.modelOptions('seo'),
).toEqual([{ slug: 'p', name: 'Provider', models: ['m'] }]);
expect(
await create({
period_days: 7,
totals: {
total_input: 0,
total_output: 2,
total_sessions: 1,
total_estimated_cost: 0,
},
tools: { secret: 1 },
}).a.usage('seo', 7),
).toEqual({
period_days: 7,
totals: {
total_input: 0,
total_output: 2,
total_sessions: 1,
total_estimated_cost: 0,
},
});
});
it('uses scoped list contract and rejects unbounded queries or profile escape', async () => {
const { a, fetcher } = create({
sessions: [
{
id: 's',
profile: 'seo',
is_active: false,
source: 'cron',
title: 'secret',
},
],
total: 1,
storage: {},
});
expect(await a.sessions('seo', 20, 0)).toEqual({
sessions: [{ id: 's', profile: 'seo', is_active: false, source: 'cron' }],
total: 1,
});
expect(fetcher.mock.calls[0][0].pathname).toBe('/api/sessions');
expect(fetcher.mock.calls[0][0].searchParams.get('full')).toBe('false');
await expect(a.sessions('../escape', 20, 0)).rejects.toThrow();
await expect(a.sessions('seo', 101, 0)).rejects.toThrow();
await expect(a.usage('seo', 366)).rejects.toThrow();
await expect(
create({
sessions: [],
total: 0,
storage: { seo: 'corrupt' },
}).a.sessions('seo'),
).rejects.toThrow();
await expect(
create({
sessions: [
{ id: 's', profile: 'dev', source: 'cli', is_active: false },
],
total: 1,
}).a.sessions('seo'),
).rejects.toThrow();
});
it('lists scoped cron array; pause/resume use exact POST routes without triggers', async () => {
expect(
await create([
{ id: 'j', profile: 'seo', enabled: false, prompt: 'secret' },
]).a.crons('seo'),
).toEqual([{ id: 'j', profile: 'seo', enabled: false }]);
const { a, fetcher } = create({ id: 'j', profile: 'seo', enabled: false });
expect(await a.pauseCron('seo', 'j')).toEqual({
id: 'j',
profile: 'seo',
enabled: false,
});
expect(fetcher.mock.calls[0][0].pathname).toBe('/api/cron/jobs/j/pause');
expect(fetcher.mock.calls[0][1].method).toBe('POST');
const resume = create({ id: 'j', profile: 'seo', enabled: true });
await resume.a.resumeCron('seo', 'j');
expect(resume.fetcher.mock.calls[0][0].pathname).toBe(
'/api/cron/jobs/j/resume',
);
await expect(a.pauseCron('seo', '../trigger')).rejects.toThrow();
});
});
describe('resource budgets and safe errors', () => {
it('does not leak upstream errors or tokens and limits credential waits', async () => {
jest.useFakeTimers();
const a = new HermesAdapter({
origin: 'http://canina-hermes:9119',
token: () => new Promise(() => {}),
});
const result = expect(a.health()).rejects.toMatchObject({
code: 'UNAVAILABLE',
message: 'Hermes unavailable',
});
await jest.advanceTimersByTimeAsync(5001);
await result;
jest.useRealTimers();
});
it('caps concurrency before upstream IO', async () => {
const resolvers: ((r: Response) => void)[] = [];
const fetcher = jest.fn(
() =>
new Promise<Response>((r) => {
resolvers.push(r);
}),
);
const a = new HermesAdapter(
{
origin: 'http://canina-hermes:9119',
token: () => Promise.resolve('secret'),
},
fetcher,
);
const calls = Array.from({ length: 4 }, () => a.health());
const denied = expect(a.health()).rejects.toMatchObject({ code: 'LIMIT' });
await Promise.resolve();
await Promise.resolve();
resolvers.forEach((r) => r(new Response(JSON.stringify(health))));
await denied;
await Promise.all(calls);
});
});
@@ -0,0 +1,267 @@
export type Json =
| null
| boolean
| number
| string
| Json[]
| { [key: string]: Json };
export type Row = Record<string, Json>;
export type HermesErrorCode =
| 'CONFIGURATION'
| 'AUTH_REQUIRED'
| 'UNAVAILABLE'
| 'CONTRACT'
| 'LIMIT'
| 'FORBIDDEN'
| 'UNSUPPORTED';
export class HermesError extends Error {
constructor(readonly code: HermesErrorCode) {
super(`Hermes ${code.toLowerCase()}`);
}
}
export interface HermesConfig {
origin: string;
token: () => Promise<string>;
}
export interface Health {
ok: boolean;
version: string;
commit: string;
auth_required: boolean;
}
function object(value: unknown): Record<string, unknown> {
if (!value || typeof value !== 'object' || Array.isArray(value))
throw new HermesError('CONTRACT');
return value as Record<string, unknown>;
}
function fields(
value: unknown,
schema: Record<string, 'string' | 'boolean' | 'number'>,
): Row {
const source = object(value);
const result: Row = {};
for (const [key, type] of Object.entries(schema)) {
if (
typeof source[key] !== type ||
(type === 'number' && !Number.isFinite(source[key]))
)
throw new HermesError('CONTRACT');
result[key] = source[key] as Json;
}
return result;
}
export class HermesAdapter {
private readonly origin: string;
private inflight = 0;
constructor(
private readonly config: HermesConfig,
private readonly fetcher: typeof fetch = fetch,
) {
if (config.origin !== 'http://canina-hermes:9119')
throw new HermesError('CONFIGURATION');
this.origin = config.origin;
}
private async request(
path: string,
profile?: string,
method = 'GET',
params: Record<string, string> = {},
): Promise<unknown> {
if (
profile !== undefined &&
!/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(profile)
)
throw new HermesError('FORBIDDEN');
const url = new URL(path, this.origin);
if (profile) url.searchParams.set('profile', profile);
for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v);
if (this.inflight >= 4) throw new HermesError('LIMIT');
this.inflight++;
const controller = new AbortController();
const timer = setTimeout(() => controller.abort(), 5000);
try {
const token = await Promise.race([
this.config.token(),
new Promise<never>((_, reject) =>
controller.signal.addEventListener(
'abort',
() => reject(new HermesError('UNAVAILABLE')),
{ once: true },
),
),
]);
if (!token || /[\r\n]/.test(token))
throw new HermesError('AUTH_REQUIRED');
const response = await this.fetcher(url, {
method,
headers: {
Authorization: `Bearer ${token}`,
Accept: 'application/json',
},
signal: controller.signal,
redirect: 'error',
});
if ([401, 403].includes(response.status))
throw new HermesError('AUTH_REQUIRED');
if (response.status === 404) throw new HermesError('UNSUPPORTED');
if (!response.ok) throw new HermesError('UNAVAILABLE');
if (Number(response.headers.get('content-length')) > 262144)
throw new HermesError('LIMIT');
const reader = response.body?.getReader();
if (!reader) throw new HermesError('CONTRACT');
let bytes = 0;
const chunks: Uint8Array[] = [];
try {
for (;;) {
const { done, value } = await reader.read();
if (done) break;
bytes += value.byteLength;
if (bytes > 262144) throw new HermesError('LIMIT');
chunks.push(value);
}
} finally {
await reader.cancel().catch(() => undefined);
}
return JSON.parse(Buffer.concat(chunks).toString('utf8')) as unknown;
} catch (error) {
if (error instanceof HermesError) throw error;
throw new HermesError('UNAVAILABLE');
} finally {
clearTimeout(timer);
this.inflight--;
}
}
async health(): Promise<Health> {
return fields(await this.request('/api/health'), {
ok: 'boolean',
version: 'string',
commit: 'string',
auth_required: 'boolean',
}) as unknown as Health;
}
async status(profile: string): Promise<Row> {
const raw = object(await this.request('/api/status', profile));
const row = fields(raw, {
version: 'string',
gateway_running: 'boolean',
overall: 'string',
active_agents: 'number',
});
if (raw.gateway_state !== null && typeof raw.gateway_state !== 'string')
throw new HermesError('CONTRACT');
return { ...row, gateway_state: raw.gateway_state as Json };
}
async profiles(): Promise<Row[]> {
return list(object(await this.request('/api/profiles')).profiles).map((r) =>
fields(r, {
name: 'string',
is_default: 'boolean',
gateway_running: 'boolean',
}),
);
}
async modelInfo(profile: string): Promise<Row> {
return fields(await this.request('/api/model/info', profile), {
model: 'string',
provider: 'string',
effective_context_length: 'number',
});
}
async modelOptions(profile: string): Promise<Row[]> {
return list(
object(await this.request('/api/model/options', profile)).providers,
).map((r) => {
const row = fields(r, { slug: 'string', name: 'string' });
const models = list(object(r).models);
if (models.some((m) => typeof m !== 'string'))
throw new HermesError('CONTRACT');
return { ...row, models: models as string[] };
});
}
async usage(profile: string, days = 30): Promise<Row> {
bound(days, 1, 365);
const raw = object(
await this.request('/api/analytics/usage', profile, 'GET', {
days: String(days),
}),
);
return {
...fields(raw, { period_days: 'number' }),
totals: fields(raw.totals, {
total_input: 'number',
total_output: 'number',
total_sessions: 'number',
total_estimated_cost: 'number',
}),
};
}
async sessions(profile: string, limit = 20, offset = 0): Promise<Row> {
bound(limit, 1, 100);
bound(offset, 0, 10000);
const raw = object(
await this.request('/api/sessions', profile, 'GET', {
limit: String(limit),
offset: String(offset),
full: 'false',
order: 'recent',
}),
);
if (raw.storage && Object.keys(object(raw.storage)).length)
throw new HermesError('UNAVAILABLE');
const rows = list(raw.sessions).map((r) =>
scoped(r, profile, {
id: 'string',
profile: 'string',
source: 'string',
is_active: 'boolean',
}),
);
return { ...fields(raw, { total: 'number' }), sessions: rows };
}
async crons(profile: string): Promise<Row[]> {
return list(await this.request('/api/cron/jobs', profile)).map((r) =>
scoped(r, profile, {
id: 'string',
profile: 'string',
enabled: 'boolean',
}),
);
}
private async cron(
profile: string,
id: string,
action: 'pause' | 'resume',
): Promise<Row> {
if (!/^[a-zA-Z0-9_-]{1,128}$/.test(id)) throw new HermesError('FORBIDDEN');
return scoped(
await this.request(`/api/cron/jobs/${id}/${action}`, profile, 'POST'),
profile,
{ id: 'string', profile: 'string', enabled: 'boolean' },
);
}
pauseCron(profile: string, id: string): Promise<Row> {
return this.cron(profile, id, 'pause');
}
resumeCron(profile: string, id: string): Promise<Row> {
return this.cron(profile, id, 'resume');
}
}
function list(value: unknown): unknown[] {
if (!Array.isArray(value) || value.length > 1000)
throw new HermesError('CONTRACT');
return value;
}
function bound(value: number, min: number, max: number): void {
if (!Number.isInteger(value) || value < min || value > max)
throw new HermesError('LIMIT');
}
function scoped(
value: unknown,
profile: string,
schema: Record<string, 'string' | 'boolean' | 'number'>,
): Row {
const row = fields(value, schema);
if (row.profile !== profile) throw new HermesError('FORBIDDEN');
return row;
}
@@ -0,0 +1,50 @@
import { createServer } from 'node:http';
import type { AddressInfo } from 'node:net';
import { HermesAdapter } from './hermes.adapter';
it('exercises bounded HTTP transport against an isolated server', async () => {
const seen: string[] = [];
const server = createServer((req, res) => {
seen.push(`${req.method} ${req.url}`);
if (req.headers.authorization !== 'Bearer local-test') {
res.writeHead(401).end();
return;
}
res.setHeader('Content-Type', 'application/json');
res.end(
JSON.stringify({
ok: true,
version: 'test',
commit: 'test',
auth_required: true,
api_key: 'redacted',
}),
);
});
await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
try {
const port = (server.address() as AddressInfo).port;
const transport: typeof fetch = (input, init) =>
fetch(
`http://127.0.0.1:${port}${new URL(input instanceof URL ? input.href : typeof input === 'string' ? input : input.url).pathname}`,
init,
);
const adapter = new HermesAdapter(
{
origin: 'http://canina-hermes:9119',
token: () => Promise.resolve('local-test'),
},
transport,
);
expect(await adapter.health()).toEqual({
ok: true,
version: 'test',
commit: 'test',
auth_required: true,
});
expect(seen).toEqual(['GET /api/health']);
} finally {
await new Promise<void>((resolve, reject) =>
server.close((e) => (e ? reject(e) : resolve())),
);
}
});
@@ -0,0 +1,11 @@
{
"extends": "../../tsconfig.json",
"compilerOptions": {
"rootDir": ".",
"outDir": "../../../.hermes-contract-build",
"incremental": false,
"strict": true
},
"include": ["./*.ts"],
"exclude": []
}