npm - opencode-dashboard - Versions diffs - 0.1.0 → 0.2.0 - Mend

opencode-dashboard 0.1.0 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/README.md +20 -1
package/bin/cli.ts +16 -2
package/dist/assets/{index-W-qyIr7d.js → index-DJanV0JQ.js} +2 -2
package/dist/index.html +1 -1
package/package.json +1 -1
package/plugin/index.ts +245 -5
package/server/index.ts +23 -3
package/server/pid.ts +115 -5
package/server/routes.ts +131 -0
package/server/sse.ts +16 -0
package/server/state.ts +518 -1
package/shared/types.ts +17 -7
package/shared/version.ts +46 -0

package/dist/index.html CHANGED Viewed

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>OpenCode Dashboard</title>
-    <script type="module" crossorigin src="/assets/index-W-qyIr7d.js"></script>
+    <script type="module" crossorigin src="/assets/index-DJanV0JQ.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-mMdK5PVd.css">
   </head>
   <body class="min-h-screen bg-background text-foreground antialiased">

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "opencode-dashboard",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Real-time Kanban dashboard that visualizes OpenCode agent activity",
   "type": "module",
   "license": "MIT",

package/plugin/index.ts CHANGED Viewed

@@ -20,9 +20,11 @@
 import type { Plugin } from "@opencode-ai/plugin";
 import { tool } from "@opencode-ai/plugin";
 import type { BeadRecord, BeadDiff, ColumnConfig } from "../shared/types";
-import { isServerRunning, readPid, writePid, removePid } from "../server/pid";
+import { computeBuildHash } from "../shared/version";
+import { isServerRunning, readPid, writePid, removePid, openLogFile, getLogFilePath, readAutostart, writeAutostart, removeAutostart } from "../server/pid";
 import { join, resolve } from "path";
 import { readdir, readFile, copyFile, mkdir, stat } from "fs/promises";
+import { closeSync } from "fs";
 // ─── Constants ─────────────────────────────────────────────────
@@ -74,6 +76,7 @@ let currentBeadId: string | null = null;
 let sessionToAgent = new Map<string, string>();
 let pendingAgentType: string | null = null;
 let currentAgentName: string | null = null; // tracks the agent handling the current chat.message
+let activePrimarySession: string | null = null; // tracks primary session with active agent:active event
 // Agent discovery results
 let discoveredAgents: DiscoveredAgent[] = [];
@@ -432,6 +435,7 @@ function generateColumnConfig(agents: DiscoveredAgent[]): ColumnConfig[] {
       type: "agent",
       color: nextColor(orchestratorAgent),
       order: order++,
+      group: "pipeline",
     });
   }
@@ -443,6 +447,7 @@ function generateColumnConfig(agents: DiscoveredAgent[]): ColumnConfig[] {
       type: "agent",
       color: nextColor(agent),
       order: order++,
+      group: "pipeline",
     });
   }
@@ -454,6 +459,7 @@ function generateColumnConfig(agents: DiscoveredAgent[]): ColumnConfig[] {
       type: "agent",
       color: nextColor(agent),
       order: order++,
+      group: "standalone",
     });
   }
@@ -543,6 +549,26 @@ async function checkServerHealth(): Promise<boolean> {
   }
 }
