heyio 0.24.1 → 0.25.0

package/dist/config.js

@@ -7,6 +7,7 @@ const DEFAULT_CONFIG = {
     backgroundNotifyMode: "meaningful",
     backgroundNotifyTelegram: true,
     backgroundNotifyTui: true,
+    watchdogEnabled: true,
 };
 function loadConfig() {
     mkdirSync(IO_HOME, { recursive: true });

package/dist/daemon.js

@@ -13,6 +13,7 @@ import { backfillReviewVerdicts } from "./copilot/review-backfill.js";
 import { startScheduler, stopScheduler } from "./copilot/scheduler.js";
 import { startIoScheduler, stopIoScheduler } from "./copilot/io-scheduler.js";
 import { config } from "./config.js";
+import { startWatchdog } from "./watchdog.js";
 import { ensureWikiStructure } from "./wiki/fs.js";
 import { autoUpdate } from "./update.js";
 import { readdirSync, statSync, rmSync } from "fs";
@@ -129,6 +130,12 @@ export async function startDaemon() {
     // Daily cleanup — prune schedule runs and notifications older than 30 days
     const PRUNE_INTERVAL_MS = 24 * 60 * 60 * 1000;
     const PRUNE_RETENTION_DAYS = 30;
+    // Start event loop watchdog
+    let stopWatchdog;
+    if (config.watchdogEnabled) {
+        stopWatchdog = startWatchdog();
+        console.error("[io] Event loop watchdog started");
+    }
     const pruneTimer = setInterval(() => {
         try {
             const runsDeleted = pruneOldScheduleRuns(PRUNE_RETENTION_DAYS);

package/dist/tui/index.js

@@ -252,9 +252,14 @@ export async function startTui() {
                     firstChunk = false;
                 }
                 if (done) {
+                    // Finalize the current message as its own line, then reset state
+                    // so the next message in a multi-turn response starts a fresh bubble.
                     clearLine();
-                    process.stdout.write(accumulated + "\n");
-                    rl.prompt();
+                    if (accumulated) {
+                        process.stdout.write(accumulated + "\n");
+                    }
+                    accumulated = "";
+                    firstChunk = true;
                 }
                 else {
                     accumulated += text;
@@ -262,6 +267,10 @@ export async function startTui() {
                     process.stdout.write(accumulated);
                 }
             });
+            // Restore the prompt once the handler promise fully resolves (i.e. after
+            // all turns are done), rather than inside the done callback so that
+            // multi-turn responses don't render a premature prompt between messages.
+            rl.prompt();
         }
         catch (err) {
             clearLine();

package/dist/watchdog.js

@@ -0,0 +1,51 @@
+/**
+ * Daemon liveness watchdog.
+ *
+ * Uses a periodic setInterval to detect event loop stalls. If the interval
+ * fires significantly late, the event loop was blocked for that duration.
+ *
+ * - Warning logged if stall exceeds WARN_THRESHOLD_MS (30s)
+ * - Process exits if stall exceeds FATAL_THRESHOLD_MS (60s), relying on
+ *   the process supervisor to restart
+ */
+const DEFAULT_CHECK_INTERVAL_MS = 30_000;
+const DEFAULT_WARN_THRESHOLD_MS = 30_000;
+const DEFAULT_FATAL_THRESHOLD_MS = 60_000;
+let timer = null;
+let lastTick = 0;
+/**
+ * Start the event loop watchdog. Returns a stop function.
+ */
+export function startWatchdog(opts = {}) {
+    const checkInterval = opts.checkIntervalMs ?? DEFAULT_CHECK_INTERVAL_MS;
+    const warnThreshold = opts.warnThresholdMs ?? DEFAULT_WARN_THRESHOLD_MS;
+    const fatalThreshold = opts.fatalThresholdMs ?? DEFAULT_FATAL_THRESHOLD_MS;
+    lastTick = Date.now();
+    timer = setInterval(() => {
+        const now = Date.now();
+        const elapsed = now - lastTick;
+        const stallMs = elapsed - checkInterval;
+        if (stallMs >= fatalThreshold) {
+            console.error(`[watchdog] FATAL: event loop stalled for ${Math.round(stallMs / 1000)}s (threshold: ${Math.round(fatalThreshold / 1000)}s) at ${new Date(now).toISOString()}`);
+            if (opts.onFatal) {
+                opts.onFatal(stallMs);
+            }
+            else {
+                process.exit(1);
+            }
+        }
+        else if (stallMs >= warnThreshold) {
+            console.error(`[watchdog] WARNING: event loop stalled for ${Math.round(stallMs / 1000)}s at ${new Date(now).toISOString()}`);
+            opts.onStall?.(stallMs);
+        }
+        lastTick = now;
+    }, checkInterval);
+    timer.unref();
+    return () => {
+        if (timer) {
+            clearInterval(timer);
+            timer = null;
+        }
+    };
+}
+//# sourceMappingURL=watchdog.js.map

package/dist/watchdog.test.js

@@ -0,0 +1,83 @@
+import { describe, it, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import { startWatchdog } from "./watchdog.js";
+describe("watchdog", () => {
+    let stop;
+    beforeEach(() => {
+        if (stop) {
+            stop();
+            stop = undefined;
+        }
+    });
+    it("calls onStall when stall exceeds warn threshold", async () => {
+        const stalls = [];
+        stop = startWatchdog({
+            checkIntervalMs: 30,
+            warnThresholdMs: 40,
+            fatalThresholdMs: 5000,
+            onStall: (ms) => stalls.push(ms),
+        });
+        // Block event loop longer than checkInterval + warnThreshold
+        const start = Date.now();
+        while (Date.now() - start < 120) {
+            // busy-wait
+        }
+        // Let the interval fire
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        assert.ok(stalls.length > 0, "onStall should have been called");
+        assert.ok(stalls[0] >= 40, `stall duration ${stalls[0]} should be >= 40ms`);
+        stop();
+        stop = undefined;
+    });
+    it("calls onFatal when stall exceeds fatal threshold", async () => {
+        const fatals = [];
+        stop = startWatchdog({
+            checkIntervalMs: 30,
+            warnThresholdMs: 20,
+            fatalThresholdMs: 50,
+            onStall: () => { },
+            onFatal: (ms) => fatals.push(ms),
+        });
+        // Block event loop longer than checkInterval + fatalThreshold
+        const start = Date.now();
+        while (Date.now() - start < 150) {
+            // busy-wait
+        }
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        assert.ok(fatals.length > 0, "onFatal should have been called");
+        assert.ok(fatals[0] >= 50, `fatal duration ${fatals[0]} should be >= 50ms`);
+        stop();
+        stop = undefined;
+    });
+    it("does not fire when event loop is healthy", async () => {
+        const stalls = [];
+        const fatals = [];
+        stop = startWatchdog({
+            checkIntervalMs: 30,
+            warnThresholdMs: 500,
+            fatalThresholdMs: 1000,
+            onStall: (ms) => stalls.push(ms),
+            onFatal: (ms) => fatals.push(ms),
+        });
+        // Wait without blocking — interval fires on time
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        assert.equal(stalls.length, 0, "onStall should not fire for healthy loop");
+        assert.equal(fatals.length, 0, "onFatal should not fire for healthy loop");
+        stop();
+        stop = undefined;
+    });
+    it("stop function cleans up the interval", () => {
+        stop = startWatchdog({
+            checkIntervalMs: 30,
+            warnThresholdMs: 10,
+            fatalThresholdMs: 20,
+            onStall: () => { },
+            onFatal: () => { },
+        });
+        // Should not throw on double-stop
+        stop();
+        stop();
+        stop = undefined;
+    });
+});
+//# sourceMappingURL=watchdog.test.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heyio",
-  "version": "0.24.1",
+  "version": "0.25.0",
   "description": "IO — a personal AI assistant built on the GitHub Copilot SDK",
   "bin": {
     "io": "dist/index.js"