aoaoe 0.58.0 → 0.60.0

package/README.md

@@ -259,6 +259,7 @@ options:
   --reasoner <opencode|claude-code>  reasoning backend (default: opencode)
   --poll-interval <ms>               poll interval in ms (default: 10000)
   --port <number>                    opencode server port (default: 4097)
+  --health-port <number>             start HTTP health check server on this port
   --model <model>                    model to use
   --profile <name>                   aoe profile (default: default)
   --dry-run                          run full loop but only log actions (costs
@@ -336,9 +337,11 @@ Config lives at `~/.aoaoe/aoaoe.config.json` (canonical, written by `aoaoe init`
 | `sessionDirs` | Map session titles to project directories (relative to cwd or absolute). Bypasses heuristic directory search. | `{}` |
 | `contextFiles` | Extra AI instruction file paths to load from each project root | `[]` |
 | `captureLinesCount` | Number of tmux lines to capture per session (`-S` flag) | `100` |
+| `healthPort` | Start HTTP health check server on this port (e.g. `4098`). GET `/health` returns JSON status. | (none) |
 | `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.
 
@@ -497,6 +500,7 @@ src/
   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
+  health.ts         # HTTP health check endpoint (GET /health JSON status)
   colors.ts         # shared ANSI color/style constants
   context.ts        # discoverContextFiles, resolveProjectDir, loadSessionContext
   activity.ts       # detect human keystrokes in tmux sessions

package/dist/config.js

@@ -83,7 +83,7 @@ export function loadConfig(overrides) {
 const KNOWN_KEYS = {
     reasoner: true, pollIntervalMs: true, captureLinesCount: true,
     verbose: true, dryRun: true, observe: true, confirm: true,
-    contextFiles: true, sessionDirs: true, protectedSessions: true,
+    contextFiles: true, sessionDirs: true, protectedSessions: true, healthPort: true,
     opencode: new Set(["port", "model"]),
     claudeCode: new Set(["model", "yolo", "resume"]),
     aoe: new Set(["profile"]),
@@ -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))
@@ -128,6 +128,11 @@ export function validateConfig(config) {
     if (typeof config.opencode?.port !== "number" || !isFinite(config.opencode.port) || config.opencode.port < 1 || config.opencode.port > 65535) {
         errors.push(`opencode.port must be 1-65535, got ${config.opencode?.port}`);
     }
+    if (config.healthPort !== undefined) {
+        if (typeof config.healthPort !== "number" || !isFinite(config.healthPort) || config.healthPort < 1 || config.healthPort > 65535) {
+            errors.push(`healthPort must be 1-65535, got ${config.healthPort}`);
+        }
+    }
     if (typeof config.policies?.maxErrorsBeforeRestart !== "number" || config.policies.maxErrorsBeforeRestart < 1) {
         errors.push(`policies.maxErrorsBeforeRestart must be >= 1, got ${config.policies?.maxErrorsBeforeRestart}`);
     }
@@ -211,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  ")}`);
     }
@@ -241,22 +253,31 @@ async function which(cmd) {
         return false;
     }
 }
