nexus-agentd 0.2.6 → 0.3.0

package/dist/server/validation.js

@@ -0,0 +1,221 @@
+/** HTTP input errors are kept separate from route and domain operations. */
+export class RequestError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = 'RequestError';
+    }
+}
+export function assertJsonContentType(request) {
+    const contentType = stringHeader(request.headers['content-type'])
+        .split(';', 1)[0]
+        .trim()
+        .toLowerCase();
+    if (contentType !== 'application/json') {
+        throw new RequestError(415, 'Request requires application/json');
+    }
+}
+export async function assertEmptyJsonBody(request, maxBytes) {
+    if (Number(request.headers['content-length'] || 0) <= 0)
+        return;
+    assertJsonContentType(request);
+    const body = await readJsonBody(request, maxBytes);
+    assertOnlyKeys(body, []);
+}
+export async function readJsonBody(request, maxBytes) {
+    const declared = Number(request.headers['content-length']);
+    if (Number.isFinite(declared) && declared > maxBytes) {
+        throw new RequestError(413, 'Request body is too large');
+    }
+    const chunks = [];
+    let total = 0;
+    for await (const value of request) {
+        const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+        total += chunk.length;
+        if (total > maxBytes)
+            throw new RequestError(413, 'Request body is too large');
+        chunks.push(chunk);
+    }
+    const raw = Buffer.concat(chunks).toString('utf8');
+    if (!raw.trim())
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new Error('body must be an object');
+        }
+        return parsed;
+    }
+    catch (error) {
+        throw new RequestError(400, `Invalid JSON body: ${errorMessage(error)}`);
+    }
+}
+export async function readBytesBody(request, maxBytes) {
+    const declared = Number(request.headers['content-length']);
+    if (Number.isFinite(declared) && declared > maxBytes) {
+        throw new RequestError(413, 'Request body is too large');
+    }
+    const chunks = [];
+    let total = 0;
+    for await (const value of request) {
+        const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+        total += chunk.length;
+        if (total > maxBytes)
+            throw new RequestError(413, 'Request body is too large');
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+}
+export function assertOnlyKeys(body, allowed) {
+    const accepted = new Set(allowed);
+    const unknown = Object.keys(body).filter((key) => !accepted.has(key));
+    if (unknown.length) {
+        throw new RequestError(400, `Unsupported request fields: ${unknown.join(', ')}`);
+    }
+}
+export function requiredString(value, name) {
+    const text = typeof value === 'string' ? value.trim() : '';
+    if (!text)
+        throw new RequestError(400, `${name} is required`);
+    return text;
+}
+export function requiredRawString(value, name) {
+    if (typeof value !== 'string' || !value)
+        throw new RequestError(400, `${name} is required`);
+    return value;
+}
+export function requiredMessage(value) {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new RequestError(400, 'message is required');
+    }
+    return value;
+}
+export function requiredInteger(value, name) {
+    if (typeof value !== 'number' || !Number.isInteger(value)) {
+        throw new RequestError(400, `${name} must be an integer`);
+    }
+    return value;
+}
+export function optionalAttachmentIds(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.length > 16) {
+        throw new RequestError(400, 'attachments must be an array with at most 16 ids');
+    }
+    return value.map((item) => requiredString(item, 'attachments'));
+}
+export function normalizePublishPaths(body) {
+    const bodyPaths = body.paths;
+    if (bodyPaths !== undefined) {
+        if (!Array.isArray(bodyPaths) || bodyPaths.length === 0) {
+            throw new RequestError(400, 'paths must be a non-empty array of strings');
+        }
+        if (bodyPaths.length > 32) {
+            throw new RequestError(400, 'paths accepts at most 32 entries');
+        }
+        return bodyPaths.map((item) => requiredString(item, 'paths'));
+    }
+    return [requiredString(body.path, 'path')];
+}
+export function normalizedMediaType(value) {
+    const mediaType = stringHeader(value).split(';', 1)[0].trim().toLowerCase();
+    return mediaType || undefined;
+}
+export function decodeHeader(value) {
+    const raw = stringHeader(value);
+    if (!raw)
+        return '';
+    try {
+        return decodeURIComponent(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+export function cleanQuery(value) {
+    const text = String(value || '').trim();
+    return text || undefined;
+}
+export function boundedLimit(value) {
+    if (!value)
+        return undefined;
+    const number = Number(value);
+    if (!Number.isInteger(number) || number < 1 || number > 200) {
+        throw new RequestError(400, 'limit must be an integer between 1 and 200');
+    }
+    return number;
+}
+export function optionalRunState(value) {
+    if (!value)
+        return undefined;
+    const states = new Set([
+        'created',
+        'running',
+        'input_required',
+        'permission_required',
+        'completed',
+        'failed',
+        'canceled'
+    ]);
+    if (!states.has(value))
+        throw new RequestError(400, 'Invalid run state');
+    return value;
+}
+export function optionalRawString(value, name) {
+    if (value === undefined || value === null || value === '')
+        return undefined;
+    if (typeof value !== 'string')
+        throw new RequestError(400, `${name} must be a string`);
+    return value;
+}
+export function optionalString(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== 'string')
+        throw new RequestError(400, 'Expected a string');
+    return value.trim() || undefined;
+}
+export function optionalPendingAction(value) {
+    if (value === undefined || value === null || value === '')
+        return undefined;
+    if (value === 'accept' || value === 'decline' || value === 'cancel') {
+        return value;
+    }
+    throw new RequestError(400, 'action must be accept, decline, or cancel');
+}
+export function optionalBoolean(value, name) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'boolean')
+        throw new RequestError(400, `${name} must be boolean`);
+    return value;
+}
+export function optionalNumber(value, name) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'number' || !Number.isInteger(value)) {
+        throw new RequestError(400, `${name} must be an integer`);
+    }
+    return value;
+}
+export function requiredStringArray(value, name, allowEmpty = false) {
+    if (!Array.isArray(value))
+        throw new RequestError(400, `${name} must be an array of strings`);
+    const result = value.map((item) => {
+        if (typeof item !== 'string' || !item.trim()) {
+            throw new RequestError(400, `${name} must contain non-empty strings`);
+        }
+        return item.trim();
+    });
+    if (!allowEmpty && !result.length) {
+        throw new RequestError(400, `${name} must contain at least one value`);
+    }
+    return result;
+}
+function stringHeader(value) {
+    return Array.isArray(value) ? value[0] || '' : value || '';
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/server.d.ts

@@ -2,4 +2,7 @@ import http from 'node:http';
 import { type AgentdControlPlane } from './control-plane.js';
 import { SessionManager } from './session.js';
 import type { AgentdConfig } from './types.js';
+export { QuotaExceededError, QuotaManager, quotaLimitsFromConfig } from './server/quota.js';
+export { DiagnosticRunner, DiagnosticConcurrencyError } from './server/diagnostics.js';
+export { GatewayMetrics } from './server/metrics.js';
 export declare function createAgentdServer(config: AgentdConfig, sessions: SessionManager, controlPlane?: AgentdControlPlane): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;