aoaoe 0.57.0 → 0.59.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,6 +337,7 @@ 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) |
@@ -497,6 +499,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"]),
@@ -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}`);
     }
@@ -241,22 +246,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 +382,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 +408,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 +494,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,6 +532,7 @@ 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",

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

@@ -120,6 +120,7 @@ export interface AoaoeConfig {
         slackWebhookUrl?: string;
         events?: NotificationEvent[];
     };
+    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.57.0",
+  "version": "0.59.0",
   "description": "Autonomous supervisor for agent-of-empires sessions using OpenCode or Claude Code",
   "type": "module",
   "main": "dist/index.js",