@phnx-labs/agents-cli 1.22.120 → 1.22.121

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

@@ -1,10 +1,3 @@
-/**
- * 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 type { JobConfig, RunMeta, WebhookContext } from '../scheduling/routines.js';
 import type { AgentId } from '../types.js';
 import type { IncomingWebhook, WebhookSource } from './webhook.js';
@@ -21,44 +14,17 @@ export interface WebhookHandler {
     label?: string;
     repo?: string;
     branch?: string;
-    /** Slack (source: slack) only — match one slash command, e.g. `/agents`. */
     command?: string;
-    /** Slack (source: slack) only — restrict to one channel id (`C0…`). Lets a
-     *  channel imply a project via a per-channel handler. */
     channel?: string;
-    /**
-     * Where to run the action. A device name (`yosemite-s0`) runs there over SSH;
-     * `fleet` picks any eligible online worker; `fleet/<platform>` (or
-     * `<platform>/fleet`, or a bare `linux`/`macos`/`windows`) restricts that pick
-     * to one platform. Omitted runs locally.
-     */
     host?: string;
-    /**
-     * Named project (`agents projects`) whose base directory the dispatched
-     * agent/workflow run lands in — the execution anchor, mirroring a routine's
-     * `project`. Without it an agent handler runs at the target's `$HOME` with no
-     * repo checkout to edit. Applies to `run.agent`/`run.workflow` and the
-     * `routine:` delegate; ignored by `run.command` (put a `cd` in the command).
-     */
     project?: string;
-    /**
-     * Portable execution directory for the dispatched run. A relative value
-     * resolves under `project` when set, otherwise the target's `$HOME`. Mirrors
-     * a routine's `cwd`.
-     */
     cwd?: string;
-    /**
-     * Permission mode for a dispatched agent/workflow run. Defaults to `auto`
-     * (write with the classifier). Set `skip`/`full` for fully unattended edits,
-     * or `plan` for a read-only run.
-     */
     mode?: JobConfig['mode'];
     run?: {
         agent?: AgentId;
         workflow?: string;
         command?: string;
         prompt?: string;
-        /** Environment variables injected into the spawned process. */
         env?: Record<string, string>;
     };
     routine?: string;
@@ -70,65 +36,22 @@ export interface FiredHandler {
     output?: string;
 }
 interface HandlerHostResolution {
-    /** Resolved execution host, or undefined to run locally. */
     host?: string;
-    /** Strategy that should be set on the JobConfig. */
     hostStrategy?: 'host' | 'fleet';
 }
-/**
- * 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 declare function resolveHandlerHost(host: string | undefined): HandlerHostResolution;
-/**
- * List all webhook handlers, scanning project > user > system webhook dirs.
- * Higher layers shadow lower ones of the same name (first-seen wins).
- */
 export declare function listHandlers(cwd?: string): WebhookHandler[];
-/** Pure matcher: does this handler match the incoming webhook? */
 export declare function handlerMatchesWebhook(handler: WebhookHandler, webhook: IncomingWebhook): boolean;
-/**
- * The `{{slack.*}}` substitution namespace: a Slack message split into an
- * agent-actionable project + prompt, plus the coordinates a reply threads into.
- */
 export interface SlackMessageContext {
-    /** The message with a leading bot mention stripped. */
     text: string;
-    /** The `PROJECT:` token at the head of the message, or '' when absent. */
     project: string;
-    /** The request — the text after `PROJECT:`, or the whole message. */
     prompt: string;
-    /** Channel id to reply into (`C0…`). */
     channel: string;
-    /** Thread ts to reply into (empty for a slash command → reply to the channel). */
     thread_ts: string;
-    /** Invoking user id (`U0…`). */
     user: string;
-    /** Slash command name (`/agents`), or '' for an event delivery. */
     command: string;
-    /**
-     * Slash-command reply URL (`https://hooks.slack.com/commands/…`), or '' for an
-     * event delivery. Slack accepts a POST here for 30 minutes with no token and no
-     * channel membership, so it is the only reply path that works before the app has
-     * been invited to a channel.
-     */
     response_url: string;
 }
-/**
- * Build the variable-substitution context for a webhook. Linear events expose
- * `issue` and `updatedFrom`; GitHub events expose `repository`, `pull_request`,
- * and `issue`; Slack events expose the `{{slack.*}}` namespace above.
- */
 export declare function buildWebhookContext(webhook: IncomingWebhook): WebhookContext;
 interface ExecuteHandlerOptions {
     dispatchAgent?: (config: JobConfig) => Promise<RunMeta>;
@@ -139,10 +62,5 @@ interface ExecuteHandlerOptions {
     }>;
     dispatchRoutine?: (config: JobConfig) => Promise<RunMeta>;
 }
