aoaoe 0.59.0 → 0.60.0

package/README.md

@@ -341,6 +341,7 @@ Config lives at `~/.aoaoe/aoaoe.config.json` (canonical, written by `aoaoe init`
 | `notifications.webhookUrl` | Generic webhook URL (POST JSON) | (none) |
 | `notifications.slackWebhookUrl` | Slack incoming webhook URL (block kit format) | (none) |
 | `notifications.events` | Filter which events fire (omit to send all). Valid: `session_error`, `session_done`, `action_executed`, `action_failed`, `daemon_started`, `daemon_stopped` | (all) |
+| `notifications.maxRetries` | Retry failed webhook deliveries with exponential backoff (1s, 2s, 4s, ...) | `0` (no retry) |
 
 Also reads `.aoaoe.json` as an alternative config filename.
 

package/dist/config.js

@@ -91,7 +91,7 @@ const KNOWN_KEYS = {
         "maxIdleBeforeNudgeMs", "maxErrorsBeforeRestart", "autoAnswerPermissions",
         "actionCooldownMs", "userActivityThresholdMs", "allowDestructive",
     ]),
-    notifications: new Set(["webhookUrl", "slackWebhookUrl", "events"]),
+    notifications: new Set(["webhookUrl", "slackWebhookUrl", "events", "maxRetries"]),
 };
 export function warnUnknownKeys(raw, source) {
     if (!raw || typeof raw !== "object" || Array.isArray(raw))
@@ -216,6 +216,13 @@ export function validateConfig(config) {
             }
         }
     }
+    // notifications.maxRetries must be a non-negative integer
+    if (config.notifications?.maxRetries !== undefined) {
+        const r = config.notifications.maxRetries;
+        if (typeof r !== "number" || !isFinite(r) || r < 0 || !Number.isInteger(r)) {
+            errors.push(`notifications.maxRetries must be a non-negative integer, got ${r}`);
+        }
+    }
     if (errors.length > 0) {
         throw new Error(`invalid config:\n  ${errors.join("\n  ")}`);
     }
@@ -536,7 +543,8 @@ example config:
     "notifications": {
       "webhookUrl": "https://example.com/webhook",
       "slackWebhookUrl": "https://hooks.slack.com/services/T.../B.../xxx",
-      "events": ["session_error", "session_done", "daemon_started", "daemon_stopped"]
+      "events": ["session_error", "session_done", "daemon_started", "daemon_stopped"],
+      "maxRetries": 2
     }
   }
 
@@ -546,7 +554,8 @@ example config:
 
   notifications sends webhook alerts for daemon events. Both webhookUrl
   and slackWebhookUrl are optional. events filters which events fire
-  (omit to send all). Run 'aoaoe notify-test' to verify delivery.
+  (omit to send all). maxRetries enables exponential backoff retry on
+  failure (default: 0 = no retry). Run 'aoaoe notify-test' to verify.
 
 interactive commands (while daemon is running):
   /help          show available commands

package/dist/notify.d.ts

@@ -14,6 +14,7 @@ export declare function sendTestNotification(config: AoaoeConfig): Promise<{
     webhookError?: string;
     slackError?: string;
 }>;
+export declare function fetchWithRetry(url: string, options: RequestInit, maxRetries?: number, baseDelayMs?: number): Promise<Response>;
 export declare function formatSlackPayload(payload: NotificationPayload): {
     text: string;
     blocks: object[];

package/dist/notify.js

@@ -45,12 +45,13 @@ export async function sendNotification(config, payload) {
     if (isRateLimited(payload))
         return;
     recordSent(payload);
+    const retries = n.maxRetries ?? 0;
     const promises = [];
     if (n.webhookUrl) {
-        promises.push(sendGenericWebhook(n.webhookUrl, payload));
+        promises.push(sendGenericWebhook(n.webhookUrl, payload, retries));
     }
     if (n.slackWebhookUrl) {
-        promises.push(sendSlackWebhook(n.slackWebhookUrl, payload));
+        promises.push(sendSlackWebhook(n.slackWebhookUrl, payload, retries));
     }
     // fire-and-forget — swallow all errors so the daemon never crashes on notification failure
     await Promise.allSettled(promises);
@@ -104,10 +105,34 @@ export async function sendTestNotification(config) {
     }
     return result;
 }
+// ── retry with exponential backoff ──────────────────────────────────────────
+// exported for testing. retries failed fetch calls with exponential backoff.
+// maxRetries=0 means no retry (single attempt). delay doubles each attempt.
+export async function fetchWithRetry(url, options, maxRetries = 0, baseDelayMs = 1000) {
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            const resp = await fetch(url, options);
+            if (resp.ok || attempt === maxRetries)
+                return resp;
+            // non-ok response: retry if we have attempts left
+            lastError = new Error(`HTTP ${resp.status} ${resp.statusText}`);
+        }
+        catch (err) {
+            lastError = err;
+            if (attempt === maxRetries)
+                break;
+        }
+        // exponential backoff: baseDelay * 2^attempt (1s, 2s, 4s, ...)
+        const delay = baseDelayMs * Math.pow(2, attempt);
+        await new Promise((r) => setTimeout(r, delay));
+    }
+    throw lastError;
+}
 // POST JSON payload to a generic webhook URL
-async function sendGenericWebhook(url, payload) {
+async function sendGenericWebhook(url, payload, maxRetries = 0) {
     try {
-        await fetch(url, {
+        await fetchWithRetry(url, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify({
@@ -117,22 +142,22 @@ async function sendGenericWebhook(url, payload) {
                 detail: payload.detail,
             }),
             signal: AbortSignal.timeout(5000),
-        });
+        }, maxRetries);
     }
     catch (err) {
         console.error(`[notify] generic webhook failed: ${err}`);
     }
 }
 // POST Slack block format to a Slack incoming webhook URL
-async function sendSlackWebhook(url, payload) {
+async function sendSlackWebhook(url, payload, maxRetries = 0) {
     try {
         const body = formatSlackPayload(payload);
-        await fetch(url, {
+        await fetchWithRetry(url, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify(body),
             signal: AbortSignal.timeout(5000),
-        });
+        }, maxRetries);
     }
     catch (err) {
         console.error(`[notify] slack webhook failed: ${err}`);

package/dist/types.d.ts

@@ -119,6 +119,7 @@ export interface AoaoeConfig {
         webhookUrl?: string;
         slackWebhookUrl?: string;
         events?: NotificationEvent[];
+        maxRetries?: number;
     };
     healthPort?: number;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aoaoe",
-  "version": "0.59.0",
+  "version": "0.60.0",
   "description": "Autonomous supervisor for agent-of-empires sessions using OpenCode or Claude Code",
   "type": "module",
   "main": "dist/index.js",