npm - aegis-bridge - Versions diffs - 2.5.3 → 2.5.4 - Mend

aegis-bridge 2.5.3 → 2.5.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (23) hide show

package/dashboard/dist/assets/{index-DxAes2EQ.js → index-DIyuyrlO.js} +47 -47
package/dashboard/dist/index.html +1 -1
package/dist/auth.d.ts +3 -2
package/dist/auth.js +42 -29
package/dist/channels/webhook.d.ts +2 -0
package/dist/channels/webhook.js +49 -13
package/dist/dashboard/assets/{index-DxAes2EQ.js → index-DIyuyrlO.js} +47 -47
package/dist/dashboard/index.html +1 -1
package/dist/hook-settings.js +23 -3
package/dist/jsonl-watcher.js +9 -2
package/dist/pipeline.js +10 -0
package/dist/server.js +32 -7
package/dist/session.d.ts +5 -1
package/dist/session.js +75 -20
package/dist/sse-writer.js +1 -1
package/dist/ssrf.d.ts +19 -2
package/dist/ssrf.js +38 -6
package/dist/tmux.d.ts +8 -7
package/dist/tmux.js +51 -36
package/dist/transcript.js +12 -8
package/dist/validation.d.ts +4 -0
package/dist/validation.js +3 -2
package/package.json +1 -1

package/dashboard/dist/index.html CHANGED Viewed

@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Aegis Dashboard</title>
     <link rel="icon" type="image/svg+xml" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>🛡️</text></svg>" />
-    <script type="module" crossorigin src="/dashboard/assets/index-DxAes2EQ.js"></script>
+    <script type="module" crossorigin src="/dashboard/assets/index-DIyuyrlO.js"></script>
     <link rel="stylesheet" crossorigin href="/dashboard/assets/index-B7DYf7vF.css">
   </head>
   <body class="bg-[#0a0a0f] text-gray-200 antialiased">

package/dist/auth.d.ts CHANGED Viewed

@@ -74,9 +74,10 @@ export declare class AuthManager {
     /**
      * Validate and consume a short-lived SSE token.
      * Returns true if valid (and marks it as used), false otherwise.
-     * Also cleans up expired tokens as a side effect.
+     * #826: Async with mutex to prevent concurrent validation/generation from
+     * racing on shared state (sseTokens, sseTokenCounts).
      */
-    validateSSEToken(token: string): boolean;
+    validateSSEToken(token: string): Promise<boolean>;
     /** Remove expired SSE tokens and recount per-key outstanding. */
     private cleanExpiredSSETokens;
 }

package/dist/auth.js CHANGED Viewed

