@phnx-labs/agents-cli 1.20.87 → 1.20.89

package/dist/lib/triggers/handlers.js

@@ -0,0 +1,384 @@
+/**
+ * Webhook handler config layer.
+ *
+ * Handlers are one-off triggers stored in `~/.agents/webhooks/*.yml` (plus
+ * project/system layers). They complement routine triggers: a matching webhook
+ * can run an agent, workflow, shell command, or delegate to a routine.
+ */
+import { exec } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'yaml';
+import { emit } from '../events.js';
+import { machineId, normalizeHost } from '../machine-id.js';
+import { safeJoin } from '../paths.js';
+import { pickFleetDevice } from '../routines-placement.js';
+import { assertShellSubstitutionSupported, readJob, substituteWebhookCommand, substituteWebhookPrompt, } from '../routines.js';
+import { ensureAgentsDir, getProjectWebhooksDir, getSystemWebhooksDir, getWebhooksDir } from '../state.js';
+const HANDLER_DEFAULTS = {
+    enabled: true,
+};
+/** Read `repository.full_name` (`owner/name`) from a webhook payload, if present. */
+function payloadRepo(payload) {
+    const repo = payload?.repository;
+    const fullName = repo?.full_name;
+    return typeof fullName === 'string' && fullName.length > 0 ? fullName : null;
+}
+/** Strip a `refs/heads/` (or `refs/tags/`) prefix to the short branch/tag name. */
+function shortRef(ref) {
+    return ref.replace(/^refs\/(heads|tags)\//, '');
+}
+/** Extract candidate branches a webhook payload references. */
+function payloadBranches(event, payload) {
+    const branches = new Set();
+    const add = (v) => {
+        if (typeof v === 'string' && v.length > 0)
+            branches.add(shortRef(v));
+    };
+    switch (event) {
+        case 'push':
+            add(payload.ref);
+            break;
+        case 'pull_request': {
+            const pr = payload.pull_request;
+            add(pr?.base?.ref);
+            add(pr?.head?.ref);
+            break;
+        }
+        case 'workflow_run': {
+            const run = payload.workflow_run;
+            add(run?.head_branch);
+            break;
+        }
+        default:
+            break;
+    }
+    return [...branches];
+}
+function linearAction(payload) {
+    return typeof payload.action === 'string' ? payload.action : null;
+}
+function linearTeamKey(payload) {
+    const data = payload.data;
+    const identifier = data?.identifier;
+    if (typeof identifier === 'string') {
+        const match = /^([A-Z][A-Z0-9]*)-\d+$/.exec(identifier);
+        if (match)
+            return match[1];
+    }
+    const team = data?.team;
+    return typeof team?.key === 'string' ? team.key : null;
+}
+function linearLabels(payload) {
+    const data = payload.data;
+    const labels = Array.isArray(data?.labels) ? data?.labels : [];
+    return labels
+        .map((n) => n.name)
+        .filter((n) => typeof n === 'string' && n.length > 0);
+}
+function githubAction(payload) {
+    return typeof payload.action === 'string' ? payload.action : null;
+}
+function githubLabels(payload) {
+    const names = new Set();
+    const add = (value) => {
+        if (typeof value === 'string' && value.length > 0)
+            names.add(value);
+    };
+    const deliveryLabel = payload.label;
+    add(deliveryLabel?.name);
+    const pr = payload.pull_request;
+    const prLabels = Array.isArray(pr?.labels) ? pr.labels : [];
+    for (const label of prLabels) {
+        add(label.name);
+    }
+    const issue = payload.issue;
+    const issueLabels = Array.isArray(issue?.labels) ? issue.labels : [];
+    for (const label of issueLabels) {
+        add(label.name);
+    }
+    return [...names];
+}
+function readHandlerFile(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const parsed = yaml.parse(content);
+        if (!parsed || typeof parsed !== 'object')
+            return null;
+        return {
+            ...HANDLER_DEFAULTS,
+            ...parsed,
+            name: parsed.name || path.basename(filePath).replace(/\.ya?ml$/, ''),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function handlerRunsOnThisDevice(handler) {
+    if (!handler.devices || handler.devices.length === 0)
+        return true;
+    const self = machineId();
+    return handler.devices.some((d) => normalizeHost(d) === self);
+}
+const HOST_PLATFORMS = ['linux', 'macos', 'windows'];
+function parseHostPlatform(raw) {
+    const parts = raw
+        .split('/')
+        .map((s) => s.trim().toLowerCase())
+        .filter((s) => s.length > 0);
+    const platformIdx = parts.findIndex((p) => HOST_PLATFORMS.includes(p));
+    if (platformIdx === -1)
+        return { base: parts.join('/') };
+    const platform = parts[platformIdx];
+    const rest = parts.filter((_, i) => i !== platformIdx).join('/');
+    return { base: rest, platform };
+}
+/**
+ * Resolve a handler `host` expression to a concrete host or local execution.
+ *
+ * - Specific device name (e.g. `yosemite-s0`) → run there over SSH, or locally
+ *   if it names this machine.
+ * - `fleet` → pick any online worker device.
+ * - `fleet/<platform>` or `<platform>/fleet` (e.g. `fleet/linux`, `linux/fleet`)
+ *   → pick any online worker on that platform. `linux` alone is accepted as a
+ *   shorthand for `fleet/linux`.
+ *
+ * Throws when a fleet expression matches no eligible device, rather than
+ * silently falling back to this machine — `fleet/linux` must never land on a
+ * macOS box.
+ */
+export function resolveHandlerHost(host) {
+    if (!host || host.trim() === '')
+        return {};
+    const { base, platform } = parseHostPlatform(host);
+    const isFleet = base === '' || base === 'fleet';
+    if (isFleet) {
+        const picked = pickFleetDevice(undefined, platform);
+        if (!picked) {
+            throw new Error(`handler host '${host}': no eligible online fleet device`);
+        }
+        if (normalizeHost(picked) === machineId())
+            return {};
+        return { host: picked, hostStrategy: 'host' };
+    }
+    if (normalizeHost(base) === machineId())
+        return {};
+    return { host: base, hostStrategy: 'host' };
+}
+/**
+ * List all webhook handlers, scanning project > user > system webhook dirs.
+ * Higher layers shadow lower ones of the same name (first-seen wins).
+ */
+export function listHandlers(cwd) {
+    ensureAgentsDir();
+    const seen = new Set();
+    const handlers = [];
+    const dirs = [];
+    if (cwd) {
+        const projectDir = getProjectWebhooksDir(cwd);
+        if (projectDir)
+            dirs.push({ scope: 'project', path: projectDir });
+    }
+    dirs.push({ scope: 'user', path: getWebhooksDir() });
+    dirs.push({ scope: 'system', path: getSystemWebhooksDir() });
+    for (const { path: dir } of dirs) {
+        if (!fs.existsSync(dir))
+            continue;
+        const files = fs.readdirSync(dir).filter((f) => f.endsWith('.yml') || f.endsWith('.yaml'));
+        for (const file of files) {
+            const handler = readHandlerFile(safeJoin(dir, file));
+            if (!handler)
+                continue;
+            if (seen.has(handler.name))
+                continue;
+            seen.add(handler.name);
+            handlers.push(handler);
+        }
+    }
+    return handlers;
+}
+/** Pure matcher: does this handler match the incoming webhook? */
+export function handlerMatchesWebhook(handler, webhook) {
+    if (handler.enabled === false)
+        return false;
+    if (handler.source !== webhook.source)
+        return false;
+    if (handler.event && handler.event !== webhook.event)
+        return false;
+    if (!handlerRunsOnThisDevice(handler))
+        return false;
+    if (handler.action) {
+        const action = webhook.source === 'github' ? githubAction(webhook.payload) : linearAction(webhook.payload);
+        if (action !== handler.action)
+            return false;
+    }
+    if (webhook.source === 'linear') {
+        if (handler.teamKey && linearTeamKey(webhook.payload) !== handler.teamKey)
+            return false;
+        if (handler.label) {
+            const expected = handler.label.toLowerCase();
+            if (!linearLabels(webhook.payload).some((name) => name.toLowerCase() === expected))
+                return false;
+        }
+        if (handler.stateTo) {
+            const data = webhook.payload.data;
+            const current = data?.state?.name;
+            if (current !== handler.stateTo)
+                return false;
+        }
+        if (handler.stateFrom) {
+            const updatedFrom = webhook.payload.updatedFrom;
+            const previous = updatedFrom?.state?.name;
+            if (previous !== handler.stateFrom)
+                return false;
+        }
+        return true;
+    }
+    if (handler.repo) {
+        const repo = payloadRepo(webhook.payload);
+        if (!repo || repo.toLowerCase() !== handler.repo.toLowerCase())
+            return false;
+    }
+    if (handler.branch) {
+        const branches = payloadBranches(webhook.event, webhook.payload);
+        if (!branches.some((b) => b === handler.branch))
+            return false;
+    }
+    if (handler.label) {
+        const expected = handler.label.toLowerCase();
+        if (!githubLabels(webhook.payload).some((name) => name.toLowerCase() === expected))
+            return false;
+    }
+    return true;
+}
+/**
+ * Build the variable-substitution context for a webhook. Linear events expose
+ * `issue` and `updatedFrom`; GitHub events expose `repository`, `pull_request`,
+ * and `issue`.
+ */
+export function buildWebhookContext(webhook) {
+    const action = webhook.source === 'github'
+        ? githubAction(webhook.payload) ?? undefined
+        : linearAction(webhook.payload) ?? undefined;
+    if (webhook.source === 'linear') {
+        return {
+            source: webhook.source,
+            event: webhook.event,
+            action,
+            issue: webhook.payload.data,
+            updatedFrom: webhook.payload.updatedFrom,
+        };
+    }
+    return {
+        source: webhook.source,
+        event: webhook.event,
+        action,
+        repository: webhook.payload.repository,
+        pull_request: webhook.payload.pull_request,
+        issue: webhook.payload.issue,
+    };
+}
+function defaultExecCommand(command) {
+    return new Promise((resolve) => {
+        exec(command, (error, stdout, stderr) => {
+            const output = stdout + stderr;
+            if (error) {
+                resolve({ exitCode: typeof error.code === 'number' ? error.code : 1, output });
+            }
+            else {
+                resolve({ exitCode: 0, output });
+            }
+        });
+    });
+}
+function dispatchDefault(config) {
+    // Import lazily so the runner module (heavy) is only loaded when a handler
+    // actually needs to spawn. Tests inject dispatch functions, so this path is
+    // not exercised in unit tests.
+    return import('../runner.js').then((m) => m.executeJobDetached(config));
+}
+/**
+ * Execute a handler's action. Runs the configured agent/workflow/command or
+ * delegates to a routine, substituting `{{...}}` placeholders from the webhook
+ * context.
+ */
+export async function executeHandler(handler, webhook, opts = {}) {
+    const context = buildWebhookContext(webhook);
+    const base = { handlerName: handler.name };
+    emit('webhook.handler.start', {
+        source: webhook.source,
+        event: webhook.event,
+        handlerName: handler.name,
+    });
+    try {
+        const result = await executeHandlerAction(handler, webhook, context, opts);
+        emit('webhook.handler.end', {
+            source: webhook.source,
+            event: webhook.event,
+            handlerName: handler.name,
+            status: 'success',
+            ...result,
+        });
+        return { ...base, ...result };
+    }
+    catch (err) {
+        const error = err.message;
+        emit('webhook.handler.end', {
+            source: webhook.source,
+            event: webhook.event,
+            handlerName: handler.name,
+            status: 'error',
+            error,
+        });
+        throw err;
+    }
+}
+async function executeHandlerAction(handler, webhook, context, opts) {
+    const substitutedPrompt = handler.run?.prompt ? substituteWebhookPrompt(handler.run.prompt, context) : '';
+    // Resolved once so a fleet pick can't differ between the two dispatch paths.
+    const hostFields = resolveHandlerHost(handler.host);
+    if (handler.run?.agent || handler.run?.workflow) {
+        const config = {
+            name: handler.name,
+            mode: 'auto',
+            effort: 'auto',
+            timeout: '10m',
+            enabled: true,
+            prompt: substitutedPrompt,
+            ...(handler.run.agent ? { agent: handler.run.agent } : { workflow: handler.run.workflow }),
+            ...(handler.devices ? { devices: handler.devices } : {}),
+            ...(handler.run.env ? { env: handler.run.env } : {}),
+            ...(hostFields.host ? { host: hostFields.host } : {}),
+            ...(hostFields.hostStrategy ? { hostStrategy: hostFields.hostStrategy } : {}),
+        };
+        const dispatch = handler.run.agent
+            ? (opts.dispatchAgent ?? dispatchDefault)
+            : (opts.dispatchWorkflow ?? dispatchDefault);
+        const meta = await dispatch(config);
+        return { runId: meta.runId };
+    }
+    if (handler.run?.command) {
+        assertShellSubstitutionSupported(handler.run.command);
+        const command = substituteWebhookCommand(handler.run.command, context);
+        const exec = opts.execCommand ?? defaultExecCommand;
+        const { exitCode, output } = await exec(command);
+        return { exitCode, output };
+    }
+    if (handler.routine) {
+        const routine = readJob(handler.routine);
+        if (!routine)
+            throw new Error(`routine '${handler.routine}' not found`);
+        const config = {
+            ...routine,
+            prompt: substituteWebhookPrompt(routine.prompt, context),
+            ...(handler.devices ? { devices: handler.devices } : {}),
+            ...(hostFields.host ? { host: hostFields.host } : {}),
+            ...(hostFields.hostStrategy ? { hostStrategy: hostFields.hostStrategy } : {}),
+        };
+        const dispatch = opts.dispatchRoutine ?? dispatchDefault;
+        const meta = await dispatch(config);
+        return { runId: meta.runId };
+    }
+    throw new Error(`handler '${handler.name}' has no run or routine action`);
+}

package/dist/lib/triggers/webhook.d.ts

@@ -13,7 +13,8 @@
  */
 import * as http from 'http';
 import type { IncomingHttpHeaders } from 'http';
-import type { JobConfig, RunMeta } from '../routines.js';
+import type { JobConfig, RunMeta, WebhookContext } from '../routines.js';
+import { type FiredHandler } from './handlers.js';
 export type WebhookSource = 'github' | 'linear';
 export interface IncomingWebhook {
     /** Delivery source, derived from `/hooks/<source>` or one-shot command flags. */
@@ -41,6 +42,11 @@ export declare function webhookRepo(payload: Record<string, unknown>): string |
  *   - issue_comment: no branch (comments aren't branch-scoped)
  */
 export declare function webhookBranches(event: string, payload: Record<string, unknown>): string[];
+export declare function linearAction(payload: Record<string, unknown>): string | null;
+export declare function linearTeamKey(payload: Record<string, unknown>): string | null;
+export declare function linearLabels(payload: Record<string, unknown>): string[];
+export declare function githubAction(payload: Record<string, unknown>): string | null;
+export declare function githubLabels(payload: Record<string, unknown>): string[];
 /** True when a single job's trigger matches the given webhook. Pure. */
 export declare function jobMatchesWebhook(job: JobConfig, webhook: IncomingWebhook): boolean;
 /**
@@ -63,6 +69,8 @@ export interface FireWebhookOptions {
     skipJobNames?: ReadonlySet<string>;
     /** Called immediately after a single matched job dispatch succeeds. */
     onJobFired?: (job: JobConfig, fired: FiredJob) => void;
+    /** Optional webhook context used to expand `{{...}}` placeholders in prompts. */
+    context?: WebhookContext;
 }
 /** Result of firing one matched job. */
 export interface FiredJob {
@@ -124,7 +132,7 @@ export interface WebhookServerOptions {
     /** Override the fire options (mainly for tests). */
     fire?: FireWebhookOptions;
     /** Called after each delivery is handled (mainly for tests/observability). */
-    onDelivery?: (webhook: IncomingWebhook, fired: FiredJob[]) => void;
+    onDelivery?: (webhook: IncomingWebhook, fired: FiredJob[], handlers: FiredHandler[]) => void;
     deliveryStore?: DeliveryStore;
     rateLimiter?: RateLimiter;
     rateLimitPerMinute?: number;

package/dist/lib/triggers/webhook.js

@@ -15,8 +15,10 @@ import * as crypto from 'crypto';
 import * as fs from 'fs';
 import * as http from 'http';
 import * as path from 'path';
-import { jobRunsOnThisDevice, listJobs } from '../routines.js';
+import { jobRunsOnThisDevice, listJobs, substituteWebhookPrompt } from '../routines.js';
 import { executeJobDetached } from '../runner.js';
+import { emit } from '../events.js';
+import { listHandlers, handlerMatchesWebhook, executeHandler, buildWebhookContext, } from './handlers.js';
 /** Read `repository.full_name` (`owner/name`) from a webhook payload, if present. */
 export function webhookRepo(payload) {
     const repo = payload?.repository;
@@ -62,10 +64,10 @@ export function webhookBranches(event, payload) {
     }
     return [...branches];
 }
-function linearAction(payload) {
+export function linearAction(payload) {
     return typeof payload.action === 'string' ? payload.action : null;
 }
-function linearTeamKey(payload) {
+export function linearTeamKey(payload) {
     const data = payload.data;
     const identifier = data?.identifier;
     if (typeof identifier === 'string') {
@@ -76,7 +78,7 @@ function linearTeamKey(payload) {
     const team = data?.team;
     return typeof team?.key === 'string' ? team.key : null;
 }
-function linearLabels(payload) {
+export function linearLabels(payload) {
     // Linear webhook bodies flatten list relations: an Issue event carries
     // `data.labels` as a flat array of label objects (`[{ id, name, color }]`),
     // NOT the `{ nodes: [...] }` connection shape returned by the GraphQL API.
@@ -87,10 +89,10 @@ function linearLabels(payload) {
         .map((n) => n.name)
         .filter((n) => typeof n === 'string' && n.length > 0);
 }
-function githubAction(payload) {
+export function githubAction(payload) {
     return typeof payload.action === 'string' ? payload.action : null;
 }
-function githubLabels(payload) {
+export function githubLabels(payload) {
     const names = new Set();
     const add = (value) => {
         if (typeof value === 'string' && value.length > 0)
@@ -148,6 +150,18 @@ function linearTriggerMatches(trigger, webhook) {
         if (!linearLabels(webhook.payload).some((name) => name.toLowerCase() === expected))
             return false;
     }
+    if (trigger.stateTo) {
+        const data = webhook.payload.data;
+        const current = data?.state?.name;
+        if (current !== trigger.stateTo)
+            return false;
+    }
+    if (trigger.stateFrom) {
+        const updatedFrom = webhook.payload.updatedFrom;
+        const previous = updatedFrom?.state?.name;
+        if (previous !== trigger.stateFrom)
+            return false;
+    }
     return true;
 }
 /** True when a single job's trigger matches the given webhook. Pure. */
@@ -193,8 +207,12 @@ export async function fireWebhookJobs(webhook, options = {}) {
     for (const job of matched) {
         if (skipJobNames.has(job.name))
             continue;
+        emit('webhook.matched', { source: webhook.source, event: webhook.event, jobName: job.name });
         try {
-            const meta = await dispatch(job);
+            const jobToDispatch = options.context
+                ? { ...job, prompt: substituteWebhookPrompt(job.prompt, options.context) }
+                : job;
+            const meta = await dispatch(jobToDispatch);
             const firedJob = { jobName: job.name, runId: meta.runId };
             fired.push(firedJob);
             options.onJobFired?.(job, firedJob);
@@ -419,6 +437,7 @@ export function startWebhookServer(options) {
             }
             const secret = options.secrets[source];
             if (!secret) {
+                emit('webhook.rejected', { source, reason: 'missing webhook secret' });
                 res.writeHead(503, { 'content-type': 'application/json' });
                 res.end(JSON.stringify({ ok: false, error: `missing ${source} webhook secret` }));
                 return;
@@ -430,12 +449,14 @@ export function startWebhookServer(options) {
             // shed this load on its own.
             const ip = req.socket.remoteAddress ?? 'unknown';
             if (!ipRateLimiter.take(ip)) {
+                emit('webhook.rejected', { source, reason: 'ip rate limit exceeded' });
                 res.writeHead(429, { 'content-type': 'application/json' });
                 res.end(JSON.stringify({ ok: false, error: 'rate limit exceeded' }));
                 return;
             }
             const declaredLength = Number.parseInt(header(req.headers, 'content-length') ?? '', 10);
             if (Number.isFinite(declaredLength) && declaredLength > maxBodyBytes) {
+                emit('webhook.rejected', { source, reason: 'payload too large' });
                 res.writeHead(413, { 'content-type': 'application/json' });
                 res.end(JSON.stringify({ ok: false, error: `payload exceeds ${maxBodyBytes} bytes` }));
                 return;
@@ -446,45 +467,78 @@ export function startWebhookServer(options) {
                     ? verifyGithubSignature(req.headers, rawBody, secret)
                     : verifyLinearSignature(req.headers, rawBody, secret);
                 if (!valid) {
+                    emit('webhook.rejected', { source, reason: 'invalid signature' });
                     res.writeHead(401, { 'content-type': 'application/json' });
                     res.end(JSON.stringify({ ok: false, error: 'invalid signature' }));
                     return;
                 }
                 const id = deliveryId(source, req.headers, rawBody);
+                const event = source === 'github' ? (header(req.headers, 'x-github-event') ?? '') : '';
+                emit('webhook.received', { source, event, deliveryId: id });
                 if (deliveryStore.seen(id)) {
                     res.writeHead(200, { 'content-type': 'application/json' });
                     res.end(JSON.stringify({ ok: true, duplicate: true, fired: [] }));
                     return;
                 }
                 const payload = rawBody.length > 0 ? JSON.parse(rawBody.toString('utf-8')) : {};
+                const webhookEvent = source === 'github' ? event : String(payload.type ?? '');
                 if (source === 'linear' && !verifyLinearTimestamp(payload)) {
+                    emit('webhook.rejected', { source, event: webhookEvent, deliveryId: id, reason: 'stale linear webhook timestamp' });
                     res.writeHead(401, { 'content-type': 'application/json' });
                     res.end(JSON.stringify({ ok: false, error: 'stale linear webhook timestamp' }));
                     return;
                 }
                 if (!rateLimiter.take(source)) {
+                    emit('webhook.rejected', { source, event: webhookEvent, deliveryId: id, reason: 'rate limit exceeded' });
                     res.writeHead(429, { 'content-type': 'application/json' });
                     res.end(JSON.stringify({ ok: false, error: 'rate limit exceeded' }));
                     return;
                 }
                 const webhook = {
                     source,
-                    event: source === 'github' ? (header(req.headers, 'x-github-event') ?? '') : String(payload.type ?? ''),
+                    event: webhookEvent,
                     payload,
                 };
+                emit('webhook.authorized', { source, event: webhookEvent, deliveryId: id });
+                const context = buildWebhookContext(webhook);
                 const fireOptions = options.fire ?? {};
-                const fired = await fireWebhookJobs(webhook, {
+                const firedJobs = await fireWebhookJobs(webhook, {
                     ...fireOptions,
+                    context,
                     skipJobNames: deliveryStore.completedJobs(id),
                     onJobFired: (job, firedJob) => {
+                        emit('webhook.fired', { source, event: webhookEvent, deliveryId: id, jobName: job.name, runId: firedJob.runId });
                         deliveryStore.markJob(id, job.name);
                         fireOptions.onJobFired?.(job, firedJob);
                     },
                 });
+                const handlers = listHandlers();
+                const matchedHandlers = handlers.filter((handler) => handlerMatchesWebhook(handler, webhook));
+                const firedHandlers = [];
+                const handlerErrors = [];
+                await Promise.allSettled(matchedHandlers.map(async (handler) => {
+                    if (deliveryStore.completedJobs(id).has(handler.name))
+                        return;
+                    emit('webhook.matched', { source, event: webhookEvent, deliveryId: id, handlerName: handler.name });
+                    try {
+                        const result = await executeHandler(handler, webhook);
+                        deliveryStore.markJob(id, handler.name);
+                        firedHandlers.push(result);
+                    }
+                    catch (err) {
+                        handlerErrors.push({ handlerName: handler.name, error: err.message });
+                    }
+                }));
                 deliveryStore.mark(id);
-                options.onDelivery?.(webhook, fired);
+                options.onDelivery?.(webhook, firedJobs, firedHandlers);
                 res.writeHead(200, { 'content-type': 'application/json' });
-                res.end(JSON.stringify({ ok: true, fired: fired.map((f) => f.jobName), runs: fired }));
+                res.end(JSON.stringify({
+                    ok: true,
+                    fired: firedJobs.map((f) => f.jobName),
+                    runs: firedJobs,
+                    handlers: firedHandlers,
+                    ...(handlerErrors.length > 0 ? { handlerErrors } : {}),
+                }));
             }
             catch (err) {
                 res.writeHead(400, { 'content-type': 'application/json' });