-/**
- * Execute a handler's action. Runs the configured agent/workflow/command or
- * delegates to a routine, substituting `{{...}}` placeholders from the webhook
- * context.
- */
 export declare function executeHandler(handler: WebhookHandler, webhook: IncomingWebhook, opts?: ExecuteHandlerOptions): Promise<FiredHandler>;
 export {};

package/dist/lib/triggers/handlers.js

@@ -1,10 +1,3 @@
-/**
- * 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';
@@ -18,17 +11,14 @@ import { ensureAgentsDir, getProjectWebhooksDir, getSystemWebhooksDir, getWebhoo
 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) => {
@@ -134,20 +124,6 @@ function parseHostPlatform(raw) {
     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 {};
@@ -166,10 +142,6 @@ export function resolveHandlerHost(host) {
         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();
@@ -198,7 +170,6 @@ export function listHandlers(cwd) {
     }
     return handlers;
 }
-/** Pure matcher: does this handler match the incoming webhook? */
 export function handlerMatchesWebhook(handler, webhook) {
     if (handler.enabled === false)
         return false;
@@ -208,9 +179,6 @@ export function handlerMatchesWebhook(handler, webhook) {
         return false;
     if (!handlerRunsOnThisDevice(handler))
         return false;
-    // Slack has no GitHub/Linear action/label/branch vocabulary; it matches on the
-    // slash command and (optionally) the channel. `event` already pinned the
-    // subtype (`app_mention`) or the slash command name above.
     if (webhook.source === 'slack') {
         const slack = webhook.payload;
         if (handler.command && slack.command !== handler.command)
@@ -237,13 +205,6 @@ export function handlerMatchesWebhook(handler, webhook) {
             const current = data?.state?.name;
             if (current !== handler.stateTo)
                 return false;
-            // RUSH-2539: `stateTo` is a TRANSITION predicate, not a current-state one.
-            // Linear carries the prior value of each changed field in `updatedFrom`, so a
-            // real state change has `updatedFrom.state` (this codebase's shape) or
-            // `updatedFrom.stateId` (Linear's scalar). With neither, this Issue/update
-            // touched something else (label, assignee, description) while the issue merely
-            // still sits in `stateTo` — matching there re-fires on every later edit
-            // (RUSH-1459 accumulated 11 duplicate plan comments).
             const updatedTo = webhook.payload.updatedFrom;
             if (!updatedTo || (updatedTo.state === undefined && updatedTo.stateId === undefined))
                 return false;
@@ -274,15 +235,6 @@ export function handlerMatchesWebhook(handler, webhook) {
     return true;
 }
 const asString = (v) => (typeof v === 'string' ? v : '');
-/**
- * Split a Slack message into a `{{slack.*}}` context. Strips a leading bot
- * mention (`<@U0BOT> …`), then reads an optional `PROJECT:` prefix — a single
- * bare token followed by a colon and a space — as the project, with the
- * remainder the prompt. `AGI: rebase my PR` → project `AGI`, prompt
- * `rebase my PR`; a message with no such prefix leaves `project` empty and the
- * whole text as the prompt. The token pattern forbids slashes, so a project
- * value can never carry a path into a `cwd`/`project` substitution.
- */
 function parseSlackMessage(payload) {
     const cleaned = asString(payload.text).replace(/^\s*<@[^>]+>\s*/, '').trim();
     const m = /^([A-Za-z0-9][\w.-]*)\s*:\s+([\s\S]+)$/.exec(cleaned);
@@ -297,17 +249,8 @@ function parseSlackMessage(payload) {
         response_url: asString(payload.response_url),
     };
 }
-/**
- * Build the variable-substitution context for a webhook. Linear events expose
- * `issue` and `updatedFrom`; GitHub events expose `repository`, `pull_request`,
- * and `issue`; Slack events expose the `{{slack.*}}` namespace above.
- */
 export function buildWebhookContext(webhook) {
     if (webhook.source === 'slack') {
-        // The `{{slack.*}}` namespace rides an intersection over WebhookContext (a
-        // subtype of it) rather than a field on the shared type, so a Slack-only
-        // addition never touches the scheduling hub every routine test depends on.
-        // `substituteWebhookPrompt`/`getPath` read it dynamically at runtime.
         const ctx = {
             source: webhook.source,
             event: webhook.event,
@@ -350,16 +293,8 @@ function defaultExecCommand(command) {
     });
 }
 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('../daemon/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 };
@@ -393,12 +328,8 @@ export async function executeHandler(handler, webhook, opts = {}) {
 }
 async function executeHandlerAction(handler, webhook, context, opts) {
     const substitutedPrompt = handler.run?.prompt ? substituteWebhookPrompt(handler.run.prompt, context) : '';
-    // Slack routes the project per-message (`AGI: …`), so a handler may template
-    // its project/cwd — e.g. `project: "{{slack.project}}"`. Substitute + trim; an
-    // empty result omits the field (falls back to the run's default cwd / $HOME).
     const substitutedProject = handler.project ? substituteWebhookPrompt(handler.project, context).trim() : '';
     const substitutedCwd = handler.cwd ? substituteWebhookPrompt(handler.cwd, context).trim() : '';
-    // 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 = {
@@ -415,12 +346,6 @@ async function executeHandlerAction(handler, webhook, context, opts) {
             ...(substitutedCwd ? { cwd: substitutedCwd } : {}),
             ...(hostFields.host ? { host: hostFields.host } : {}),
             ...(hostFields.hostStrategy ? { hostStrategy: hostFields.hostStrategy } : {}),
-            // A handler is not a routine, so its name can never appear in this device's
-            // routine activation manifest — without this marker the gate answered "not
-            // activated here" and every delivery was skipped while the receiver logged
-            // `fired` (the same shape as RUSH-2681's monitor bug). The `routine:`
-            // delegate below deliberately omits it: that fires a REAL routine, which
-            // keeps its own activation gate.
             dispatchedBy: 'webhook',
         };
         const dispatch = handler.run.agent

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

@@ -1,133 +1,51 @@
-/**
- * Public webhook trigger receiver for routines.
- *
- * A routine may declare a `trigger` block instead of (or alongside) a cron
- * `schedule` (see `JobConfig.trigger` in `../routines.ts`). This module turns
- * incoming GitHub or Linear webhooks into the set of routines they should fire,
- * and dispatches those routines through the exact same path a cron fire uses
- * (`executeJobDetached`).
- *
- * The matching logic is pure, so it can be unit-tested without a daemon or HTTP
- * server. The listener adds the public-ingress requirements: raw-body HMAC
- * verification, idempotency, source allow-listing, and rate limiting.
- */
 import * as http from 'http';
 import type { IncomingHttpHeaders } from 'http';
 import type { JobConfig, RunMeta, WebhookContext } from '../scheduling/routines.js';
 import { type FiredHandler } from './handlers.js';
 export type WebhookSource = 'github' | 'linear' | 'slack';
 export interface IncomingWebhook {
-    /** Delivery source, derived from `/hooks/<source>` or one-shot command flags. */
     source: WebhookSource;
-    /** Source event name: GitHub header event, Linear payload `type`, or the Slack
-     *  event subtype (`app_mention`) / slash command (`/agents`). */
     event: string;
-    /** Decoded request body (JSON for GitHub/Linear/Slack-events; the normalized
-     *  {@link SlackPayload} for a Slack slash command's form body). */
     payload: Record<string, unknown>;
 }
-/** Read `repository.full_name` (`owner/name`) from a webhook payload, if present. */
 export declare function webhookRepo(payload: Record<string, unknown>): string | null;
-/**
- * Extract every candidate branch a webhook payload references, per event type.
- * A trigger's `branch` matches if it equals any of these. Different events
- * carry the branch in different places:
- *   - push:          `ref` (refs/heads/<b>)
- *   - pull_request:  base + head refs of the PR
- *   - workflow_run:  `workflow_run.head_branch`
- *   - 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;
-/**
- * Pure matcher: given a set of jobs and an incoming webhook, return the jobs
- * whose `trigger` matches. Jobs without a trigger (schedule-only routines) are
- * never selected — proving time-based jobs are unaffected by webhook delivery.
- */
 export declare function matchJobsToWebhook(jobs: JobConfig[], webhook: IncomingWebhook): JobConfig[];
-/** Options for firing webhook-matched jobs (dispatch is injectable for tests). */
 export interface FireWebhookOptions {
-    /** Job source. Defaults to all persisted routines (`listJobs()`). */
     jobs?: JobConfig[];
-    /**
-     * How to dispatch a matched job. Defaults to `executeJobDetached` — the SAME
-     * path a cron fire uses (see `daemon.ts`). Injectable so tests can assert
-     * matching without spawning real agent processes.
-     */
     dispatch?: (config: JobConfig) => Promise<RunMeta>;
-    /** Matched job names that already completed for this delivery. */
     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. */
 interface FiredJob {
     jobName: string;
     runId: string;
 }
-/**
- * Match an incoming webhook against the persisted routines and fire each match
- * through the cron dispatch path. Returns one entry per fired job.
- */
 export declare function fireWebhookJobs(webhook: IncomingWebhook, options?: FireWebhookOptions): Promise<FiredJob[]>;
 export declare function verifyGithubSignature(headers: IncomingHttpHeaders, rawBody: Buffer, secret: string): boolean;
 export declare function verifyLinearSignature(headers: IncomingHttpHeaders, rawBody: Buffer, secret: string): boolean;
-/**
- * Verify a Slack request signature (the `v0` scheme). Slack signs the base
- * string `v0:${timestamp}:${rawBody}` with the app's signing secret and sends
- * the hex digest as `X-Slack-Signature: v0=<hex>`, alongside the unix
- * `X-Slack-Request-Timestamp`. The timestamp is BOTH part of the signed base
- * string AND checked for freshness here — a request older than `toleranceSec`
- * (default 5 min) is rejected, so a captured, correctly-signed body cannot be
- * replayed later. Fails closed on any missing/malformed header.
- */
 export declare function verifySlackSignature(headers: IncomingHttpHeaders, rawBody: Buffer, secret: string, now?: number, toleranceSec?: number): boolean;
-/**
- * Normalized fields extracted from a Slack slash-command or Events API delivery.
- * This is the `payload` of a Slack {@link IncomingWebhook}: transport-level
- * parsing lives here, message *semantics* (splitting the mention text into an
- * agent / project / prompt) live in `handlers.ts` `buildWebhookContext`.
- */
 export interface SlackPayload extends Record<string, unknown> {
-    /** `url_verification` | `event_callback` | `slash_command`. */
     type: string;
-    /** Echoed back for the one-time Events API URL-verification handshake. */
     challenge?: string;
-    /** Slack event id (Events API) — the dedup key when present. */
     event_id?: string;
-    /** Event subtype, e.g. `app_mention` (Events API). */
     event_type?: string;
-    /** Raw message text (the mention body, or the slash-command text). */
     text?: string;
-    /** Channel id (`C0…`) the message arrived in. */
     channel?: string;
-    /** Thread to reply into: an existing thread's parent ts, else the message ts. */
     thread_ts?: string;
-    /** Invoking user id (`U0…`). */
     user?: string;
-    /** Slash command name, e.g. `/agents`. */
     command?: string;
-    /** Slash-command `response_url` (valid ~30 min, 5 uses). */
     response_url?: string;
-    /** Slack team / workspace id. */
     team?: string;
 }
-/**
- * Parse a Slack delivery body into a normalized {@link SlackPayload}. Slack
- * sends slash commands as `application/x-www-form-urlencoded` and Events API
- * deliveries (including the `url_verification` handshake) as
- * `application/json` — this is the one place that content-type branch lives.
- */
 export declare function parseSlackBody(contentType: string | undefined, rawBody: Buffer): SlackPayload;
-/** The `event` name a Slack delivery fires under: the slash command, or the event subtype. */
 export declare function slackEventName(payload: SlackPayload): string;
 export interface WebhookSecrets {
     github?: string;
@@ -140,102 +58,26 @@ interface DeliveryStore {
     completedJobs(id: string): ReadonlySet<string>;
     markJob(id: string, jobName: string): void;
 }
-/**
- * A durable, disk-backed delivery store. Unlike `createMemoryDeliveryStore`,
- * seen delivery ids survive a process restart and are bounded by AGE, not by a
- * fixed entry count — so a captured valid delivery cannot re-fire after a
- * restart or after count-based LRU eviction would have dropped it.
- *
- * `retentionMs` doubles as the replay-acceptance window: a delivery whose id is
- * still on record (younger than the window) is rejected as a duplicate; entries
- * older than the window are pruned (keeping the file bounded) since a webhook
- * source will not legitimately retry a delivery that old.
- */
 export declare function createFileDeliveryStore(filePath: string, retentionMs?: number): DeliveryStore;
 interface RateLimiter {
     take(key: string): boolean;
 }
-/**
- * Resolve once a receiver is actually accepting connections, REJECT if the bind
- * failed. `server.listen()` reports a bind failure (EADDRINUSE, EACCES) as an
- * asynchronous `'error'` event, never a throw — so a `try/catch` around
- * `startWebhookServer` cannot see it, and without this the event reaches Node's
- * default handler and takes the whole process down. Every caller that hosts a
- * receiver MUST await this rather than assuming the return means "bound".
- */
 export declare function waitForListening(server: http.Server): Promise<void>;
-/** Options for the local webhook http listener. */
 interface WebhookServerOptions {
     port?: number;
     host?: string;
-    /** HMAC signing secrets keyed by source. */
     secrets: WebhookSecrets;
-    /** Override the fire options (mainly for tests). */
     fire?: FireWebhookOptions;
-    /**
-     * Called the moment a delivery's matches are known — BEFORE any routine or
-     * handler is dispatched. Matching is a pure, synchronous lookup (no I/O), so
-     * this fires immediately after the ack, regardless of how long the matched
-     * work then takes to run. This is the right hook for a "webhook X fired Y"
-     * log line: a `run.command` handler that shells out a long agent session
-     * (`exec()`, which only resolves on process exit) used to hold that log back
-     * for as long as the session ran — `ps` would show the agent already running
-     * while the log still implied nothing had matched (RUSH-2722). Names only
-     * (no runId/exitCode yet — those aren't known until dispatch settles).
-     */
     onMatch?: (webhook: IncomingWebhook, matchedJobNames: string[], matchedHandlerNames: string[]) => void;
-    /**
-     * Called after a delivery has fully settled — every matched routine and
-     * handler dispatched (and, for `run.command` handlers, exited). Because the
-     * receiver acks the HTTP response BEFORE dispatch (see `startWebhookServer`),
-     * this fires strictly after the response has been written, and is the only
-     * way a caller observes the dispatch outcome (runId/exitCode/output). It is
-     * NOT the right hook for "did this webhook match" logging — use `onMatch`.
-     */
     onDelivery?: (webhook: IncomingWebhook, fired: FiredJob[], handlers: FiredHandler[]) => void;
-    /**
-     * Called when settling an already-acked delivery threw. The HTTP status can
-     * no longer carry the failure, so this is the loud path — the daemon host and
-     * `agents webhooks serve` both log it. Never swallowed silently.
-     */
     onDeliveryError?: (webhook: IncomingWebhook, error: Error) => void;
     deliveryStore?: DeliveryStore;
     rateLimiter?: RateLimiter;
     rateLimitPerMinute?: number;
     maxBodyBytes?: number;
-    /** Per-IP ingress throttle applied BEFORE the body read (bad-sig flood guard). */
     ipRateLimiter?: RateLimiter;
-    /** Per-source-IP requests/minute allowed through to the body read. Default 120. */
     ipRateLimitPerMinute?: number;
-    /** Max concurrent TCP connections the receiver accepts. Default 256. */
     maxConnections?: number;
 }
-/**
- * Start a localhost-bound receiver. It accepts only:
- *   POST /hooks/github  with X-Hub-Signature-256
- *   POST /hooks/linear  with Linear-Signature + fresh webhookTimestamp
- *   POST /hooks/slack   with X-Slack-Signature + fresh X-Slack-Request-Timestamp
- *
- * **The ack is asynchronous (RUSH-2548).** Once a delivery has passed signature
- * verification, freshness, dedup, and rate limiting, the receiver writes
- * `202 {ok:true, accepted:true}` IMMEDIATELY and dispatches the matched routines
- * and handlers afterwards. Dispatch starts an agent run and takes 15-20s, which
- * exceeds Linear's delivery timeout — holding the socket open across it made
- * every real delivery log a timeout + retry on Linear's side. Nothing about the
- * dedup ledger changes: the `<source>:<delivery-id>` key is still what makes a
- * retry a no-op, per-job `markJob` still lets a retry finish only the matches
- * that failed, and the delivery is marked complete only after it settles.
- *
- * A retry that lands WHILE the first is still settling is answered as a
- * duplicate from an in-flight set, since `deliveryStore.seen` only reports
- * completed deliveries and would otherwise let a mid-flight retry double-fire.
- *
- * `onMatch` fires as soon as matching is known, before any dispatch; `onDelivery`
- * fires only once every matched routine/handler has settled — see their docs on
- * `WebhookServerOptions`. A caller that wants a prompt "this fired" log uses
- * `onMatch`, not `onDelivery` (RUSH-2722).
- *
- * Returns the underlying server so callers can `close()` it.
- */
 export declare function startWebhookServer(options: WebhookServerOptions): http.Server;
 export {};