@shieldaai/agent-map 0.1.0-alpha.2 → 1.0.0

package/dist/cli-entry.js

@@ -0,0 +1,66 @@
+import { realpathSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { MapQueryError } from './types.js';
+/** Optional `neo4j` configuration keys passed to the store as its per-read limits. */
+export const STORE_LIMITS = ['maxNodes', 'maxEdges', 'maxBytes'];
+export const PACKAGE_VERSION = createRequire(import.meta.url)('../package.json').version;
+/** npm's POSIX executable is a symlink. Node resolves it when loading the module. */
+export function isCliEntry(meta) {
+    if (typeof meta.main === 'boolean')
+        return meta.main;
+    const entry = process.argv[1];
+    if (!entry)
+        return false;
+    try {
+        // Older supported Node versions do not expose import.meta.main.
+        return pathToFileURL(realpathSync(entry)).href === meta.url;
+    }
+    catch {
+        // Imports from eval/stdin can supply an argv value that is not a file.
+        return false;
+    }
+}
+// One fixed line per cause. Nothing from the error itself is printed: its message can hold a
+// path, an argument or a configuration value.
+const STARTUP_HINTS = Object.freeze({
+    MAP_ARGUMENT_INVALID: 'an argument is unknown or incomplete, or --config is missing.',
+    MAP_CONFIG_NOT_FOUND: 'the configuration file, or a file it names, does not exist.',
+    MAP_CONFIG_UNREADABLE: 'the configuration file, or a file it names, cannot be opened; check its type, owner and permissions.',
+    MAP_CONFIG_INVALID: 'the configuration is not accepted; check that it is strict JSON with known field names and valid values, and that each file is a regular file owned by the service user and not writable by others.',
+    MAP_CREDENTIAL_REQUIRED: 'an environment variable the configuration names is unset or empty.',
+    MAP_SCOPE_INVALID: 'a credential or binding scope is not valid.',
+    MAP_LISTEN_FAILED: 'the configured address and port could not be opened; another process may be using the port.',
+    MAP_IDENTITY_INVALID: 'the identity provider metadata does not match the configuration (issuer, RS256, S256 PKCE, client authentication or endpoint origins).',
+    MAP_IDENTITY_UNAVAILABLE: 'the identity provider did not answer within the deadline.',
+    MAP_UNAVAILABLE: 'a required service or capability is unavailable.',
+    MAP_START_FAILED: 'unexpected failure during startup.',
+});
+/** The specific safe code for a startup failure, and whether the usage line helps. */
+export function startupFailure(error) {
+    const raw = error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
+    const syscall = error && typeof error === 'object' && 'syscall' in error ? String(error.syscall) : '';
+    let code = 'MAP_START_FAILED';
+    if (error instanceof MapQueryError) {
+        // A configuration file that is not strict JSON, or too large, is a configuration fault.
+        code = ['MAP_REQUEST_INVALID', 'MAP_REQUEST_TOO_LARGE'].includes(raw) ? 'MAP_CONFIG_INVALID' : raw;
+    }
+    else if (raw.startsWith('ERR_PARSE_ARGS'))
+        code = 'MAP_ARGUMENT_INVALID';
+    else if (syscall === 'listen' || raw === 'EADDRINUSE' || raw === 'EADDRNOTAVAIL')
+        code = 'MAP_LISTEN_FAILED';
+    else if (raw === 'ENOENT' || raw === 'ENOTDIR')
+        code = 'MAP_CONFIG_NOT_FOUND';
+    else if (['EACCES', 'EPERM', 'ELOOP', 'EISDIR', 'ENXIO', 'EMFILE', 'ENFILE'].includes(raw))
+        code = 'MAP_CONFIG_UNREADABLE';
+    if (!Object.hasOwn(STARTUP_HINTS, code))
+        code = 'MAP_START_FAILED';
+    return { code, hint: STARTUP_HINTS[code], usage: code === 'MAP_ARGUMENT_INVALID' };
+}
+/** Prints `MAP_START_FAILED <code>: <hint>` (and the usage for an argument error) and sets the exit code. */
+export function reportStartupFailure(error, usage) {
+    const failure = startupFailure(error);
+    const cause = failure.code === 'MAP_START_FAILED' ? '' : ` ${failure.code}`;
+    process.stderr.write(`MAP_START_FAILED${cause}: ${failure.hint}\n${failure.usage ? `Usage: ${usage}\n` : ''}`);
+    process.exitCode = 1;
+}

package/dist/cli.js

@@ -1,59 +1,43 @@
 #!/usr/bin/env node
-import { constants } from 'node:fs';
-import { open } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { parseArgs } from 'node:util';
-import { pathToFileURL } from 'node:url';
+import { PACKAGE_VERSION, STORE_LIMITS, isCliEntry, reportStartupFailure } from './cli-entry.js';
 import { createNeo4jMapStore } from './store.js';
 import { MapService } from './service.js';
 import { startMapServer } from './http.js';
 import { validateReadScope } from './types.js';
-import { fields, fail, integer, parseRequest } from './boundary.js';
+import { fail, integer } from './common.js';
+import { fields, parseRequest, readHostFile } from './boundary.js';
 function environmentName(value) {
     if (typeof value !== 'string' || !/^[A-Za-z_][A-Za-z0-9_]{0,127}$/.test(value))
         fail('MAP_CONFIG_INVALID');
     return value;
 }
-/** Keep the type check and bounded read on one nonblocking descriptor. */
-async function configBytes(path) {
-    if (typeof constants.O_NONBLOCK !== 'number')
-        fail('MAP_CONFIG_INVALID');
-    const maximum = 128 * 1024;
-    const file = await open(path, constants.O_RDONLY | constants.O_NONBLOCK);
-    try {
-        const info = await file.stat();
-        if (!info.isFile() || info.size > maximum)
-            fail('MAP_CONFIG_INVALID');
-        // The file may grow after stat; never use an unbounded readFile here.
-        const data = Buffer.alloc(maximum + 1);
-        let bytes = 0;
-        while (bytes < data.length) {
-            const read = await file.read(data, bytes, data.length - bytes, null);
-            if (!read.bytesRead)
-                break;
-            bytes += read.bytesRead;
-        }
-        if (bytes > maximum)
-            fail('MAP_CONFIG_INVALID');
-        return data.subarray(0, bytes);
-    }
-    finally {
-        await file.close();
-    }
-}
+/** The reference launcher's configuration: a regular file of this user or root, not writable by others. */
+const CONFIG_FILE = { noFollow: false, owner: 'service-or-root', singleLink: false, private: false };
+const USAGE = 'agent-guard-map --config HOST_CONFIG.json | --help | --version';
 /** Credential values stay in the environment and are never printed by this launcher. */
 export async function runMapCli(argv = process.argv.slice(2)) {
-    const { values } = parseArgs({ args: argv, options: { config: { type: 'string' }, help: { type: 'boolean' } }, strict: true });
+    const { values } = parseArgs({
+        args: argv,
+        options: { config: { type: 'string' }, help: { type: 'boolean' }, version: { type: 'boolean' } },
+        strict: true,
+    });
     if (values.help) {
-        process.stdout.write('agent-guard-map --config HOST_CONFIG.json\n');
+        process.stdout.write(`${USAGE}\n`);
+        return;
+    }
+    if (values.version) {
+        process.stdout.write(`${PACKAGE_VERSION}\n`);
         return;
     }
     if (!values.config)
-        fail('MAP_CONFIG_INVALID');
+        fail('MAP_ARGUMENT_INVALID');
     const path = resolve(values.config);
-    const config = fields(parseRequest(await configBytes(path), 128 * 1024), ['neo4j', 'credentials', 'port', 'viewerDirectory'], ['neo4j', 'credentials']);
-    const database = fields(config.neo4j, ['uri', 'username', 'passwordEnv', 'database'], ['uri', 'username', 'passwordEnv']);
-    if (typeof database.uri !== 'string' || typeof database.username !== 'string' ||
+    const config = fields(parseRequest(await readHostFile(path, 128 * 1024, CONFIG_FILE), 128 * 1024), ['neo4j', 'credentials', 'port', 'viewerDirectory'], ['neo4j', 'credentials']);
+    const database = fields(config.neo4j, ['uri', 'username', 'passwordEnv', 'database', ...STORE_LIMITS], ['uri', 'username', 'passwordEnv']);
+    if (typeof database.uri !== 'string' ||
+        typeof database.username !== 'string' ||
         (database.database !== undefined && typeof database.database !== 'string'))
         fail('MAP_CONFIG_INVALID');
     const password = process.env[environmentName(database.passwordEnv)];
@@ -70,15 +54,28 @@ export async function runMapCli(argv = process.argv.slice(2)) {
     });
     if (config.viewerDirectory !== undefined && typeof config.viewerDirectory !== 'string')
         fail('MAP_CONFIG_INVALID');
-    const store = createNeo4jMapStore({ uri: database.uri, username: database.username, password,
-        ...(database.database === undefined ? {} : { database: database.database }) });
+    const store = createNeo4jMapStore({
+        uri: database.uri,
+        username: database.username,
+        password,
+        ...(database.database === undefined ? {} : { database: database.database }),
+        // Optional read limits; the store checks their type and hard maximum.
+        ...Object.fromEntries(STORE_LIMITS.filter(key => database[key] !== undefined).map(key => [key, database[key]])),
+    });
     try {
-        const server = await startMapServer({ service: new MapService(store), credentials,
+        const server = await startMapServer({
+            service: new MapService(store),
+            credentials,
             port: integer(config.port, 8789, 0, 65535),
-            ...(config.viewerDirectory === undefined ? {} : { viewerDirectory: resolve(config.viewerDirectory) }) });
+            ...(config.viewerDirectory === undefined ? {} : { viewerDirectory: resolve(config.viewerDirectory) }),
+        });
         process.stdout.write(`${JSON.stringify({ url: server.url, mode: 'read-only' })}\n`);
         await new Promise(done => {
-            const stop = () => { process.off('SIGINT', stop); process.off('SIGTERM', stop); done(); };
+            const stop = () => {
+                process.off('SIGINT', stop);
+                process.off('SIGTERM', stop);
+                done();
+            };
             process.once('SIGINT', stop);
             process.once('SIGTERM', stop);
         });
@@ -88,6 +85,6 @@ export async function runMapCli(argv = process.argv.slice(2)) {
         await store.close();
     }
 }
-if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
-    void runMapCli().catch(() => { process.stderr.write('MAP_START_FAILED\n'); process.exitCode = 1; });
+if (isCliEntry(import.meta)) {
+    void runMapCli().catch(error => reportStartupFailure(error, USAGE));
 }

package/dist/common.d.ts

@@ -0,0 +1,34 @@
+import { type MapEdge, type MapIdentityScope, type MapNode } from './types.js';
+export declare function fail(code: string): never;
+/** A safe integer option within `[min, max]`, or `fallback` when it is not set. */
+export declare function integer(value: unknown, fallback: number, min: number, max: number): number;
+/** Unicode code-point order (the order Python sorts strings in), independent of host locale. */
+export declare function compareCodePoints(a: string, b: string): number;
+/**
+ * The bucket and object key of an S3 ARN, or null when it is not one. `key` is undefined for
+ * a bare bucket ARN and may be empty for one that ends in a slash.
+ */
+export declare function parseS3Arn(arn: unknown): {
+    readonly bucket: string;
+    readonly key: string | undefined;
+} | null;
+/** The bucket name of an S3 bucket or object ARN, or null. */
+export declare const s3BucketName: (arn: unknown) => string | null;
+export declare const LIST_SHORTENED = "bucket_list_shortened";
+/**
+ * An identity-scope record with its bucket list cut to `keep` entries. Only the list changes:
+ * the status came from the full comparison and stands.
+ */
+export declare function shortenScopeList(record: MapIdentityScope, keep: number): MapIdentityScope;
+/** Adjacency over one projection's nodes and edges, in projection order. */
+export interface GraphIndex {
+    readonly nodes: Map<string, MapNode>;
+    /** Positions of each node ID in the node list, so subgraphs keep projection order. */
+    readonly nodePositions: Map<string, number[]>;
+    /** Positions of each source's edges in the edge list. */
+    readonly edgesFrom: Map<string, number[]>;
+    readonly outgoing: Map<string, Map<MapEdge['kind'], string[]>>;
+    readonly incoming: Map<string, Map<MapEdge['kind'], string[]>>;
+}
+/** Builds the index in one pass; callers account for the work themselves. */
+export declare function buildGraphIndex(nodes: readonly MapNode[], edges: readonly MapEdge[]): GraphIndex;

package/dist/common.js

@@ -0,0 +1,94 @@
+import { MapQueryError } from './types.js';
+// Helpers shared by the service, the store and the HTTP boundaries. Nothing in this file touches
+// the network, the file system or a Node-only module. The service as a whole is not free of
+// them: `service/work.ts` and `service/policy.ts` import `node:buffer`, and the JSON helpers of
+// `@shieldaai/agent-guard/internal` import `node:buffer`, `node:crypto` and `node:util/types`.
+// A browser bundle of `@shieldaai/agent-map/service` must supply stand-ins for those three
+// (the viewer build does).
+export function fail(code) {
+    throw new MapQueryError(code);
+}
+/** A safe integer option within `[min, max]`, or `fallback` when it is not set. */
+export function integer(value, fallback, min, max) {
+    const result = value === undefined ? fallback : value;
+    if (typeof result !== 'number' || !Number.isSafeInteger(result) || result < min || result > max)
+        fail('MAP_CONFIG_INVALID');
+    return result;
+}
+/** Unicode code-point order (the order Python sorts strings in), independent of host locale. */
+export function compareCodePoints(a, b) {
+    let left = 0, right = 0;
+    while (left < a.length && right < b.length) {
+        const ac = a.codePointAt(left), bc = b.codePointAt(right);
+        if (ac !== bc)
+            return ac - bc;
+        left += ac > 0xffff ? 2 : 1;
+        right += bc > 0xffff ? 2 : 1;
+    }
+    return a.length - left - (b.length - right);
+}
+const S3_ARN = /^arn:aws:s3:::([a-z0-9][a-z0-9.-]{1,61}[a-z0-9])(?:\/(.*))?$/;
+/**
+ * The bucket and object key of an S3 ARN, or null when it is not one. `key` is undefined for
+ * a bare bucket ARN and may be empty for one that ends in a slash.
+ */
+export function parseS3Arn(arn) {
+    const match = S3_ARN.exec(typeof arn === 'string' ? arn : '');
+    return match ? { bucket: match[1], key: match[2] } : null;
+}
+/** The bucket name of an S3 bucket or object ARN, or null. */
+export const s3BucketName = (arn) => parseS3Arn(arn)?.bucket ?? null;
+export const LIST_SHORTENED = 'bucket_list_shortened';
+/**
+ * An identity-scope record with its bucket list cut to `keep` entries. Only the list changes:
+ * the status came from the full comparison and stands.
+ */
+export function shortenScopeList(record, keep) {
+    if (record.extraResources.length <= keep)
+        return record;
+    return {
+        ...record,
+        extraResources: record.extraResources.slice(0, keep),
+        truncated: true,
+        notes: record.notes?.includes(LIST_SHORTENED) ? record.notes : [...(record.notes ?? []), LIST_SHORTENED],
+    };
+}
+/** Builds the index in one pass; callers account for the work themselves. */
+export function buildGraphIndex(nodes, edges) {
+    const result = {
+        nodes: new Map(),
+        nodePositions: new Map(),
+        edgesFrom: new Map(),
+        outgoing: new Map(),
+        incoming: new Map(),
+    };
+    const push = (map, key, position) => {
+        const list = map.get(key);
+        if (list)
+            list.push(position);
+        else
+            map.set(key, [position]);
+    };
+    nodes.forEach((node, position) => {
+        result.nodes.set(node.id, node);
+        push(result.nodePositions, node.id, position);
+    });
+    const add = (map, from, kind, to) => {
+        let kinds = map.get(from);
+        if (!kinds) {
+            kinds = new Map();
+            map.set(from, kinds);
+        }
+        const items = kinds.get(kind);
+        if (items)
+            items.push(to);
+        else
+            kinds.set(kind, [to]);
+    };
+    edges.forEach((edge, position) => {
+        push(result.edgesFrom, edge.source, position);
+        add(result.outgoing, edge.source, edge.kind, edge.target);
+        add(result.incoming, edge.target, edge.kind, edge.source);
+    });
+    return result;
+}

package/dist/http.js

@@ -1,19 +1,31 @@
 import { createServer } from 'node:http';
 import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
-import { immutableJson } from '@shieldaai/agent-guard';
+import { immutableJson } from '@shieldaai/agent-guard/internal';
 import { MapService } from './service.js';
 import { validateReadScope } from './types.js';
 import { createMapMcpHandler } from './mcp.js';
-import { fail, fields, integer, parseRequest } from './boundary.js';
-import { headers, errorResponse, safeError, count, consume, readBody } from './transport.js';
+import { fail, integer } from './common.js';
+import { fields } from './boundary.js';
+import { headers, errorResponse, respondError, count, consume, queryEnvelope, rateLimit, readJsonBody, timeoutStatus, refuseOtherTraffic, sendAsset, } from './transport.js';
 import { loadMapAssets } from './assets.js';
 const TOKEN = /^agm_v1\.[A-Za-z0-9_-]{43}$/;
 const hash = (text) => createHash('sha256').update(text).digest();
-export function createMapToken() { return `agm_v1.${randomBytes(32).toString('base64url')}`; }
+export function createMapToken() {
+    return `agm_v1.${randomBytes(32).toString('base64url')}`;
+}
 /** Loopback pilot server. Remote serving requires a trusted, verified TLS reverse proxy. */
 export async function startMapServer(options) {
-    const config = fields(options, ['service', 'credentials', 'viewerDirectory', 'port', 'maxRequestBytes',
-        'maxResponseBytes', 'requestTimeoutMs', 'maxConcurrentRequests', 'rateLimit'], ['service', 'credentials']);
+    const config = fields(options, [
+        'service',
+        'credentials',
+        'viewerDirectory',
+        'port',
+        'maxRequestBytes',
+        'maxResponseBytes',
+        'requestTimeoutMs',
+        'maxConcurrentRequests',
+        'rateLimit',
+    ], ['service', 'credentials']);
     if (!(config.service instanceof MapService))
         fail('MAP_CONFIG_INVALID');
     const service = config.service;
@@ -22,8 +34,7 @@ export async function startMapServer(options) {
     const responseLimit = integer(config.maxResponseBytes, 2 * 1024 * 1024, 128, 2 * 1024 * 1024);
     const timeout = integer(config.requestTimeoutMs, 10_000, 10, 30_000);
     const concurrency = integer(config.maxConcurrentRequests, 4, 1, 32);
-    const rate = config.rateLimit === undefined ? {} : fields(config.rateLimit, ['maxRequests', 'windowMs'], ['maxRequests', 'windowMs']);
-    const maxRequests = integer(rate.maxRequests, 120, 1, 10_000), windowMs = integer(rate.windowMs, 60_000, 10, 60_000);
+    const { maxRequests, windowMs } = rateLimit(config.rateLimit, 120);
     let copied;
     try {
         copied = immutableJson(config.credentials, 8, 100_000, 1024 * 1024);
@@ -49,14 +60,16 @@ export async function startMapServer(options) {
     const socketTimers = new WeakMap();
     let active = 0, closing = false, host = '';
     const globalBucket = { since: performance.now(), count: 0 };
-    const server = createServer({ maxHeaderSize: 8192, headersTimeout: timeout, requestTimeout: timeout, keepAliveTimeout: 1 }, (request, response) => { void handle(request, response); });
+    const server = createServer({ maxHeaderSize: 8192, headersTimeout: timeout, requestTimeout: timeout, keepAliveTimeout: 1 }, (request, response) => {
+        void handle(request, response);
+    });
     server.maxConnections = 64;
     server.maxHeadersCount = 0;
     async function handle(request, response) {
         request.on('error', () => { });
         response.on('error', () => { });
         // Once headers arrive, leave a short bounded flush window after the request
-        // deadline. A connection timer at the same instant would erase the 408.
+        // deadline. A connection timer at the same instant would erase the 408 or 504.
         clearTimeout(socketTimers.get(request.socket));
         const socketTimer = setTimeout(() => request.socket.destroy(), timeout + 250);
         socketTimer.unref();
@@ -64,9 +77,14 @@ export async function startMapServer(options) {
         const started = performance.now();
         const abort = new AbortController();
         let admitted = false;
+        // Whether the whole request has arrived (a GET has no body to wait for): a timeout after
+        // that is the service's (504), not the client's (408).
+        let received = request.method === 'GET';
         let timer;
-        const check = () => { if (abort.signal.aborted || performance.now() - started > timeout)
-            fail('MAP_TIMEOUT'); };
+        const check = () => {
+            if (abort.signal.aborted || performance.now() - started > timeout)
+                fail('MAP_TIMEOUT');
+        };
         try {
             consume(globalBucket, Math.min(maxRequests * credentials.length, 10_000), windowMs);
             if (closing || active >= concurrency)
@@ -74,15 +92,22 @@ export async function startMapServer(options) {
             active++;
             admitted = true;
             aborts.add(abort);
-            timer = setTimeout(() => { abort.abort(); errorResponse(response, 'MAP_TIMEOUT'); }, timeout);
+            timer = setTimeout(() => {
+                abort.abort();
+                errorResponse(response, 'MAP_TIMEOUT', timeoutStatus(received));
+            }, timeout);
             timer.unref();
-            if (count(request, 'host') !== 1 || request.headers.host !== host || request.headers['proxy-authorization'] !== undefined)
+            if (count(request, 'host') !== 1 ||
+                request.headers.host !== host ||
+                request.headers['proxy-authorization'] !== undefined)
                 fail('MAP_REQUEST_DENIED');
             const origin = request.headers.origin;
-            if (count(request, 'origin') > 1 || (origin !== undefined && origin !== `http://${host}`) ||
-                (request.headers['sec-fetch-site'] !== undefined && !['same-origin', 'none'].includes(request.headers['sec-fetch-site'])))
+            if (count(request, 'origin') > 1 ||
+                (origin !== undefined && origin !== `http://${host}`) ||
+                (request.headers['sec-fetch-site'] !== undefined &&
+                    !['same-origin', 'none'].includes(request.headers['sec-fetch-site'])))
                 fail('MAP_REQUEST_DENIED');
-            const path = request.url === '/' ? '/index.html' : request.url ?? '';
+            const path = request.url === '/' ? '/index.html' : (request.url ?? '');
             if (request.method === 'GET' && path === '/auth/session') {
                 const body = Buffer.from(JSON.stringify({ mode: 'bearer' }));
                 headers(response, body.length);
@@ -92,9 +117,7 @@ export async function startMapServer(options) {
             }
             const asset = assets.get(path);
             if (request.method === 'GET' && asset) {
-                headers(response, asset.body.length, asset.mime);
-                response.writeHead(200);
-                response.end(asset.body);
+                sendAsset(response, asset);
                 return;
             }
             if (request.method !== 'POST' || !['/v1/query', '/mcp'].includes(path))
@@ -113,28 +136,15 @@ export async function startMapServer(options) {
             if (!credential)
                 fail('MAP_UNAUTHENTICATED');
             consume(credential.bucket, maxRequests, windowMs);
-            if (count(request, 'content-type') !== 1 || !/^application\/json(?:\s*;\s*charset=utf-8)?$/i.test(request.headers['content-type'] ?? '') ||
-                count(request, 'content-length') > 1 || count(request, 'transfer-encoding') > 1 || request.headers['content-encoding'] !== undefined)
-                fail('MAP_REQUEST_INVALID');
-            const length = request.headers['content-length'];
-            if (length !== undefined && (!/^\d+$/.test(length) || !Number.isSafeInteger(Number(length))))
-                fail('MAP_REQUEST_INVALID');
-            if (length !== undefined && Number(length) > requestLimit)
-                fail('MAP_REQUEST_TOO_LARGE');
-            const bytes = await readBody(request, requestLimit, abort.signal);
+            // The credential and rate checks have passed; a refusal above already answered with its status.
+            const parsed = await readJsonBody(request, response, requestLimit, abort.signal);
+            received = true;
             check();
-            const parsed = parseRequest(bytes, requestLimit);
             let output;
             let status = 200;
             let mime = 'application/json';
             if (path === '/v1/query') {
-                let envelope;
-                try {
-                    envelope = fields(parsed, ['operation', 'args'], ['operation', 'args']);
-                }
-                catch {
-                    fail('MAP_REQUEST_INVALID');
-                }
+                const envelope = queryEnvelope(parsed);
                 const result = await service.query(credential.scope, envelope.operation, envelope.args);
                 check();
                 output = Buffer.from(JSON.stringify(result));
@@ -143,11 +153,15 @@ export async function startMapServer(options) {
                 if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
                     fail('MAP_REQUEST_INVALID');
                 const method = parsed.method;
-                if (typeof method !== 'string' || !['initialize', 'notifications/initialized', 'server/discover', 'tools/list', 'tools/call', 'ping'].includes(method))
+                if (typeof method !== 'string' ||
+                    !['initialize', 'notifications/initialized', 'server/discover', 'tools/list', 'tools/call', 'ping'].includes(method))
                     fail('MAP_REQUEST_DENIED');
                 const handler = createMapMcpHandler(service, credential.scope);
                 try {
-                    const forwarded = new Headers({ 'content-type': 'application/json', accept: 'application/json, text/event-stream' });
+                    const forwarded = new Headers({
+                        'content-type': 'application/json',
+                        accept: 'application/json, text/event-stream',
+                    });
                     for (const name of ['mcp-protocol-version', 'mcp-session-id']) {
                         if (count(request, name) > 1)
                             fail('MAP_REQUEST_INVALID');
@@ -155,8 +169,12 @@ export async function startMapServer(options) {
                         if (typeof value === 'string')
                             forwarded.set(name, value);
                     }
-                    const result = await handler.fetch(new Request(`http://${host}/mcp`, { method: 'POST', headers: forwarded,
-                        body: JSON.stringify(parsed), signal: abort.signal }), { parsedBody: parsed });
+                    const result = await handler.fetch(new Request(`http://${host}/mcp`, {
+                        method: 'POST',
+                        headers: forwarded,
+                        body: JSON.stringify(parsed),
+                        signal: abort.signal,
+                    }), { parsedBody: parsed });
                     const reader = result.body?.getReader();
                     const chunks = [];
                     let size = 0;
@@ -193,7 +211,7 @@ export async function startMapServer(options) {
             response.end(output);
         }
         catch (error) {
-            errorResponse(response, safeError(error));
+            respondError(response, error, received);
         }
         finally {
             if (timer)
@@ -208,19 +226,27 @@ export async function startMapServer(options) {
         const timer = setTimeout(() => socket.destroy(), timeout);
         timer.unref();
         socketTimers.set(socket, timer);
-        socket.once('close', () => { sockets.delete(socket); clearTimeout(socketTimers.get(socket)); });
+        socket.once('close', () => {
+            sockets.delete(socket);
+            clearTimeout(socketTimers.get(socket));
+        });
+    });
+    refuseOtherTraffic(server, handle);
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(port, '127.0.0.1', () => {
+            server.off('error', reject);
+            resolve();
+        });
     });
-    server.on('checkContinue', (request, response) => { void handle(request, response); });
-    server.on('checkExpectation', (_request, response) => errorResponse(response, 'MAP_REQUEST_DENIED'));
-    server.on('connect', (_request, socket) => socket.destroy());
-    server.on('upgrade', (_request, socket) => socket.destroy());
-    server.on('clientError', (_error, socket) => socket.destroy());
-    await new Promise((resolve, reject) => { server.once('error', reject); server.listen(port, '127.0.0.1', () => { server.off('error', reject); resolve(); }); });
     const address = server.address();
     if (!address || typeof address === 'string')
         fail('MAP_UNAVAILABLE');
     host = `127.0.0.1:${address.port}`;
-    return { server, url: `http://${host}`, async close() {
+    return {
+        server,
+        url: `http://${host}`,
+        async close() {
             if (closing)
                 return;
             closing = true;
@@ -229,5 +255,6 @@ export async function startMapServer(options) {
             for (const socket of sockets)
                 socket.destroy();
             await new Promise(resolve => server.close(() => resolve()));
-        } };
+        },
+    };
 }