@@ -107,8 +107,6 @@ export class AuthManager {
         if (!key) {
             return { valid: false, keyId: null, rateLimited: false };
         }
-        // Update last used
-        key.lastUsedAt = Date.now();
         // Rate limiting
         const bucket = this.rateLimits.get(key.id) || { count: 0, windowStart: Date.now() };
         const now = Date.now();
@@ -125,6 +123,8 @@ export class AuthManager {
         if (bucket.count > key.rateLimit) {
             return { valid: true, keyId: key.id, rateLimited: true };
         }
+        // Issue #841: Only update lastUsedAt for accepted requests, not rate-limited ones
+        key.lastUsedAt = Date.now();
         return { valid: true, keyId: key.id, rateLimited: false };
     }
     /** Hash a key with SHA-256. */
@@ -199,37 +199,50 @@ export class AuthManager {
     /**
      * Validate and consume a short-lived SSE token.
      * Returns true if valid (and marks it as used), false otherwise.
-     * Also cleans up expired tokens as a side effect.
+     * #826: Async with mutex to prevent concurrent validation/generation from
+     * racing on shared state (sseTokens, sseTokenCounts).
      */
-    validateSSEToken(token) {
-        const entry = this.sseTokens.get(token);
-        if (!entry)
-            return false;
-        // Already used
-        if (entry.used) {
-            this.sseTokens.delete(token);
-            return false;
-        }
-        // Expired
-        if (Date.now() > entry.expiresAt) {
-            this.sseTokens.delete(token);
-            return false;
-        }
-        // Valid — consume it
-        entry.used = true;
-        const keyId = entry.keyId;
-        this.sseTokens.delete(token);
-        // #357: Decrement outstanding count so generateSSEToken doesn't over-limit
-        const count = this.sseTokenCounts.get(keyId);
-        if (count !== undefined) {
-            if (count <= 1) {
-                this.sseTokenCounts.delete(keyId);
+    async validateSSEToken(token) {
+        // Acquire mutex — chain onto the previous operation
+        let release = () => { };
+        const lock = new Promise((resolve) => { release = resolve; });
+        const previous = this.sseMutex;
+        this.sseMutex = lock;
+        // #573: catch prior rejection so it doesn't propagate and block subsequent callers
+        try {
+            await previous.catch(() => { });
+            const entry = this.sseTokens.get(token);
+            if (!entry)
+                return false;
+            // Already used
+            if (entry.used) {
+                this.sseTokens.delete(token);
+                return false;
             }
-            else {
-                this.sseTokenCounts.set(keyId, count - 1);
+            // Expired
+            if (Date.now() > entry.expiresAt) {
+                this.sseTokens.delete(token);
+                return false;
             }
+            // Valid — consume it
+            entry.used = true;
+            const keyId = entry.keyId;
+            this.sseTokens.delete(token);
+            // #357: Decrement outstanding count so generateSSEToken doesn't over-limit
+            const count = this.sseTokenCounts.get(keyId);
+            if (count !== undefined) {
+                if (count <= 1) {
+                    this.sseTokenCounts.delete(keyId);
+                }
+                else {
+                    this.sseTokenCounts.set(keyId, count - 1);
+                }
+            }
+            return true;
+        }
+        finally {
+            release();
         }
-        return true;
     }
     /** Remove expired SSE tokens and recount per-key outstanding. */
     cleanExpiredSSETokens() {

package/dist/channels/webhook.d.ts CHANGED Viewed

@@ -46,6 +46,8 @@ export declare class WebhookChannel implements Channel {
     static readonly BASE_DELAY_MS = 1000;
     /** Exponential backoff with jitter: delay * (0.5 + Math.random() * 0.5). */
     static backoff(attempt: number): number;
+    /** Redact sensitive session metadata from webhook payloads. */
+    private static redactPayload;
     private fire;
     /** Issue #25: Deliver webhook with retry + exponential backoff. */
     private deliverWithRetry;

package/dist/channels/webhook.js CHANGED Viewed

@@ -5,7 +5,7 @@
  * Configure via AEGIS_WEBHOOKS (or legacy MANUS_WEBHOOKS) env var or config file.
  */
 import { webhookEndpointSchema, getErrorMessage } from '../validation.js';
-import { validateWebhookUrl } from '../ssrf.js';
+import { validateWebhookUrl, resolveAndCheckIp, buildConnectionUrl } from '../ssrf.js';
 import { redactSecretsFromText } from '../utils/redact-headers.js';
 import { RetriableError } from './manager.js';
 export class WebhookChannel {
@@ -73,15 +73,25 @@ export class WebhookChannel {
         const base = WebhookChannel.BASE_DELAY_MS * Math.pow(2, attempt - 1);
         return base * (0.5 + Math.random() * 0.5);
     }
-    async fire(payload) {
-        const body = JSON.stringify({
-            ...payload,
+    /** Redact sensitive session metadata from webhook payloads. */
+    static redactPayload(payload) {
+        const { session, ...rest } = payload;
+        return {
+            ...rest,
+            session: {
+                id: '[REDACTED]',
+                name: '[REDACTED]',
+                workDir: '[REDACTED]',
+            },
             api: {
-                read: `GET /sessions/${payload.session.id}/read`,
-                send: `POST /sessions/${payload.session.id}/send`,
-                kill: `DELETE /sessions/${payload.session.id}`,
+                read: 'GET /sessions/[REDACTED]/read',
+                send: 'POST /sessions/[REDACTED]/send',
+                kill: 'DELETE /sessions/[REDACTED]',
             },
-        });
+        };
+    }
+    async fire(payload) {
+        const body = JSON.stringify(WebhookChannel.redactPayload(payload));
         const promises = this.endpoints.map(async (ep) => {
             // Skip if endpoint filters and this event isn't in the list
             if (ep.events && ep.events.length > 0 && !ep.events.includes(payload.event))
@@ -104,14 +114,40 @@ export class WebhookChannel {
     /** Issue #25: Deliver webhook with retry + exponential backoff. */
     async deliverWithRetry(ep, body, event, maxRetries = WebhookChannel.MAX_RETRIES) {
         let lastError = '';
+        const hostname = new URL(ep.url).hostname;
+        const bareHost = hostname.replace(/^\[|\]$/g, '');
         for (let attempt = 1; attempt <= maxRetries; attempt++) {
             try {
-                const res = await fetch(ep.url, {
+                // DNS rebinding protection: resolve and validate IP before each fetch.
+                // Skip for literal IPs (already validated at config time).
+                let fetchUrl = ep.url;
+                let headers = {
+                    'Content-Type': 'application/json',
+                    ...(ep.headers || {}),
+                };
+                if (bareHost !== '127.0.0.1' && bareHost !== '::1' && bareHost !== 'localhost') {
+                    const dnsResult = await resolveAndCheckIp(bareHost);
+                    if (dnsResult.error) {
+                        lastError = dnsResult.error;
+                        if (attempt < maxRetries) {
+                            const delay = WebhookChannel.backoff(attempt);
+                            console.warn(`Webhook ${ep.url} DNS check failed for ${event} (attempt ${attempt}/${maxRetries}): ${lastError}, retrying in ${Math.round(delay)}ms`);
+                            await new Promise(r => setTimeout(r, delay));
+                            continue;
+                        }
+                        console.error(`Webhook ${ep.url} DNS check failed after ${maxRetries} attempts for ${event}: ${lastError}`);
+                        this.addToDeadLetterQueue(ep.url, event, lastError, maxRetries);
+                        throw new RetriableError(lastError);
+                    }
+                    if (dnsResult.resolvedIp) {
+                        const { connectionUrl, hostHeader } = buildConnectionUrl(ep.url, dnsResult.resolvedIp);
+                        fetchUrl = connectionUrl;
+                        headers['Host'] = hostHeader;
+                    }
+                }
+                const res = await fetch(fetchUrl, {
                     method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        ...(ep.headers || {}),
-                    },
+                    headers,
                     body,
                     signal: AbortSignal.timeout(ep.timeoutMs || 5000),
                 });