aoaoe 0.67.0 → 0.68.0

package/dist/config-watcher.d.ts

@@ -0,0 +1,44 @@
+import type { AoaoeConfig } from "./types.js";
+/** Describes a single config field change */
+export interface ConfigChange {
+    field: string;
+    oldValue: unknown;
+    newValue: unknown;
+    applied: boolean;
+}
+/**
+ * Merge hot-reloadable fields from fresh config into the current config.
+ * Returns: { config: updated config, changes: list of what changed }
+ * Non-reloadable fields are left unchanged but reported as changes.
+ */
+export declare function mergeHotReload(current: AoaoeConfig, fresh: AoaoeConfig): {
+    config: AoaoeConfig;
+    changes: ConfigChange[];
+};
+/**
+ * Format a config change for display in the TUI.
+ */
+export declare function formatConfigChange(change: ConfigChange): string;
+export type ConfigChangeCallback = (changes: ConfigChange[], newConfig: AoaoeConfig) => void;
+/**
+ * ConfigWatcher — watches the config file and calls back when it changes.
+ * Debounces rapid changes (editors do save-rename-write sequences).
+ */
+export declare class ConfigWatcher {
+    private watcher;
+    private debounceTimer;
+    private configPath;
+    private callback;
+    private currentConfig;
+    private debounceMs;
+    constructor(config: AoaoeConfig, debounceMs?: number);
+    /** Start watching the config file. Returns the watched path or null. */
+    start(callback: ConfigChangeCallback): string | null;
+    /** Stop watching */
+    stop(): void;
+    /** Get the current config (may have been hot-reloaded) */
+    getConfig(): AoaoeConfig;
+    private scheduleReload;
+    private doReload;
+}
+//# sourceMappingURL=config-watcher.d.ts.map

package/dist/config-watcher.js

@@ -0,0 +1,159 @@
+// config-watcher.ts — watch config file for changes and hot-reload safe fields.
+// pure mergeHotReload function + ConfigWatcher class using fs.watch.
+import { watch } from "node:fs";
+import { loadConfig, findConfigFile, validateConfig } from "./config.js";
+/**
+ * Fields that are safe to hot-reload without restarting the daemon.
+ * Fields NOT in this list require a daemon restart to take effect.
+ *
+ * Unsafe (require restart): reasoner, opencode.port, healthPort, dryRun, observe, confirm
+ */
+const HOT_RELOAD_FIELDS = new Set([
+    "pollIntervalMs",
+    "sessionDirs",
+    "protectedSessions",
+    "contextFiles",
+    "verbose",
+    "captureLinesCount",
+    "tuiHistoryRetentionDays",
+]);
+/** Nested objects where all sub-fields are safe to hot-reload */
+const HOT_RELOAD_OBJECTS = new Set([
+    "policies",
+    "notifications",
+]);
+/**
+ * Merge hot-reloadable fields from fresh config into the current config.
+ * Returns: { config: updated config, changes: list of what changed }
+ * Non-reloadable fields are left unchanged but reported as changes.
+ */
+export function mergeHotReload(current, fresh) {
+    const changes = [];
+    const merged = { ...current };
+    // check top-level scalar/array fields
+    for (const field of HOT_RELOAD_FIELDS) {
+        const key = field;
+        const curVal = JSON.stringify(current[key]);
+        const freshVal = JSON.stringify(fresh[key]);
+        if (curVal !== freshVal) {
+            changes.push({ field, oldValue: current[key], newValue: fresh[key], applied: true });
+            merged[key] = fresh[key];
+        }
+    }
+    // check nested objects (policies, notifications)
+    for (const objField of HOT_RELOAD_OBJECTS) {
+        const key = objField;
+        const curVal = JSON.stringify(current[key]);
+        const freshVal = JSON.stringify(fresh[key]);
+        if (curVal !== freshVal) {
+            changes.push({ field: objField, oldValue: current[key], newValue: fresh[key], applied: true });
+            merged[key] = fresh[key];
+        }
+    }
+    // detect non-reloadable changes (warn user)
+    const unsafeFields = [
+        "reasoner", "dryRun", "observe", "confirm", "healthPort",
+    ];
+    for (const key of unsafeFields) {
+        const curVal = JSON.stringify(current[key]);
+        const freshVal = JSON.stringify(fresh[key]);
+        if (curVal !== freshVal) {
+            changes.push({ field: key, oldValue: current[key], newValue: fresh[key], applied: false });
+        }
+    }
+    // check nested non-reloadable (opencode.port)
+    if (current.opencode?.port !== fresh.opencode?.port) {
+        changes.push({ field: "opencode.port", oldValue: current.opencode?.port, newValue: fresh.opencode?.port, applied: false });
+    }
+    return { config: merged, changes };
+}
+/**
+ * Format a config change for display in the TUI.
+ */
+export function formatConfigChange(change) {
+    const status = change.applied ? "applied" : "requires restart";
+    const newVal = typeof change.newValue === "object"
+        ? JSON.stringify(change.newValue)
+        : String(change.newValue);
+    const truncated = newVal.length > 60 ? newVal.slice(0, 57) + "..." : newVal;
+    return `${change.field}: ${truncated} (${status})`;
+}
+/**
+ * ConfigWatcher — watches the config file and calls back when it changes.
+ * Debounces rapid changes (editors do save-rename-write sequences).
+ */
+export class ConfigWatcher {
+    watcher = null;
+    debounceTimer = null;
+    configPath = null;
+    callback = null;
+    currentConfig;
+    debounceMs;
+    constructor(config, debounceMs = 500) {
+        this.currentConfig = config;
+        this.debounceMs = debounceMs;
+    }
+    /** Start watching the config file. Returns the watched path or null. */
+    start(callback) {
+        this.callback = callback;
+        this.configPath = findConfigFile();
+        if (!this.configPath)
+            return null;
+        try {
+            this.watcher = watch(this.configPath, { persistent: false }, () => {
+                this.scheduleReload();
+            });
+            this.watcher.on("error", () => {
+                // config file may be renamed during save — try to re-watch
+                this.stop();
+            });
+        }
+        catch {
+            // watch failed — degrade gracefully
+            return null;
+        }
+        return this.configPath;
+    }
+    /** Stop watching */
+    stop() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        if (this.watcher) {
+            try {
+                this.watcher.close();
+            }
+            catch { }
+            this.watcher = null;
+        }
+    }
+    /** Get the current config (may have been hot-reloaded) */
+    getConfig() {
+        return this.currentConfig;
+    }
+    scheduleReload() {
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => {
+            this.debounceTimer = null;
+            this.doReload();
+        }, this.debounceMs);
+    }
+    doReload() {
+        try {
+            const fresh = loadConfig();
+            validateConfig(fresh);
+            const { config, changes } = mergeHotReload(this.currentConfig, fresh);
+            if (changes.length > 0) {
+                this.currentConfig = config;
+                this.callback?.(changes, config);
+            }
+        }
+        catch (err) {
+            // invalid config — ignore silently (keep running with current config)
+            console.error(`[config-watcher] reload failed: ${err}`);
+        }
+    }
+}
+//# sourceMappingURL=config-watcher.js.map

