@phnx-labs/agents-cli 1.22.40 → 1.22.41

package/dist/lib/triggers/webhook.js

@@ -264,6 +264,76 @@ export function verifyLinearTimestamp(payload, now = Date.now(), toleranceMs = 6
     const ts = payload.webhookTimestamp;
     return typeof ts === 'number' && Math.abs(now - ts) <= toleranceMs;
 }
+/**
+ * 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 function verifySlackSignature(headers, rawBody, secret, now = Date.now(), toleranceSec = 300) {
+    const ts = header(headers, 'x-slack-request-timestamp');
+    if (!ts || !/^\d+$/.test(ts))
+        return false;
+    if (Math.abs(Math.floor(now / 1000) - Number(ts)) > toleranceSec)
+        return false;
+    const received = header(headers, 'x-slack-signature');
+    const signature = received?.startsWith('v0=') ? received.slice('v0='.length) : undefined;
+    // Concatenate the base-string prefix with the raw body bytes so a non-ASCII
+    // payload hashes identically to Slack's own `v0:${ts}:${body}` string.
+    const base = Buffer.concat([Buffer.from(`v0:${ts}:`, 'utf-8'), rawBody]);
+    const expected = crypto.createHmac('sha256', secret).update(base).digest('hex');
+    return timingSafeHexEqual(signature, expected);
+}
+/**
+ * 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 function parseSlackBody(contentType, rawBody) {
+    if ((contentType ?? '').includes('application/x-www-form-urlencoded')) {
+        const form = new URLSearchParams(rawBody.toString('utf-8'));
+        // A slash command carries no thread; its reply posts to the channel.
+        return {
+            type: 'slash_command',
+            command: form.get('command') ?? undefined,
+            text: form.get('text') ?? undefined,
+            channel: form.get('channel_id') ?? undefined,
+            user: form.get('user_id') ?? undefined,
+            response_url: form.get('response_url') ?? undefined,
+            team: form.get('team_id') ?? undefined,
+        };
+    }
+    const json = rawBody.length > 0 ? JSON.parse(rawBody.toString('utf-8')) : {};
+    const type = String(json.type ?? '');
+    if (type === 'url_verification') {
+        return { type, challenge: typeof json.challenge === 'string' ? json.challenge : '' };
+    }
+    const event = (json.event ?? {});
+    return {
+        type: type || 'event_callback',
+        event_id: typeof json.event_id === 'string' ? json.event_id : undefined,
+        event_type: typeof event.type === 'string' ? event.type : undefined,
+        text: typeof event.text === 'string' ? event.text : undefined,
+        channel: typeof event.channel === 'string' ? event.channel : undefined,
+        thread_ts: typeof event.thread_ts === 'string'
+            ? event.thread_ts
+            : typeof event.ts === 'string'
+                ? event.ts
+                : undefined,
+        user: typeof event.user === 'string' ? event.user : undefined,
+        team: typeof json.team_id === 'string' ? json.team_id : undefined,
+    };
+}
+/** The `event` name a Slack delivery fires under: the slash command, or the event subtype. */
+export function slackEventName(payload) {
+    if (payload.type === 'slash_command')
+        return payload.command ?? 'slash_command';
+    return payload.event_type ?? payload.type;
+}
 export function createMemoryDeliveryStore(maxEntries = 1000) {
     const seen = new Map();
     const touch = (id) => {
@@ -405,7 +475,7 @@ function deliveryId(source, headers, rawBody) {
     return `${source}:${named ?? crypto.createHash('sha256').update(rawBody).digest('hex')}`;
 }
 function sourceFromPath(pathname) {
-    const match = /^\/hooks\/(github|linear)\/?$/.exec(pathname ?? '');
+    const match = /^\/hooks\/(github|linear|slack)\/?$/.exec(pathname ?? '');
     return match ? match[1] : null;
 }
 async function readRawBody(req, maxBytes) {
@@ -461,6 +531,11 @@ export function waitForListening(server) {
  * 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 function startWebhookServer(options) {
@@ -482,8 +557,17 @@ export function startWebhookServer(options) {
         try {
             const context = buildWebhookContext(webhook);
             const fireOptions = options.fire ?? {};
+            // Match FIRST, before any dispatch — matching is a pure in-memory lookup,
+            // so this is the earliest point the receiver knows what fired, and the
+            // right time to log it (RUSH-2722). Dispatching a `run.command` handler
+            // can then block on the shelled-out process for minutes; that must never
+            // hold the "fired" log back with it.
+            const matchedJobs = matchJobsToWebhook(fireOptions.jobs ?? listJobs(), webhook);
+            const matchedHandlers = listHandlers().filter((handler) => handlerMatchesWebhook(handler, webhook));
+            options.onMatch?.(webhook, matchedJobs.map((job) => job.name), matchedHandlers.map((handler) => handler.name));
             const firedJobs = await fireWebhookJobs(webhook, {
                 ...fireOptions,
+                jobs: matchedJobs,
                 context,
                 skipJobNames: deliveryStore.completedJobs(id),
                 onJobFired: (job, firedJob) => {
@@ -492,7 +576,6 @@ export function startWebhookServer(options) {
                     fireOptions.onJobFired?.(job, firedJob);
                 },
             });
-            const matchedHandlers = listHandlers().filter((handler) => handlerMatchesWebhook(handler, webhook));
             const firedHandlers = [];
             const handlerErrors = [];
             await Promise.allSettled(matchedHandlers.map(async (handler) => {
@@ -563,13 +646,54 @@ export function startWebhookServer(options) {
                 const rawBody = await readRawBody(req, maxBodyBytes);
                 const valid = source === 'github'
                     ? verifyGithubSignature(req.headers, rawBody, secret)
-                    : verifyLinearSignature(req.headers, rawBody, secret);
+                    : source === 'linear'
+                        ? verifyLinearSignature(req.headers, rawBody, secret)
+                        : verifySlackSignature(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;
                 }
+                // Slack diverges from the GitHub/Linear JSON path: two content-types
+                // (slash = form, events = JSON), a one-time url_verification handshake,
+                // a body-carried event id, and a 200 ack Slack shows to the caller.
+                if (source === 'slack') {
+                    const slack = parseSlackBody(header(req.headers, 'content-type'), rawBody);
+                    // One-time Events API URL handshake: echo the challenge, dispatch nothing.
+                    if (slack.type === 'url_verification') {
+                        res.writeHead(200, { 'content-type': 'application/json' });
+                        res.end(JSON.stringify({ challenge: slack.challenge ?? '' }));
+                        return;
+                    }
+                    const slackEvent = slackEventName(slack);
+                    // Slash commands carry no event_id, so fall back to a body hash for dedup.
+                    const slackId = `slack:${slack.event_id ?? crypto.createHash('sha256').update(rawBody).digest('hex')}`;
+                    emit('webhook.received', { source, event: slackEvent, deliveryId: slackId });
+                    if (deliveryStore.seen(slackId) || inFlight.has(slackId)) {
+                        res.writeHead(200, { 'content-type': 'application/json' });
+                        res.end(JSON.stringify({ ok: true, duplicate: true }));
+                        return;
+                    }
+                    if (!rateLimiter.take(source)) {
+                        emit('webhook.rejected', { source, event: slackEvent, deliveryId: slackId, reason: 'rate limit exceeded' });
+                        res.writeHead(429, { 'content-type': 'application/json' });
+                        res.end(JSON.stringify({ ok: false, error: 'rate limit exceeded' }));
+                        return;
+                    }
+                    const slackWebhook = { source, event: slackEvent, payload: slack };
+                    emit('webhook.authorized', { source, event: slackEvent, deliveryId: slackId });
+                    // ACK FIRST (RUSH-2548): a 200 inside Slack's 3s window. A slash
+                    // command renders the ack text to the caller; an event delivery
+                    // ignores the body. Dispatch outlives the ack, same as GitHub/Linear.
+                    inFlight.add(slackId);
+                    res.writeHead(200, { 'content-type': 'application/json' });
+                    res.end(slack.type === 'slash_command'
+                        ? JSON.stringify({ response_type: 'ephemeral', text: 'On it — replying in this thread.' })
+                        : '');
+                    void settleDelivery(slackWebhook, slackId).finally(() => inFlight.delete(slackId));
+                    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 });

package/dist/lib/types.d.ts

@@ -1110,7 +1110,7 @@ export interface HostEntry {
 /** Browser profile definition stored in agents.yaml. */
 export interface BrowserProfileConfig {
     description?: string;
-    browser: 'chrome' | 'comet' | 'chromium' | 'brave' | 'edge' | 'custom';
+    browser: 'chrome' | 'comet' | 'chromium' | 'brave' | 'edge' | 'arc' | 'custom';
     binary?: string;
     electron?: boolean;
     /**

package/dist/lib/wrap.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Terminal word-wrap — one shared helper for the whole CLI.
+ *
+ * Multi-line word wrapping is the gap the single-line helpers in
+ * `session/width.ts` (`truncateToWidth`, `padToWidth`) do not fill. Anywhere that
+ * renders variable-length text into a fixed-width terminal wraps through THIS,
+ * never a per-field slice.
+ *
+ * Width is measured with `stringWidth` (from the canonical `session/width.ts`),
+ * NOT `String.length`: the text this wraps is routinely ANSI-coloured (chalk /
+ * marked-terminal output) and may carry OSC-8 hyperlinks, where `.length`
+ * over-counts the invisible escape bytes. Words are split on whitespace, so a
+ * wrap boundary always falls between escape sequences, never inside one.
+ */
+/**
+ * Hard-wrap `text` to `cols` visible columns.
+ *
+ * - Splits on existing newlines first (each paragraph wraps independently).
+ * - Wraps on whitespace; a single word wider than the available width is emitted
+ *   on its own line rather than split mid-word (and never mid-escape).
+ * - Width is the visible display width via `stringWidth`, so ANSI colour and
+ *   OSC-8 hyperlink escapes do not inflate the count.
+ * - `hangingIndent` pads every line AFTER the first with that many spaces, so a
+ *   labelled value ("Latest  <text>") keeps its continuation lines aligned under
+ *   the value. The wrapping width is `cols - indent`.
+ * - Floor: when `hangingIndent` is set, the width is floored at 8 so a
+ *   pathologically large indent still makes forward progress. With no indent the
+ *   floor is 1, so a legitimately small `cols` is respected, never overridden. A
+ *   non-finite `cols` degrades to the floor rather than silently disabling wrap.
+ *
+ * Returns the wrapped lines (never mutates input). An empty string yields [''].
+ */
+export declare function wrapToWidth(text: string, cols: number, hangingIndent?: number): string[];

package/dist/lib/wrap.js

@@ -0,0 +1,70 @@
+/**
+ * Terminal word-wrap — one shared helper for the whole CLI.
+ *
+ * Multi-line word wrapping is the gap the single-line helpers in
+ * `session/width.ts` (`truncateToWidth`, `padToWidth`) do not fill. Anywhere that
+ * renders variable-length text into a fixed-width terminal wraps through THIS,
+ * never a per-field slice.
+ *
+ * Width is measured with `stringWidth` (from the canonical `session/width.ts`),
+ * NOT `String.length`: the text this wraps is routinely ANSI-coloured (chalk /
+ * marked-terminal output) and may carry OSC-8 hyperlinks, where `.length`
+ * over-counts the invisible escape bytes. Words are split on whitespace, so a
+ * wrap boundary always falls between escape sequences, never inside one.
+ */
+import { stringWidth } from './session/width.js';
+/**
+ * Hard-wrap `text` to `cols` visible columns.
+ *
+ * - Splits on existing newlines first (each paragraph wraps independently).
+ * - Wraps on whitespace; a single word wider than the available width is emitted
+ *   on its own line rather than split mid-word (and never mid-escape).
+ * - Width is the visible display width via `stringWidth`, so ANSI colour and
+ *   OSC-8 hyperlink escapes do not inflate the count.
+ * - `hangingIndent` pads every line AFTER the first with that many spaces, so a
+ *   labelled value ("Latest  <text>") keeps its continuation lines aligned under
+ *   the value. The wrapping width is `cols - indent`.
+ * - Floor: when `hangingIndent` is set, the width is floored at 8 so a
+ *   pathologically large indent still makes forward progress. With no indent the
+ *   floor is 1, so a legitimately small `cols` is respected, never overridden. A
+ *   non-finite `cols` degrades to the floor rather than silently disabling wrap.
+ *
+ * Returns the wrapped lines (never mutates input). An empty string yields [''].
+ */
+export function wrapToWidth(text, cols, hangingIndent = 0) {
+    const indent = Math.max(0, Math.trunc(hangingIndent));
+    const floor = indent > 0 ? 8 : 1;
+    const width = Number.isFinite(cols) ? Math.max(floor, cols - indent) : floor;
+    const pad = ' '.repeat(indent);
+    const out = [];
+    for (const para of String(text).split('\n')) {
+        const words = para.split(/\s+/).filter(w => w.length > 0);
+        if (words.length === 0) {
+            out.push('');
+            continue;
+        }
+        let line = '';
+        let lineWidth = 0;
+        for (const word of words) {
+            const wordWidth = stringWidth(word);
+            if (line === '') {
+                line = word;
+                lineWidth = wordWidth;
+            }
+            else if (lineWidth + 1 + wordWidth > width) {
+                out.push(line);
+                line = word;
+                lineWidth = wordWidth;
+            }
+            else {
+                line = `${line} ${word}`;
+                lineWidth += 1 + wordWidth;
+            }
+        }
+        if (line !== '')
+            out.push(line);
+    }
+    if (out.length === 0)
+        out.push('');
+    return out.map((l, i) => (i === 0 ? l : pad + l));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.22.40",
+  "version": "1.22.41",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",