opencode-dashboard 0.1.0 → 0.2.0

package/server/routes.ts

@@ -21,9 +21,16 @@ import {
   createSSEResponse,
   closeAllClients,
   clientCount,
+  setClientCountChangeCallback,
   reset as resetSSE,
 } from "./sse";
 import { join } from "path";
+import { computeBuildHash } from "../shared/version";
+
+// --- Build Hash ---
+
+/** Computed once at module load time (same process as server/index.ts) */
+const buildHash = computeBuildHash();
 
 // --- Static File Serving ---
 
@@ -51,6 +58,36 @@ const MIME_TYPES: Record<string, string> = {
 /** Central state manager — processes events and persists to disk */
 export const stateManager = new StateManager();
 
+// --- Column Visibility → SSE Bridge ---
+
+/**
+ * Listen for column visibility changes from the StateManager and broadcast
+ * them as `columns:update` SSE events to all connected dashboard frontends.
+ *
+ * The StateManager emits `columns:visibility` events (via its onEvent listener
+ * mechanism) whenever broadcastColumnsUpdate() detects that the visible column
+ * set has changed. This bridge forwards those events to SSE clients so the
+ * frontend can update its column layout in real time.
+ *
+ * The StateManager already handles:
+ * - Deduplication (only emits when visible set actually changes)
+ * - Grace period timers for pipeline column hiding
+ * - Only triggering on column-affecting events (bead:stage, bead:done, etc.)
+ */
+const _unsubscribeColumnsListener = stateManager.onEvent((event, data) => {
+  if (event === "columns:visibility") {
+    const { projectPath, visibleColumns } = data as {
+      projectPath: string;
+      visibleColumns: unknown[];
+    };
+    broadcast("columns:update", {
+      projectPath,
+      visibleColumns,
+      _serverTimestamp: Date.now(),
+    });
+  }
+});
+
 // --- Plugin Registry ---
 
 interface PluginRecord {
@@ -67,6 +104,91 @@ const plugins = new Map<string, PluginRecord>();
 /** Server start time for uptime calculation */
 const startTime = Date.now();
 
+// --- Idle Auto-Shutdown ---
+
+/** Handle for the idle shutdown timer (null when not ticking) */
+let idleTimer: ReturnType<typeof setTimeout> | null = null;
+
+/** Idle timeout in milliseconds; 0 or negative disables the feature */
+let idleTimeoutMs: number = 300_000;
+
+/**
+ * Configure the idle auto-shutdown feature.
+ *
+ * Sets the idle timeout value and registers a callback on SSE client
+ * count changes so that the idle timer is started/cleared automatically
+ * when all dashboard browser tabs connect or disconnect.
+ */
+export function configureIdleShutdown(timeoutMs: number): void {
+  idleTimeoutMs = timeoutMs;
+
+  setClientCountChangeCallback(() => {
+    if (clientCount() === 0) {
+      checkAndStartIdleTimer();
+    } else {
+      clearIdleTimer();
+    }
+  });
+}
+
+/**
+ * Start the idle shutdown timer if the server is truly idle
+ * (no registered plugins AND no connected SSE clients).
+ *
+ * Does nothing if:
+ * - The feature is disabled (idleTimeoutMs <= 0)
+ * - There are still plugins or clients connected
+ * - A timer is already ticking
+ */
+export function checkAndStartIdleTimer(): void {
+  if (idleTimeoutMs <= 0) return;
+
+  if (plugins.size > 0 || clientCount() > 0) {
+    clearIdleTimer();
+    return;
+  }
+
+  if (idleTimer !== null) return; // already ticking
+
+  const timeoutSec = Math.round(idleTimeoutMs / 1000);
+  console.log(
+    `[server] No plugins or clients connected. Auto-shutdown in ${timeoutSec}s...`
+  );
+
+  idleTimer = setTimeout(() => {
+    idleTimer = null;
+    // Race-condition guard: re-check conditions before pulling the trigger
+    if (plugins.size > 0 || clientCount() > 0) {
+      console.log(
+        "[server] Idle timer fired but activity detected — shutdown aborted."
+      );
+      return;
+    }
+    console.log("[server] Idle timeout reached — shutting down.");
+    // Dynamic require to avoid circular dependency at module load time:
+    // routes.ts ↔ index.ts both import from each other, but shutdown()
+    // is only needed at runtime (inside a setTimeout callback), so lazy
+    // resolution via require() defers the import until it's actually called.
+    const { shutdown: performShutdown } = require("./index");
+    performShutdown();
+  }, idleTimeoutMs);
+
+  // Don't let the timer keep the process alive on its own
+  idleTimer.unref();
+}
+
+/**
+ * Cancel a running idle shutdown timer (e.g. when a plugin registers
+ * or an SSE client connects).
+ */
+export function clearIdleTimer(): void {
+  if (idleTimer !== null) {
+    clearTimeout(idleTimer);
+    idleTimer = null;
+    console.log("[server] Idle timer cancelled — activity detected.");
+  }
+}
+
 // --- Helpers ---
 
 /** Add CORS headers for localhost origins */
@@ -171,6 +293,9 @@ async function handleRegister(
     pluginId,
   });
 
+  // A new plugin means activity — cancel any pending idle shutdown
+  clearIdleTimer();
+
   return json({ pluginId }, 200, origin);
 }
 