+/**
+ * Get the server's build hash from the health endpoint.
+ * Returns null if the server doesn't report a hash or is unreachable.
+ */
+async function getServerBuildHash(port?: number): Promise<string | null> {
+  try {
+    const url = port
+      ? `http://localhost:${port}/api/health`
+      : serverUrl("/api/health");
+    const res = await fetch(url, {
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+    });
+    if (!res.ok) return null;
+    const data = (await res.json()) as { buildHash?: string };
+    return data.buildHash ?? null;
+  } catch {
+    return null;
+  }
+}
 async function spawnServer(port: number): Promise<boolean> {
   // Resolve the bun executable path. We cannot use process.execPath because
   // when running inside OpenCode, that points to the OpenCode Go binary,
@@ -556,17 +582,28 @@ async function spawnServer(port: number): Promise<boolean> {
   log(`Server not running, starting on port ${port}...`);
   log(`Spawning: ${bunPath} run ${SERVER_ENTRY}`);
+  let logFd: number | undefined;
+  try {
+    logFd = openLogFile();
+  } catch {
+    // If log file can't be opened, fall back to ignore
+  }
   try {
     const proc = Bun.spawn([bunPath, "run", SERVER_ENTRY], {
       detached: true,
-      stdio: ["ignore", "ignore", "ignore"],
+      stdio: ["ignore", logFd ?? "ignore", logFd ?? "ignore"],
       env: { ...process.env, DASHBOARD_PORT: String(port) },
     });
     proc.unref();
-    log(`Spawned server process (PID: ${proc.pid})`);
+    log(`Spawned server process (PID: ${proc.pid}), logs: ${getLogFilePath()}`);
   } catch (err) {
     logError(`Failed to spawn server process:`, err);
     return false;
+  } finally {
+    if (logFd !== undefined) {
+      try { closeSync(logFd); } catch {}
+    }
   }
   // Poll for readiness
@@ -945,6 +982,12 @@ async function startupSequence(
   pluginId = id;
   serverReady = true;
+  // Write autostart marker so subsequent sessions auto-start the server.
+  // This ensures the dashboard "just works" across sessions without the user
+  // needing to manually call dashboard_start every time.
+  writeAutostart(serverPort);
+  log(`Wrote autostart marker (port ${serverPort})`);
   // Generate and send column config
   const columns = generateColumnConfig(discoveredAgents);
   await pushEvent("columns:update", { columns });
@@ -1071,7 +1114,7 @@ async function getServerStatus(): Promise<string> {
 export const DashboardPlugin: Plugin = async ({ client, directory, $ }) => {
   const projectName = directory.split("/").pop() || "unknown";
-  log(`Plugin loaded for ${projectName} (dormant — waiting for /dashboard-start)`);
+  log(`Plugin loaded for ${projectName} — checking for existing server`);
   log(`Directory: ${directory}`);
   projectPath = directory;
@@ -1113,6 +1156,97 @@ export const DashboardPlugin: Plugin = async ({ client, directory, $ }) => {
     log("Setup not detected — commands not installed in either location");
   }
+  // Auto-connect to existing server if one is already running,
+  // or auto-start a new server if the user previously activated the dashboard.
+  // This enables event flow (agent:active, bead:stage, etc.) without
+  // requiring the user to manually call dashboard_start each session.
+  // Fire-and-forget: don't block plugin load / hook registration.
+  (async () => {
+    try {
+      let existing = await isServerRunning(true);
+      if (!existing) {
+        // No server running — check if the user previously activated the dashboard
+        const autostart = readAutostart();
+        if (autostart) {
+          log("No server found but autostart marker exists — spawning server");
+          const port = autostart.port || DEFAULT_PORT;
+          const started = await spawnServer(port);
+          if (started) {
+            existing = await isServerRunning(true);
+            if (!existing) {
+              warn("Server spawned but PID file not found after autostart");
+              return;
+            }
+            log(`Auto-started server on port ${existing.port} (from autostart marker)`);
+          } else {
+            warn("Failed to auto-start server from autostart marker");
+            return;
+          }
+        } else {
+          log("No existing server found — staying dormant");
+          return;
+        }
+      }
+      // Version check: compare server's build hash with current code on disk.
+      // If they differ, the server is running stale code and must be restarted.
+      const expectedHash = computeBuildHash();
+      const serverHash = await getServerBuildHash(existing.port);
+      if (serverHash && serverHash !== expectedHash) {
+        log(`Server code is stale (server: ${serverHash}, expected: ${expectedHash}) — restarting`);
+        // Kill the old server
+        try {
+          process.kill(existing.pid, "SIGTERM");
+          removePid();
+        } catch { /* ignore — process may already be gone */ }
+        // Wait briefly for the old server to die
+        await Bun.sleep(1000);
+        // Spawn a fresh server on the same port
+        const started = await spawnServer(existing.port);
+        if (!started) {
+          warn("Failed to restart server after detecting stale code");
+          return;
+        }
+        log("Server restarted with fresh code");
+        // Re-read PID data since we spawned a new server
+        existing = await isServerRunning(true);
+        if (!existing) {
+          warn("Server restarted but PID file not found");
+          return;
+        }
+      } else if (serverHash) {
+        log(`Server code is current (hash: ${serverHash})`);
+      } else {
+        log("Server does not report build hash — skipping version check");
+      }
+      log(`Found existing server (PID: ${existing.pid}, port: ${existing.port}) — auto-connecting`);
+      // Discover agents first (startupSequence needs discoveredAgents populated)
+      discoveredAgents = await discoverAllAgents(directory);
+      hasPipelineAgents = discoveredAgents.some((a) => a.name in PIPELINE_AGENT_ORDER);
+      log(
+        `Discovered ${discoveredAgents.length} agent(s)` +
+          (hasPipelineAgents ? " (pipeline agents present)" : " (no pipeline agents)"),
+      );
+      const result = await startupSequence(directory, projectName, $, existing.port);
+      if (serverReady) {
+        activated = true;
+        toast(`Auto-connected to dashboard at http://localhost:${existing.port}`, "success", "Dashboard");
+        log(`Auto-connect succeeded: ${result}`);
+      } else {
+        log(`Auto-connect failed: ${result}`);
+      }
+    } catch (err) {
+      warn("Auto-connect error:", err);
+    }
+  })();
   return {
     // ─── Custom Tools (LLM-callable) ──────────────────────────
@@ -1132,9 +1266,53 @@ export const DashboardPlugin: Plugin = async ({ client, directory, $ }) => {
             args.port ?? (Number(process.env.DASHBOARD_PORT) || DEFAULT_PORT);
           // Check if already running
-          const existing = await isServerRunning(true);
+          let existing = await isServerRunning(true);
           if (existing) {
             serverPort = existing.port;
+            // Version check: restart stale server
+            const expectedHash = computeBuildHash();
+            const serverHash = await getServerBuildHash(existing.port);
+            if (serverHash && serverHash !== expectedHash) {
+              log(`dashboard_start: server is stale (server: ${serverHash}, expected: ${expectedHash}) — restarting`);
+              // Deregister from old server if currently connected
+              if (activated) {
+                stopHeartbeat();
+                await deregisterFromServer();
+                serverReady = false;
+                activated = false;
+              }
+              // Kill old server
+              try {
+                process.kill(existing.pid, "SIGTERM");
+                removePid();
+              } catch { /* ignore — process may already be gone */ }
+              await Bun.sleep(1000);
+              // Spawn fresh and connect
+              activating = true;
+              try {
+                const result = await startupSequence(directory, projectName, $, existing.port);
+                activated = true;
+                const isSuccess = serverReady;
+                toast(
+                  isSuccess ? `Dashboard restarted (stale code detected) at http://localhost:${existing.port}` : result,
+                  isSuccess ? "success" : "warning",
+                  "Dashboard",
+                );
+                return isSuccess
+                  ? `Dashboard restarted with fresh code at http://localhost:${existing.port}`
+                  : result;
+              } finally {
+                activating = false;
+              }
+            }
+            // Server is current — connect or report already running
             if (!activated) {
               // Server is running but plugin isn't connected — connect now
               const result = await startupSequence(directory, projectName, $, existing.port);
@@ -1167,6 +1345,10 @@ export const DashboardPlugin: Plugin = async ({ client, directory, $ }) => {
           "Call this when the user wants to shut down the dashboard.",
         args: {},
         async execute() {
+          // Remove autostart marker so the server is not auto-started
+          // on the next session — the user explicitly wants it stopped.
+          removeAutostart();
+          log("Removed autostart marker (explicit stop)");
           const result = await stopServer();
           toast(result, "info", "Dashboard");
           return result;
@@ -1240,11 +1422,55 @@ export const DashboardPlugin: Plugin = async ({ client, directory, $ }) => {
       const model = input.model;
       const agent = input.agent;
+      log(`chat.message: session=${sessionID} agent=${agent ?? "(none)"} model=${model ?? "(unknown)"} activated=${activated} serverReady=${serverReady}`);
+      // Lazy reconnection: if this plugin session is dormant but a server
+      // is available (started by another OpenCode session or auto-started),
+      // connect now. This handles the multi-session scenario where session B
+      // starts before session A starts the dashboard.
+      if (!activated && !activating) {
+        const pidData = readPid();
+        if (pidData) {
+          log("Dormant session detected available server — attempting lazy connect");
+          // Fire-and-forget: don't block the chat.message hook
+          activating = true;
+          (async () => {
+            try {
+              discoveredAgents = await discoverAllAgents(directory);
+              hasPipelineAgents = discoveredAgents.some((a) => a.name in PIPELINE_AGENT_ORDER);
+              const result = await startupSequence(directory, projectName, $, pidData.port);
+              if (serverReady) {
+                activated = true;
+                toast(`Auto-connected to dashboard at http://localhost:${pidData.port}`, "success", "Dashboard");
+                log(`Lazy connect succeeded: ${result}`);
+              } else {
+                log(`Lazy connect failed: ${result}`);
+              }
+            } catch (err) {
+              warn("Lazy connect error:", err);
+            } finally {
+              activating = false;
+            }
+          })();
+        }
+      }
       // Track current agent for bead:claimed stage tracking
       if (agent) {
         currentAgentName = agent;
       }
+      // Send agent:active for primary agents (not subagents tracked in sessionToAgent)
+      // Only send if not already active for this session to avoid duplicates
+      if (agent && serverReady && !sessionToAgent.has(sessionID) && activePrimarySession !== sessionID) {
+        activePrimarySession = sessionID;
+        await pushEvent("agent:active", {
+          agent: agent,
+          sessionId: sessionID,
+          beadId: currentBeadId,
+        });
+      }
       if (injectedSessions.has(sessionID)) return;
       if (await isChildSession(client, sessionID)) {
@@ -1415,6 +1641,7 @@ export const DashboardPlugin: Plugin = async ({ client, directory, $ }) => {
           const sessionID = props?.sessionID;
           if (typeof sessionID !== "string" || !sessionID) return;
+          // Handle subagent idle (existing behavior)
           const agentType = sessionToAgent.get(sessionID);
           if (agentType) {
             log(`Agent idle: ${agentType} (session: ${sessionID})`);
@@ -1428,6 +1655,19 @@ export const DashboardPlugin: Plugin = async ({ client, directory, $ }) => {
             sessionToAgent.delete(sessionID);
           }
+          // Handle primary agent idle (not a subagent, but a built-in agent like Build, Plan, etc.)
+          if (!sessionToAgent.has(sessionID) && currentAgentName && activePrimarySession === sessionID) {
+            log(`Primary agent idle: ${currentAgentName} (session: ${sessionID})`);
+            activePrimarySession = null;
+            if (serverReady) {
+              await pushEvent("agent:idle", {
+                agent: currentAgentName,
+                sessionId: sessionID,
+                beadId: currentBeadId,
+              });
+            }
+          }
           if (serverReady) {
             scheduleRefresh($);
           }

package/server/index.ts CHANGED Viewed

@@ -13,10 +13,22 @@ import {
   closeAllSSEClients,
   stateManager,
   stopHealthMonitoring,
+  configureIdleShutdown,
+  checkAndStartIdleTimer,
 } from "./routes";
 import { writePid, removePid } from "./pid";
+import { computeBuildHash } from "../shared/version";
 const PORT = Number(process.env.DASHBOARD_PORT) || 3333;
+const buildHash = computeBuildHash();
+const DEFAULT_IDLE_TIMEOUT_MS = 300_000; // 5 minutes
+const rawIdleTimeout = process.env.DASHBOARD_IDLE_TIMEOUT_MS;
+const parsedIdleTimeout = rawIdleTimeout ? parseInt(rawIdleTimeout, 10) : NaN;
+const IDLE_TIMEOUT_MS =
+  Number.isFinite(parsedIdleTimeout) && parsedIdleTimeout >= 0
+    ? parsedIdleTimeout
+    : DEFAULT_IDLE_TIMEOUT_MS;
 const server = Bun.serve({
   port: PORT,
@@ -25,10 +37,14 @@ const server = Bun.serve({
 });
 // Write PID file so plugin tools and CLI can find this server
-writePid(process.pid, server.port ?? PORT);
+writePid(process.pid, server.port ?? PORT, buildHash);
 console.log(`[dashboard-server] Running on http://localhost:${server.port}`);
 console.log(`[dashboard-server] PID: ${process.pid}`);
+console.log(
+  `[dashboard-server] Idle auto-shutdown timeout: ${IDLE_TIMEOUT_MS === 0 ? "disabled" : `${IDLE_TIMEOUT_MS}ms`}`,
+);
+console.log(`[dashboard-server] Build hash: ${buildHash}`);
 console.log(`[dashboard-server] Endpoints:`);
 console.log(`  POST   /api/plugin/register`);
 console.log(`  POST   /api/plugin/event`);
@@ -38,14 +54,18 @@ console.log(`  GET    /api/state`);
 console.log(`  GET    /api/events`);
 console.log(`  GET    /api/health`);
+// --- Idle Auto-Shutdown ---
+configureIdleShutdown(IDLE_TIMEOUT_MS);
+checkAndStartIdleTimer();
 // --- Graceful Shutdown ---
-function shutdown() {
+export function shutdown() {
   console.log(`\n[dashboard-server] Shutting down...`);
   stateManager.persistNow(); // Flush state to disk before shutdown
   stopHealthMonitoring();
   closeAllSSEClients();
-  removePid(); // Clean up PID file
+  removePid(process.pid); // Clean up PID file (only if it still belongs to us)
   server.stop();
   console.log(`[dashboard-server] Server stopped.`);
   process.exit(0);

package/server/pid.ts CHANGED Viewed

@@ -8,7 +8,7 @@
  * Contents: JSON { pid, port, startedAt }
  */
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, openSync, readFileSync, statSync, truncateSync, unlinkSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
 import { homedir } from "os";
@@ -18,25 +18,59 @@ export interface PidFileData {
   pid: number;
   port: number;
   startedAt: string; // ISO timestamp
+  buildHash?: string; // 12-char hex hash of source files (optional for backward compat)
 }
 // --- PID file path ---
 const PID_DIR = join(homedir(), ".cache", "opencode");
 const PID_FILE = join(PID_DIR, "opencode-dashboard.pid");
+const LOG_FILE = join(PID_DIR, "opencode-dashboard.log");
+const AUTOSTART_FILE = join(PID_DIR, "opencode-dashboard.autostart");
+const MAX_LOG_SIZE_BYTES = 1_048_576; // 1 MB
 /** Get the PID file path (exposed for testing) */
 export function getPidFilePath(): string {
   return PID_FILE;
 }
+/** Get the server log file path */
+export function getLogFilePath(): string {
+  return LOG_FILE;
+}
+/**
+ * Prepare the server log file for writing.
+ * Ensures the directory exists and truncates the file if it exceeds 1 MB.
+ * Returns a file descriptor opened in append mode, suitable for Bun.spawn stdio.
+ */
+export function openLogFile(): number {
+  if (!existsSync(PID_DIR)) {
+    mkdirSync(PID_DIR, { recursive: true });
+  }
+  // Simple size management: truncate if over 1 MB
+  try {
+    const st = statSync(LOG_FILE);
+    if (st.size > MAX_LOG_SIZE_BYTES) {
+      truncateSync(LOG_FILE, 0);
+    }
+  } catch {
+    // File doesn't exist yet — that's fine
+  }
+  // Open in append mode, create if not exists
+  return openSync(LOG_FILE, "a");
+}
 // --- Write ---
 /**
  * Write PID file when the server starts.
  * Creates the directory if it doesn't exist.
  */
-export function writePid(pid: number, port: number): void {
+export function writePid(pid: number, port: number, buildHash?: string): void {
   if (!existsSync(PID_DIR)) {
     mkdirSync(PID_DIR, { recursive: true });
   }
@@ -44,6 +78,7 @@ export function writePid(pid: number, port: number): void {
     pid,
     port,
     startedAt: new Date().toISOString(),
+    ...(buildHash ? { buildHash } : {}),
   };
   writeFileSync(PID_FILE, JSON.stringify(data, null, 2), "utf-8");
 }
@@ -71,12 +106,19 @@ export function readPid(): PidFileData | null {
 /**
  * Remove PID file on graceful shutdown or after stopping the server.
+ *
+ * When `ownPid` is provided, the file is only deleted if it still belongs
+ * to that process. This prevents a shutting-down server from accidentally
+ * removing a *new* server's PID file written during a restart race.
  */
-export function removePid(): void {
+export function removePid(ownPid?: number): void {
   try {
-    if (existsSync(PID_FILE)) {
-      unlinkSync(PID_FILE);
+    if (!existsSync(PID_FILE)) return;
+    if (ownPid !== undefined) {
+      const current = readPid();
+      if (current && current.pid !== ownPid) return; // PID file belongs to a newer server
     }
+    unlinkSync(PID_FILE);
   } catch {
     // Ignore errors (file may already be gone)
   }
@@ -138,3 +180,71 @@ export async function isServerRunning(
   return pidData;
 }
+// --- Autostart Marker ---
+/**
+ * Autostart marker file tracks whether the user has previously activated
+ * the dashboard. When present, the plugin will auto-start the server on
+ * subsequent sessions instead of staying dormant.
+ *
+ * The marker is:
+ * - Written when the dashboard is first activated (startupSequence succeeds)
+ * - Removed when the user explicitly calls dashboard_stop
+ * - Checked during plugin auto-connect to decide whether to spawn a server
+ */
+export interface AutostartData {
+  port: number;
+  createdAt: string; // ISO timestamp
+}
+/** Get the autostart marker file path (exposed for testing) */
+export function getAutostartFilePath(): string {
+  return AUTOSTART_FILE;
+}
+/**
+ * Write the autostart marker to indicate the dashboard should auto-start
+ * on subsequent plugin loads.
+ */
+export function writeAutostart(port: number): void {
+  if (!existsSync(PID_DIR)) {
+    mkdirSync(PID_DIR, { recursive: true });
+  }
+  const data: AutostartData = {
+    port,
+    createdAt: new Date().toISOString(),
+  };
+  writeFileSync(AUTOSTART_FILE, JSON.stringify(data, null, 2), "utf-8");
+}
+/**
+ * Read the autostart marker. Returns null if the marker doesn't exist
+ * or is malformed.
+ */
+export function readAutostart(): AutostartData | null {
+  try {
+    if (!existsSync(AUTOSTART_FILE)) return null;
+    const raw = readFileSync(AUTOSTART_FILE, "utf-8");
+    const parsed = JSON.parse(raw) as AutostartData;
+    if (typeof parsed.port !== "number") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+/**
+ * Remove the autostart marker (e.g. when the user explicitly stops
+ * the dashboard via dashboard_stop).
+ */
+export function removeAutostart(): void {
+  try {
+    if (existsSync(AUTOSTART_FILE)) {
+      unlinkSync(AUTOSTART_FILE);
+    }
+  } catch {
+    // Ignore errors (file may already be gone)
+  }
+}