package/dist/executor.d.ts

@@ -10,6 +10,8 @@ export declare class Executor {
     private taskManager?;
     constructor(config: AoaoeConfig);
     setTaskManager(tm: TaskManager): void;
+    /** Hot-reload: update the config reference (picks up new protectedSessions, policies, etc.) */
+    updateConfig(newConfig: AoaoeConfig): void;
     execute(actions: Action[], snapshots: SessionSnapshot[]): Promise<ActionLogEntry[]>;
     private executeOne;
     private sendInput;

package/dist/executor.js

@@ -32,6 +32,10 @@ export class Executor {
     setTaskManager(tm) {
         this.taskManager = tm;
     }
+    /** Hot-reload: update the config reference (picks up new protectedSessions, policies, etc.) */
+    updateConfig(newConfig) {
+        this.config = newConfig;
+    }
     async execute(actions, snapshots) {
         const results = [];
         for (const action of actions) {

package/dist/index.js

@@ -20,6 +20,7 @@ import { isDaemonRunningFromState } from "./chat.js";
 import { sendNotification, sendTestNotification } from "./notify.js";
 import { startHealthServer } from "./health.js";
 import { loadTuiHistory } from "./tui-history.js";
+import { ConfigWatcher, formatConfigChange } from "./config-watcher.js";
 import { parseActionLogEntries, parseActivityEntries, mergeTimeline, filterByAge, parseDuration, formatTimelineJson, formatTimelineMarkdown } from "./export.js";
 import { actionSession, actionDetail, toActionLogEntry } from "./types.js";
 import { YELLOW, GREEN, DIM, BOLD, RED, RESET } from "./colors.js";
@@ -137,7 +138,7 @@ async function main() {
     }
     const configResult = loadConfig(overrides);
     const configPath = configResult._configPath;
-    const config = configResult; // strip _configPath from type for downstream
+    let config = configResult; // strip _configPath from type for downstream (let: hot-reloaded)
     // acquire daemon lock — prevent two daemons from running simultaneously
     const lock = acquireLock();
     if (!lock.acquired) {
@@ -373,6 +374,7 @@ async function main() {
             console.error(`  mode:       dry-run (no execution)`);
         console.error("");
         log("shutting down...");
+        configWatcher.stop();
         if (healthServer)
             healthServer.close();
         // notify: daemon stopped (fire-and-forget, don't block shutdown)
@@ -400,6 +402,36 @@ async function main() {
     else {
         log("entering main loop (Ctrl+C to stop)\n");
     }
+    // ── config hot-reload watcher ──────────────────────────────────────────────
+    const configWatcher = new ConfigWatcher(config);
+    const watchedPath = configWatcher.start((changes, newConfig) => {
+        config = newConfig;
+        if (executor)
+            executor.updateConfig(newConfig);
+        const applied = changes.filter((c) => c.applied);
+        const needsRestart = changes.filter((c) => !c.applied);
+        for (const c of applied) {
+            const msg = `config: ${formatConfigChange(c)}`;
+            if (tui)
+                tui.log("system", msg);
+            else
+                log(msg);
+        }
+        for (const c of needsRestart) {
+            const msg = `config: ${c.field} changed but requires restart`;
+            if (tui)
+                tui.log("system", msg);
+            else
+                log(msg);
+        }
+    });
+    if (watchedPath) {
+        const msg = `watching config: ${watchedPath}`;
+        if (tui)
+            tui.log("system", msg);
+        else
+            log(msg);
+    }
     // notify: daemon started
     sendNotification(config, { event: "daemon_started", timestamp: Date.now(), detail: `reasoner: ${config.reasoner}` });
     // clear any stale interrupt from a previous run

package/package.json

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