@@ -334,6 +459,9 @@ function handleDeregister(
     pluginId,
   });
 
+  // Plugin removed — check if the server is now idle
+  checkAndStartIdleTimer();
+
   return json({ ok: true }, 200, origin);
 }
 
@@ -378,6 +506,7 @@ function handleHealth(origin?: string | null): Response {
       uptime: Math.floor((Date.now() - startTime) / 1000),
       plugins: plugins.size,
       sseClients: clientCount(),
+      buildHash,
     },
     200,
     origin
@@ -506,6 +635,8 @@ const pluginHealthInterval = setInterval(() => {
         pluginId,
         reason: "heartbeat_timeout",
       });
+      // Plugin timed out — check if server is now idle
+      checkAndStartIdleTimer();
     }
   }
 }, PLUGIN_HEALTH_CHECK_INTERVAL_MS);

package/server/sse.ts

@@ -27,6 +27,17 @@ const clients = new Set<SSEClient>();
 
 const encoder = new TextEncoder();
 
+/** Optional callback invoked whenever the connected client count changes */
+let onClientCountChange: (() => void) | null = null;
+
+/**
+ * Register a callback that fires whenever the SSE client count changes
+ * (connect, disconnect, or failed send/heartbeat removal).
+ */
+export function setClientCountChangeCallback(cb: () => void): void {
+  onClientCountChange = cb;
+}
+
 /**
  * Get the current number of connected SSE clients.
  */
@@ -61,6 +72,7 @@ export function broadcast(eventName: string, data: unknown): void {
       client.controller.enqueue(encoded);
     } catch {
       clients.delete(client);
+      try { onClientCountChange?.(); } catch { /* callback error must not disrupt broadcast loop */ }
     }
   }
 }
@@ -97,6 +109,7 @@ export function createSSEResponse(
         connectedAt: Date.now(),
       };
       clients.add(sseClient);
+      onClientCountChange?.();
 
       // Set reconnect interval
       controller.enqueue(encoder.encode("retry: 3000\n\n"));
@@ -122,6 +135,7 @@ export function createSSEResponse(
     cancel() {
       if (sseClient) {
         clients.delete(sseClient);
+        onClientCountChange?.();
       }
     },
   });
@@ -152,6 +166,7 @@ const sseHeartbeatInterval = setInterval(() => {
       client.controller.enqueue(heartbeat);
     } catch {
       clients.delete(client);
+      try { onClientCountChange?.(); } catch { /* callback error must not disrupt heartbeat loop */ }
     }
   }
 }, SSE_HEARTBEAT_INTERVAL_MS);
@@ -189,6 +204,7 @@ export function reset(): void {
   }
   clients.clear();
   messageId = 0;
+  onClientCountChange = null;
 }
 
 // --- Exports for testing ---