aoaoe 0.51.0 → 0.52.0

package/dist/config.js

@@ -91,6 +91,7 @@ const KNOWN_KEYS = {
         "maxIdleBeforeNudgeMs", "maxErrorsBeforeRestart", "autoAnswerPermissions",
         "actionCooldownMs", "userActivityThresholdMs", "allowDestructive",
     ]),
+    notifications: new Set(["webhookUrl", "slackWebhookUrl", "events"]),
 };
 export function warnUnknownKeys(raw, source) {
     if (!raw || typeof raw !== "object" || Array.isArray(raw))
@@ -182,6 +183,34 @@ export function validateConfig(config) {
     if (config.policies?.allowDestructive !== undefined && typeof config.policies.allowDestructive !== "boolean") {
         errors.push(`policies.allowDestructive must be a boolean, got ${typeof config.policies.allowDestructive}`);
     }
+    // notifications.webhookUrl must be a string starting with http:// or https://
+    if (config.notifications?.webhookUrl !== undefined) {
+        const u = config.notifications.webhookUrl;
+        if (typeof u !== "string" || (!u.startsWith("http://") && !u.startsWith("https://"))) {
+            errors.push(`notifications.webhookUrl must be a URL starting with http:// or https://, got ${JSON.stringify(u)}`);
+        }
+    }
+    // notifications.slackWebhookUrl must be a string starting with http:// or https://
+    if (config.notifications?.slackWebhookUrl !== undefined) {
+        const u = config.notifications.slackWebhookUrl;
+        if (typeof u !== "string" || (!u.startsWith("http://") && !u.startsWith("https://"))) {
+            errors.push(`notifications.slackWebhookUrl must be a URL starting with http:// or https://, got ${JSON.stringify(u)}`);
+        }
+    }
+    // notifications.events must be an array of valid NotificationEvent values
+    if (config.notifications?.events !== undefined) {
+        const VALID_EVENTS = new Set(["session_error", "session_done", "action_executed", "action_failed", "daemon_started", "daemon_stopped"]);
+        if (!Array.isArray(config.notifications.events)) {
+            errors.push(`notifications.events must be an array, got ${typeof config.notifications.events}`);
+        }
+        else {
+            for (const e of config.notifications.events) {
+                if (!VALID_EVENTS.has(e)) {
+                    errors.push(`notifications.events contains invalid event "${e}"`);
+                }
+            }
+        }
+    }
     if (errors.length > 0) {
         throw new Error(`invalid config:\n  ${errors.join("\n  ")}`);
     }

package/dist/index.js

@@ -17,6 +17,7 @@ import { TaskManager, loadTaskDefinitions, loadTaskState, formatTaskTable } from
 import { runTaskCli, handleTaskSlashCommand } from "./task-cli.js";
 import { TUI } from "./tui.js";
 import { isDaemonRunningFromState } from "./chat.js";
+import { sendNotification } from "./notify.js";
 import { actionSession, actionDetail } from "./types.js";
 import { YELLOW, GREEN, DIM, BOLD, RED, RESET } from "./colors.js";
 import { readFileSync, existsSync, statSync, mkdirSync, writeFileSync, chmodSync } from "node:fs";
@@ -284,6 +285,8 @@ async function main() {
             console.error(`  mode:       dry-run (no execution)`);
         console.error("");
         log("shutting down...");
+        // notify: daemon stopped (fire-and-forget, don't block shutdown)
+        sendNotification(config, { event: "daemon_stopped", timestamp: Date.now(), detail: `polls: ${totalPolls}, actions: ${totalActionsExecuted}` });
         input.stop();
         Promise.resolve()
             .then(() => reasonerConsole.stop())
@@ -307,6 +310,8 @@ async function main() {
     else {
         log("entering main loop (Ctrl+C to stop)\n");
     }
+    // notify: daemon started
+    sendNotification(config, { event: "daemon_started", timestamp: Date.now(), detail: `reasoner: ${config.reasoner}` });
     // clear any stale interrupt from a previous run
     clearInterrupt();
     // auto-explain: on the very first tick with sessions, inject an explain prompt
@@ -680,6 +685,19 @@ async function daemonTick(config, poller, reasoner, executor, reasonerConsole, p
             }
         }
     }
+    // notify: session error/done events (fires for both TUI and non-TUI modes)
+    {
+        const changedSet = new Set(observation.changes.map((c) => c.title));
+        for (const snap of observation.sessions) {
+            const s = snap.session;
+            if (s.status === "error" && changedSet.has(s.title)) {
+                sendNotification(config, { event: "session_error", timestamp: Date.now(), session: s.title, detail: `status: ${s.status}` });
+            }
+            if (s.status === "done" && changedSet.has(s.title)) {
+                sendNotification(config, { event: "session_done", timestamp: Date.now(), session: s.title });
+            }
+        }
+    }
     if (skippedReason === "no changes") {
         if (config.verbose) {
             if (tui)
@@ -750,6 +768,13 @@ async function daemonTick(config, poller, reasoner, executor, reasonerConsole, p
             log(`[${icon}] ${displayText}`);
         }
         reasonerConsole.writeAction(entry.action.action, richDetail, entry.success);
+        // notify: action executed or failed
+        sendNotification(config, {
+            event: entry.success ? "action_executed" : "action_failed",
+            timestamp: Date.now(),
+            session: sessionTitle,
+            detail: `${entry.action.action}${actionText ? `: ${actionText.slice(0, 200)}` : ""}`,
+        });
     }
     const actionsOk = executed.filter((e) => e.success && e.action.action !== "wait").length;
     const actionsFail = executed.filter((e) => !e.success && e.action.action !== "wait").length;

package/dist/notify.d.ts

@@ -0,0 +1,13 @@
+import type { AoaoeConfig, NotificationEvent } from "./types.js";
+export interface NotificationPayload {
+    event: NotificationEvent;
+    timestamp: number;
+    session?: string;
+    detail?: string;
+}
+export declare function sendNotification(config: AoaoeConfig, payload: NotificationPayload): Promise<void>;
+export declare function formatSlackPayload(payload: NotificationPayload): {
+    text: string;
+    blocks: object[];
+};
+//# sourceMappingURL=notify.d.ts.map

package/dist/notify.js

@@ -0,0 +1,104 @@
+// send a notification to all configured webhooks.
+// fire-and-forget: never throws, never blocks the daemon.
+export async function sendNotification(config, payload) {
+    const n = config.notifications;
+    if (!n)
+        return;
+    // filter: only send if event is in the configured list (or no filter = send all)
+    if (n.events && n.events.length > 0 && !n.events.includes(payload.event))
+        return;
+    const promises = [];
+    if (n.webhookUrl) {
+        promises.push(sendGenericWebhook(n.webhookUrl, payload));
+    }
+    if (n.slackWebhookUrl) {
+        promises.push(sendSlackWebhook(n.slackWebhookUrl, payload));
+    }
+    // fire-and-forget — swallow all errors so the daemon never crashes on notification failure
+    await Promise.allSettled(promises);
+}
+// POST JSON payload to a generic webhook URL
+async function sendGenericWebhook(url, payload) {
+    try {
+        await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                event: payload.event,
+                timestamp: payload.timestamp,
+                session: payload.session,
+                detail: payload.detail,
+            }),
+            signal: AbortSignal.timeout(5000),
+        });
+    }
+    catch (err) {
+        console.error(`[notify] generic webhook failed: ${err}`);
+    }
+}
+// POST Slack block format to a Slack incoming webhook URL
+async function sendSlackWebhook(url, payload) {
+    try {
+        const body = formatSlackPayload(payload);
+        await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(5000),
+        });
+    }
+    catch (err) {
+        console.error(`[notify] slack webhook failed: ${err}`);
+    }
+}
+// format a notification payload into Slack block kit format.
+// exported for testing.
+export function formatSlackPayload(payload) {
+    const icon = eventIcon(payload.event);
+    const title = eventTitle(payload.event);
+    const fallbackText = payload.session
+        ? `${icon} ${title}: ${payload.session}${payload.detail ? ` — ${payload.detail}` : ""}`
+        : `${icon} ${title}${payload.detail ? ` — ${payload.detail}` : ""}`;
+    const blocks = [
+        {
+            type: "section",
+            text: {
+                type: "mrkdwn",
+                text: `*${icon} ${title}*${payload.session ? `\n*Session:* ${payload.session}` : ""}${payload.detail ? `\n${payload.detail}` : ""}`,
+            },
+        },
+        {
+            type: "context",
+            elements: [
+                {
+                    type: "mrkdwn",
+                    text: `aoaoe | ${new Date(payload.timestamp).toISOString()}`,
+                },
+            ],
+        },
+    ];
+    return { text: fallbackText, blocks };
+}
+// human-readable title for each event type
+function eventTitle(event) {
+    switch (event) {
+        case "session_error": return "Session Error";
+        case "session_done": return "Session Done";
+        case "action_executed": return "Action Executed";
+        case "action_failed": return "Action Failed";
+        case "daemon_started": return "Daemon Started";
+        case "daemon_stopped": return "Daemon Stopped";
+    }
+}
+// emoji icon for each event type (used in Slack messages)
+function eventIcon(event) {
+    switch (event) {
+        case "session_error": return "\u{1F6A8}"; // 🚨
+        case "session_done": return "\u2705"; // ✅
+        case "action_executed": return "\u2699\uFE0F"; // ⚙️
+        case "action_failed": return "\u274C"; // ❌
+        case "daemon_started": return "\u{1F680}"; // 🚀
+        case "daemon_stopped": return "\u{1F6D1}"; // 🛑
+    }
+}
+//# sourceMappingURL=notify.js.map

package/dist/types.d.ts

@@ -115,7 +115,13 @@ export interface AoaoeConfig {
     dryRun: boolean;
     observe: boolean;
     confirm: boolean;
+    notifications?: {
+        webhookUrl?: string;
+        slackWebhookUrl?: string;
+        events?: NotificationEvent[];
+    };
 }
+export type NotificationEvent = "session_error" | "session_done" | "action_executed" | "action_failed" | "daemon_started" | "daemon_stopped";
 export type DaemonPhase = "sleeping" | "polling" | "reasoning" | "executing" | "interrupted";
 export interface DaemonSessionState {
     id: string;

package/package.json

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