@adriandmitroca/relay 0.0.2

package/src/dashboard.ts

@@ -0,0 +1,175 @@
+import type { IssueDB, IssueRow, ConfigDB } from "./db.ts";
+import type { CallbackAction, CallbackData } from "./constants.ts";
+import { createRouter } from "./api/router.ts";
+import { logger } from "./utils/logger.ts";
+import { join } from "node:path";
+
+type WsClient = { send(msg: string | Buffer): void };
+
+type ActionHandler = (data: CallbackData) => Promise<{ ok: boolean; error?: string; issue?: IssueRow }>;
+type StatusProvider = () => Array<{ workspace: string; telegram: boolean; sources: string[] }>;
+
+export class DashboardServer {
+  private db: IssueDB;
+  private configDB: ConfigDB | null = null;
+  private port: number;
+  private clients = new Set<WsClient>();
+  private server: ReturnType<typeof Bun.serve> | null = null;
+  private activeStreams = new Map<number, Record<string, unknown>>();
+  private actionHandler: ActionHandler | null = null;
+  private statusProvider: StatusProvider | null = null;
+  private configChangeHandler: (() => void) | null = null;
+  private distDir: string | null = null;
+
+  constructor(db: IssueDB, port = 7842) {
+    this.db = db;
+    this.port = port;
+  }
+
+  setActionHandler(handler: ActionHandler) {
+    this.actionHandler = handler;
+  }
+
+  setStatusProvider(provider: StatusProvider) {
+    this.statusProvider = provider;
+  }
+
+  setConfigDB(configDB: ConfigDB) {
+    this.configDB = configDB;
+  }
+
+  setConfigChangeHandler(handler: () => void) {
+    this.configChangeHandler = handler;
+  }
+
+  setDistDir(dir: string) {
+    this.distDir = dir;
+  }
+
+  start() {
+    const self = this;
+
+    const app = createRouter({
+      getDB: () => this.db,
+      getConfigDB: () => {
+        if (!this.configDB) throw new Error("ConfigDB not initialized");
+        return this.configDB;
+      },
+      getActionHandler: () => this.actionHandler,
+      getStatusProvider: () => this.statusProvider,
+      onConfigChange: () => this.configChangeHandler?.(),
+    });
+
+    try {
+      this.server = Bun.serve({
+        hostname: "127.0.0.1",
+        port: this.port,
+
+        async fetch(req, server) {
+          const url = new URL(req.url);
+
+          // WebSocket upgrade
+          if (url.pathname === "/ws") {
+            const ok = server.upgrade(req);
+            if (!ok) return new Response("WebSocket upgrade failed", { status: 400 });
+            return undefined;
+          }
+
+          // API routes via Hono
+          if (url.pathname.startsWith("/api/")) {
+            return app.fetch(req);
+          }
+
+          // Serve static files from dist/ if available
+          if (self.distDir) {
+            // Try exact file match
+            let filePath = url.pathname === "/" ? "/index.html" : url.pathname;
+            const file = Bun.file(join(self.distDir, filePath));
+            if (await file.exists()) {
+              return new Response(file, {
+                headers: { "Content-Type": getMimeType(filePath) },
+              });
+            }
+
+            // SPA fallback: serve index.html for non-file paths
+            const indexFile = Bun.file(join(self.distDir, "index.html"));
+            if (await indexFile.exists()) {
+              return new Response(indexFile, {
+                headers: { "Content-Type": "text/html; charset=utf-8" },
+              });
+            }
+          }
+
+          return new Response("Dashboard not built. Run: bun run build", {
+            status: 503,
+            headers: { "Content-Type": "text/plain" },
+          });
+        },
+
+        websocket: {
+          open(ws) {
+            self.clients.add(ws);
+            // Send current stream state to new clients
+            for (const event of self.activeStreams.values()) {
+              try { ws.send(JSON.stringify(event)); } catch {}
+            }
+          },
+          close(ws) {
+            self.clients.delete(ws);
+          },
+          message() {},
+        },
+      });
+
+      logger.info("Dashboard running", { url: `http://localhost:${this.port}` });
+    } catch (err) {
+      logger.warn("Dashboard failed to start (port may be in use)", { port: this.port, error: String(err) });
+    }
+  }
+
+  broadcast(event: Record<string, unknown>) {
+    if (event.type === "stream_progress") {
+      this.activeStreams.set(event.issueId as number, event);
+    } else if (event.type === "issue_update") {
+      const issue = event.issue as { id: number; status: string };
+      if (issue.status === "triaging" || issue.status === "working") {
+        // Seed stream with startedAt so clients get a timer immediately
+        if (!this.activeStreams.has(issue.id)) {
+          this.activeStreams.set(issue.id, {
+            type: "stream_progress",
+            issueId: issue.id,
+            stage: issue.status === "triaging" ? "triage" : "fix",
+            startedAt: Date.now(),
+          });
+        }
+      } else {
+        this.activeStreams.delete(issue.id);
+      }
+    }
+
+    if (!this.clients.size) return;
+    const msg = JSON.stringify(event);
+    for (const client of this.clients) {
+      try {
+        client.send(msg);
+      } catch {}
+    }
+  }
+
+  stop() {
+    this.server?.stop(true);
+    this.server = null;
+    this.clients.clear();
+  }
+}
+
+function getMimeType(path: string): string {
+  if (path.endsWith(".html")) return "text/html; charset=utf-8";
+  if (path.endsWith(".js")) return "application/javascript";
+  if (path.endsWith(".css")) return "text/css";
+  if (path.endsWith(".json")) return "application/json";
+  if (path.endsWith(".svg")) return "image/svg+xml";
+  if (path.endsWith(".png")) return "image/png";
+  if (path.endsWith(".ico")) return "image/x-icon";
+  return "application/octet-stream";
+}