aoaoe 0.59.0 → 0.61.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.
 
@@ -496,6 +497,7 @@ src/
   dashboard.ts      # periodic CLI status table with task column
   daemon-state.ts   # shared IPC state file + interrupt flag
   tui.ts            # in-place terminal UI (alternate screen, scroll regions)
+  tui-history.ts    # persisted TUI history (JSONL file with rotation, replay on startup)
   input.ts          # stdin readline listener with inject() for post-interrupt
   init.ts           # `aoaoe init`: auto-discover tools, sessions, generate config
   notify.ts         # webhook + Slack notification dispatcher for daemon events

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/index.js

@@ -19,6 +19,7 @@ import { TUI } from "./tui.js";
 import { isDaemonRunningFromState } from "./chat.js";
 import { sendNotification, sendTestNotification } from "./notify.js";
 import { startHealthServer } from "./health.js";
+import { loadTuiHistory } from "./tui-history.js";
 import { actionSession, actionDetail, toActionLogEntry } from "./types.js";
 import { YELLOW, GREEN, DIM, BOLD, RED, RESET } from "./colors.js";
 import { readFileSync, existsSync, statSync, mkdirSync, writeFileSync, chmodSync } from "node:fs";
@@ -230,6 +231,10 @@ async function main() {
     await reasonerConsole.start();
     // start TUI (alternate screen buffer) after input is ready
     if (tui) {
+        // replay persisted history from previous runs before entering alt screen
+        const history = loadTuiHistory();
+        if (history.length > 0)
+            tui.replayHistory(history);
         tui.start(pkg || "dev");
         tui.updateState({ reasonerName: config.observe ? "observe-only" : config.reasoner });
         // welcome banner — plain-English explanation of what's happening

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/tui-history.d.ts

@@ -0,0 +1,27 @@
+/** JSONL entry format — extends ActivityEntry with epoch timestamp for filtering */
+export interface HistoryEntry {
+    ts: number;
+    time: string;
+    tag: string;
+    text: string;
+}
+/**
+ * Append a single history entry to the JSONL file.
+ * Fire-and-forget — errors are silently swallowed so they never block the TUI.
+ * Rotates the file if it exceeds MAX_FILE_SIZE before appending.
+ */
+export declare function appendHistoryEntry(entry: HistoryEntry, filePath?: string, maxSize?: number): void;
+/**
+ * Load recent TUI history entries from the JSONL file.
+ * Returns the last `maxEntries` entries (default 200), newest last.
+ * Returns empty array if the file doesn't exist or is unreadable.
+ */
+export declare function loadTuiHistory(maxEntries?: number, filePath?: string): HistoryEntry[];
+/**
+ * Rotate the history file if it exceeds the size threshold.
+ * Renames current file to .old (overwriting any previous .old) and starts fresh.
+ */
+export declare function rotateTuiHistory(filePath?: string, maxSize?: number): boolean;
+/** Default history file path (for wiring in index.ts) */
+export declare const TUI_HISTORY_FILE: string;
+//# sourceMappingURL=tui-history.d.ts.map

package/dist/tui-history.js

@@ -0,0 +1,89 @@
+// tui-history.ts — persisted TUI activity history
+// JSONL file at ~/.aoaoe/tui-history.jsonl with rotation at 500KB.
+// pure exported functions for testability — no classes, no singletons.
+import { appendFileSync, readFileSync, renameSync, statSync, mkdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const AOAOE_DIR = join(homedir(), ".aoaoe");
+const HISTORY_FILE = join(AOAOE_DIR, "tui-history.jsonl");
+const HISTORY_OLD = join(AOAOE_DIR, "tui-history.jsonl.old");
+const MAX_FILE_SIZE = 500 * 1024; // 500KB rotation threshold
+/**
+ * Append a single history entry to the JSONL file.
+ * Fire-and-forget — errors are silently swallowed so they never block the TUI.
+ * Rotates the file if it exceeds MAX_FILE_SIZE before appending.
+ */
+export function appendHistoryEntry(entry, filePath = HISTORY_FILE, maxSize = MAX_FILE_SIZE) {
+    try {
+        const dir = join(filePath, "..");
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        rotateTuiHistory(filePath, maxSize);
+        const line = JSON.stringify(entry) + "\n";
+        appendFileSync(filePath, line, "utf-8");
+    }
+    catch {
+        // fire-and-forget — never crash the daemon over history persistence
+    }
+}
+/**
+ * Load recent TUI history entries from the JSONL file.
+ * Returns the last `maxEntries` entries (default 200), newest last.
+ * Returns empty array if the file doesn't exist or is unreadable.
+ */
+export function loadTuiHistory(maxEntries = 200, filePath = HISTORY_FILE) {
+    try {
+        if (!existsSync(filePath))
+            return [];
+        const content = readFileSync(filePath, "utf-8");
+        const lines = content.split("\n").filter((l) => l.trim());
+        const recent = lines.slice(-maxEntries);
+        const entries = [];
+        for (const line of recent) {
+            try {
+                const parsed = JSON.parse(line);
+                if (isValidEntry(parsed))
+                    entries.push(parsed);
+            }
+            catch {
+                // skip malformed lines
+            }
+        }
+        return entries;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Rotate the history file if it exceeds the size threshold.
+ * Renames current file to .old (overwriting any previous .old) and starts fresh.
+ */
+export function rotateTuiHistory(filePath = HISTORY_FILE, maxSize = MAX_FILE_SIZE) {
+    try {
+        if (!existsSync(filePath))
+            return false;
+        const size = statSync(filePath).size;
+        if (size < maxSize)
+            return false;
+        const oldPath = filePath + ".old";
+        renameSync(filePath, oldPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Validate that a parsed JSON value has the shape of a HistoryEntry */
+function isValidEntry(val) {
+    if (typeof val !== "object" || val === null)
+        return false;
+    const obj = val;
+    return (typeof obj.ts === "number" &&
+        typeof obj.time === "string" &&
+        typeof obj.tag === "string" &&
+        typeof obj.text === "string");
+}
+/** Default history file path (for wiring in index.ts) */
+export const TUI_HISTORY_FILE = HISTORY_FILE;
+//# sourceMappingURL=tui-history.js.map

package/dist/tui.d.ts

@@ -1,4 +1,5 @@
 import type { DaemonSessionState, DaemonPhase } from "./types.js";
+import type { HistoryEntry } from "./tui-history.js";
 declare function phaseDisplay(phase: DaemonPhase, paused: boolean, spinnerFrame: number): string;
 export interface ActivityEntry {
     time: string;
@@ -38,6 +39,7 @@ export declare class TUI {
         nextTickAt?: number;
     }): void;
     log(tag: string, text: string): void;
+    replayHistory(entries: HistoryEntry[]): void;
     private updateDimensions;
     private computeLayout;
     private onResize;

package/dist/tui.js

@@ -1,4 +1,5 @@
 import { BOLD, DIM, RESET, GREEN, CYAN, WHITE, BG_DARK, INDIGO, TEAL, AMBER, SLATE, ROSE, LIME, SKY, BOX, SPINNER, DOT, } from "./colors.js";
+import { appendHistoryEntry } from "./tui-history.js";
 // ── ANSI helpers ────────────────────────────────────────────────────────────
 const ESC = "\x1b";
 const CSI = `${ESC}[`;
@@ -140,6 +141,19 @@ export class TUI {
         }
         if (this.active)
             this.writeActivityLine(entry);
+        // persist to disk (fire-and-forget, never blocks)
+        appendHistoryEntry({ ts: now.getTime(), time, tag, text });
+    }
+    // populate activity buffer from persisted history before start()
+    // entries are loaded from the JSONL file and added to the in-memory buffer
+    replayHistory(entries) {
+        for (const e of entries) {
+            this.activityBuffer.push({ time: e.time, tag: e.tag, text: e.text });
+        }
+        // trim to max
+        if (this.activityBuffer.length > this.maxActivity) {
+            this.activityBuffer = this.activityBuffer.slice(-this.maxActivity);
+        }
     }
     // ── Layout computation ──────────────────────────────────────────────────
     updateDimensions() {

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.61.0",
   "description": "Autonomous supervisor for agent-of-empires sessions using OpenCode or Claude Code",
   "type": "module",
   "main": "dist/index.js",