-// exported for testing
-export function deepMerge(...objects) {
-    const result = {};
-    for (const obj of objects) {
-        for (const [key, val] of Object.entries(obj)) {
-            if (val !== undefined && val !== null) {
-                // empty objects ({}) replace rather than merge — allows clearing sessionDirs etc.
-                if (typeof val === "object" && !Array.isArray(val) && Object.keys(val).length > 0 && typeof result[key] === "object") {
-                    result[key] = deepMerge(result[key], val);
-                }
-                else {
-                    result[key] = val;
-                }
+// internal recursive merge on plain Record objects (no type assertions needed)
+function mergeRecords(target, source) {
+    for (const [key, val] of Object.entries(source)) {
+        if (val !== undefined && val !== null) {
+            const existing = target[key];
+            // empty objects ({}) replace rather than merge — allows clearing sessionDirs etc.
+            if (typeof val === "object" && !Array.isArray(val) &&
+                typeof existing === "object" && existing !== null && !Array.isArray(existing) &&
+                Object.keys(val).length > 0) {
+                target[key] = mergeRecords({ ...existing }, val);
+            }
+            else {
+                target[key] = val;
             }
         }
     }
+    return target;
+}
+// exported for testing — merges config objects with nested object support
+export function deepMerge(...objects) {
+    let result = {};
+    for (const obj of objects) {
+        result = mergeRecords(result, obj);
+    }
+    // validated by caller (validateConfig) before use — safe cast
     return result;
 }
 // compute fields that differ between two config objects (flat dot-notation paths)
@@ -368,7 +389,7 @@ export function parseCliArgs(argv) {
         return argv[i + 1];
     };
     const knownFlags = new Set([
-        "--reasoner", "--poll-interval", "--port", "--model", "--profile",
+        "--reasoner", "--poll-interval", "--port", "--model", "--profile", "--health-port",
         "--verbose", "-v", "--dry-run", "--observe", "--confirm", "--help", "-h", "--version",
     ]);
     for (let i = 2; i < argv.length; i++) {
@@ -394,6 +415,14 @@ export function parseCliArgs(argv) {
                 i++;
                 break;
             }
+            case "--health-port": {
+                const val = parseInt(nextArg(i, arg), 10);
+                if (isNaN(val))
+                    throw new Error(`--health-port value '${argv[i + 1]}' is not a valid number`);
+                overrides.healthPort = val;
+                i++;
+                break;
+            }
             case "--model": {
                 // applies to whichever backend is selected
                 const model = nextArg(i, arg);
@@ -472,6 +501,7 @@ options:
   --reasoner <opencode|claude-code>  reasoning backend (default: opencode)
   --poll-interval <ms>               poll interval in ms (default: 10000)
   --port <number>                    opencode server port (default: 4097)
+  --health-port <number>             start HTTP health check server on this port
   --model <model>                    model to use
   --profile <name>                   aoe profile (default: default)
   --dry-run                          run full loop but only log actions (costs
@@ -509,10 +539,12 @@ example config:
       "my-project": "/path/to/my-project",
       "other-repo": "/path/to/other-repo"
     },
+    "healthPort": 4098,
     "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
     }
   }
 
@@ -522,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/health.d.ts

@@ -0,0 +1,26 @@
+import { type Server } from "node:http";
+import type { DaemonState } from "./types.js";
+export declare function buildHealthResponse(state: DaemonState | null, startedAt: number, now?: number): HealthResponse;
+export interface HealthResponse {
+    status: "ok" | "error";
+    version: string;
+    uptimeMs: number;
+    daemon: {
+        phase: string;
+        phaseStartedAt: number;
+        pollCount: number;
+        pollIntervalMs: number;
+        sessionCount: number;
+        changeCount: number;
+        paused: boolean;
+        sessions: Array<{
+            title: string;
+            tool: string;
+            status: string;
+            currentTask?: string;
+            userActive: boolean;
+        }>;
+    } | null;
+}
+export declare function startHealthServer(port: number, startedAt: number): Server;
+//# sourceMappingURL=health.d.ts.map

package/dist/health.js

@@ -0,0 +1,79 @@
+// health.ts — HTTP health check endpoint for daemon monitoring
+// starts a lightweight HTTP server that responds to GET /health with JSON status.
+// enabled when config.healthPort is set (opt-in). the server reads daemon state
+// from the IPC state file and returns uptime, phase, session info, and version.
+import { createServer } from "node:http";
+import { readState } from "./daemon-state.js";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+// read version from package.json at startup (cached)
+let cachedVersion;
+function getVersion() {
+    if (cachedVersion)
+        return cachedVersion;
+    try {
+        // resolve from compiled dist/ to project root package.json
+        const thisDir = dirname(fileURLToPath(import.meta.url));
+        const pkg = JSON.parse(readFileSync(join(thisDir, "..", "package.json"), "utf-8"));
+        cachedVersion = pkg.version ?? "unknown";
+    }
+    catch {
+        cachedVersion = "unknown";
+    }
+    return cachedVersion;
+}
+// pure function: build health response JSON from daemon state (exported for testing)
+export function buildHealthResponse(state, startedAt, now = Date.now()) {
+    const uptimeMs = now - startedAt;
+    const version = getVersion();
+    if (!state) {
+        return {
+            status: "error",
+            version,
+            uptimeMs,
+            daemon: null,
+        };
+    }
+    return {
+        status: "ok",
+        version,
+        uptimeMs,
+        daemon: {
+            phase: state.phase,
+            phaseStartedAt: state.phaseStartedAt,
+            pollCount: state.pollCount,
+            pollIntervalMs: state.pollIntervalMs,
+            sessionCount: state.sessionCount,
+            changeCount: state.changeCount,
+            paused: state.paused,
+            sessions: state.sessions.map((s) => ({
+                title: s.title,
+                tool: s.tool,
+                status: s.status,
+                currentTask: s.currentTask,
+                userActive: s.userActive ?? false,
+            })),
+        },
+    };
+}
+// start the health HTTP server on the given port. returns the server for shutdown.
+export function startHealthServer(port, startedAt) {
+    const server = createServer((req, res) => {
+        // only respond to GET /health (and GET / as convenience alias)
+        if (req.method === "GET" && (req.url === "/health" || req.url === "/")) {
+            const state = readState();
+            const body = JSON.stringify(buildHealthResponse(state, startedAt), null, 2);
+            res.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "no-cache" });
+            res.end(body + "\n");
+            return;
+        }
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "not found", hint: "try GET /health" }) + "\n");
+    });
+    server.listen(port, "127.0.0.1", () => {
+        // listening — logged by caller
+    });
+    return server;
+}
+//# sourceMappingURL=health.js.map

package/dist/index.js

@@ -18,6 +18,7 @@ import { runTaskCli, handleTaskSlashCommand } from "./task-cli.js";
 import { TUI } from "./tui.js";
 import { isDaemonRunningFromState } from "./chat.js";
 import { sendNotification, sendTestNotification } from "./notify.js";
+import { startHealthServer } from "./health.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";
@@ -266,8 +267,18 @@ async function main() {
         }
         catch { }
     }
-    // ── session stats (for shutdown summary) ──────────────────────────────────
+    // ── health check HTTP server (opt-in via config.healthPort) ────────────────
     const daemonStartedAt = Date.now();
+    let healthServer = null;
+    if (config.healthPort) {
+        healthServer = startHealthServer(config.healthPort, daemonStartedAt);
+        const msg = `health server listening on http://127.0.0.1:${config.healthPort}/health`;
+        if (tui)
+            tui.log("system", msg);
+        else
+            log(msg);
+    }
+    // ── session stats (for shutdown summary) ──────────────────────────────────
     let totalDecisions = 0;
     let totalActionsExecuted = 0;
     let totalActionsFailed = 0;
@@ -308,6 +319,8 @@ async function main() {
             console.error(`  mode:       dry-run (no execution)`);
         console.error("");
         log("shutting down...");
+        if (healthServer)
+            healthServer.close();
         // 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();

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,7 +119,9 @@ export interface AoaoeConfig {
         webhookUrl?: string;
         slackWebhookUrl?: string;
         events?: NotificationEvent[];
+        maxRetries?: number;
     };
+    healthPort?: number;
 }
 export type NotificationEvent = "session_error" | "session_done" | "action_executed" | "action_failed" | "daemon_started" | "daemon_stopped";
 export type DaemonPhase = "sleeping" | "polling" | "reasoning" | "executing" | "interrupted";

package/package.json

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