@opencoreai/opencore 0.2.2

package/src/dashboard-server.ts

@@ -0,0 +1,403 @@
+import express from "express";
+import { promises as fs } from "node:fs";
+import http from "node:http";
+import path from "node:path";
+import type net from "node:net";
+import { WebSocketServer } from "ws";
+import { SKILL_CATALOG } from "./skill-catalog.mjs";
+import {
+  deleteCredentialEntry,
+  readCredentialStore,
+  updateCredentialDefaults,
+  upsertCredentialEntry,
+} from "./credential-store.mjs";
+
+export type ChatRole = "user" | "assistant" | "system" | "error";
+
+export type ChatEntry = {
+  id: string;
+  role: ChatRole;
+  source: "terminal" | "dashboard" | "manager" | "telegram" | "system";
+  text: string;
+  ts: string;
+};
+
+type DashboardServerOptions = {
+  rootDir: string;
+  openCoreHome: string;
+  screenshotDir: string;
+  onDashboardPrompt: (text: string) => void;
+  getTelegramConfig: () => Promise<Record<string, any>>;
+  setTelegramConfig: (next: Record<string, any>) => Promise<Record<string, any>>;
+  disconnectTelegram: () => Promise<Record<string, any>>;
+  onCredentialsUpdated?: (payload: Record<string, any>) => Promise<void> | void;
+};
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function id() {
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+
+export class DashboardServer {
+  private readonly options: DashboardServerOptions;
+  private readonly app = express();
+  private readonly server: http.Server;
+  private readonly wss: WebSocketServer;
+  private readonly dashboardDir: string;
+  private readonly skillsDir: string;
+  private readonly chatLogPath: string;
+  private readonly vendorMap: Record<string, string>;
+  private readonly filesMap: Record<string, string>;
+  private readonly sockets = new Set<net.Socket>();
+  private chatHistory: ChatEntry[] = [];
+  private started = false;
+
+  constructor(options: DashboardServerOptions) {
+    this.options = options;
+    this.dashboardDir = path.join(options.rootDir, "opencore dashboard");
+    this.skillsDir = path.join(options.openCoreHome, "skills");
+    this.chatLogPath = path.join(options.openCoreHome, "chat-history.json");
+    this.vendorMap = {
+      "react.production.min.js": path.join(options.rootDir, "node_modules", "react", "umd", "react.production.min.js"),
+      "react-dom.production.min.js": path.join(
+        options.rootDir,
+        "node_modules",
+        "react-dom",
+        "umd",
+        "react-dom.production.min.js",
+      ),
+    };
+    this.filesMap = {
+      soul: path.join(options.openCoreHome, "soul.md"),
+      memory: path.join(options.openCoreHome, "memory.md"),
+      heartbeat: path.join(options.openCoreHome, "heartbeat.md"),
+      guidelines: path.join(options.openCoreHome, "guidelines.md"),
+      instructions: path.join(options.openCoreHome, "instructions.md"),
+    };
+
+    this.app.use(express.json({ limit: "5mb" }));
+    this.configureRoutes();
+    this.server = http.createServer(this.app);
+    this.server.on("connection", (socket) => {
+      this.sockets.add(socket);
+      socket.on("close", () => this.sockets.delete(socket));
+    });
+    this.wss = new WebSocketServer({ server: this.server, path: "/ws" });
+  }
+
+  private async loadChatHistory() {
+    try {
+      const raw = await fs.readFile(this.chatLogPath, "utf8");
+      const parsed = JSON.parse(raw || "[]");
+      this.chatHistory = Array.isArray(parsed) ? parsed.slice(-2000) : [];
+    } catch {
+      this.chatHistory = [];
+    }
+  }
+
+  private async persistChatHistory() {
+    await fs.writeFile(this.chatLogPath, `${JSON.stringify(this.chatHistory, null, 2)}\n`, "utf8");
+  }
+
+  private async listScreenshots() {
+    try {
+      const files = await fs.readdir(this.options.screenshotDir);
+      const items = await Promise.all(
+        files
+          .filter((name) => name.toLowerCase().endsWith(".png"))
+          .map(async (name) => {
+            const abs = path.join(this.options.screenshotDir, name);
+            const stat = await fs.stat(abs);
+            return { name, path: abs, ts: stat.mtime.toISOString(), size: stat.size };
+          }),
+      );
+      return items.sort((a, b) => (a.ts < b.ts ? 1 : -1));
+    } catch {
+      return [];
+    }
+  }
+
+  private wsBroadcast(payload: unknown) {
+    const data = JSON.stringify(payload);
+    for (const client of this.wss.clients) {
+      if (client.readyState === 1) {
+        client.send(data);
+      }
+    }
+  }
+
+  private async listInstalledSkillIds() {
+    const installed = new Set<string>();
+    try {
+      const entries = await fs.readdir(this.skillsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const id = entry.name;
+        const skillFile = path.join(this.skillsDir, id, "SKILL.md");
+        try {
+          await fs.access(skillFile);
+          installed.add(id);
+        } catch {}
+      }
+    } catch {}
+    return installed;
+  }
+
+  private async installSkill(id: string) {
+    const skill = SKILL_CATALOG.find((item) => item.id === id);
+    if (!skill) {
+      return { ok: false, error: "Unknown skill." };
+    }
+    const skillDir = path.join(this.skillsDir, skill.id);
+    const skillFile = path.join(skillDir, "SKILL.md");
+    const configFile = path.join(skillDir, "config.json");
+    await fs.mkdir(skillDir, { recursive: true });
+    await fs.writeFile(skillFile, `${skill.markdown.trim()}\n`, "utf8");
+    await fs.writeFile(
+      configFile,
+      `${JSON.stringify(
+        {
+          id: skill.id,
+          name: skill.name,
+          description: skill.description,
+          ...skill.config,
+        },
+        null,
+        2,
+      )}\n`,
+      "utf8",
+    );
+    return { ok: true };
+  }
+
+  private configureRoutes() {
+    this.app.get("/api/health", (_req, res) => {
+      res.json({ ok: true, service: "opencore-dashboard" });
+    });
+
+    this.app.get("/api/chat", async (_req, res) => {
+      res.json({ messages: this.chatHistory.slice(-500) });
+    });
+
+    this.app.post("/api/chat", async (req, res) => {
+      const text = String(req.body?.text || "").trim();
+      if (!text) return res.status(400).json({ error: "Message text is required." });
+      this.options.onDashboardPrompt(text);
+      res.json({ ok: true });
+    });
+
+    this.app.get("/api/files/:name", async (req, res) => {
+      const key = String(req.params.name || "");
+      const filePath = this.filesMap[key];
+      if (!filePath) return res.status(404).json({ error: "Unknown file." });
+      try {
+        const content = await fs.readFile(filePath, "utf8");
+        res.json({ name: key, path: filePath, content });
+      } catch (error) {
+        res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+      }
+    });
+
+    this.app.put("/api/files/:name", async (req, res) => {
+      const key = String(req.params.name || "");
+      const filePath = this.filesMap[key];
+      if (!filePath) return res.status(404).json({ error: "Unknown file." });
+      const content = String(req.body?.content ?? "");
+      try {
+        await fs.writeFile(filePath, content, "utf8");
+        this.wsBroadcast({ type: "file_saved", name: key, ts: nowIso() });
+        res.json({ ok: true });
+      } catch (error) {
+        res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+      }
+    });
+
+    this.app.get("/api/screenshots", async (_req, res) => {
+      res.json({ items: await this.listScreenshots() });
+    });
+
+    this.app.get("/api/screenshots/file", async (req, res) => {
+      const filePath = String(req.query.path || "");
+      if (!filePath.startsWith(this.options.screenshotDir)) {
+        return res.status(403).json({ error: "Forbidden screenshot path." });
+      }
+      res.sendFile(filePath, (err) => {
+        if (err) res.status(404).end();
+      });
+    });
+
+    this.app.get("/api/skills", async (_req, res) => {
+      const installed = await this.listInstalledSkillIds();
+      res.json({
+        items: SKILL_CATALOG.map((skill) => ({
+          id: skill.id,
+          name: skill.name,
+          description: skill.description,
+          installed: installed.has(skill.id),
+        })),
+      });
+    });
+
+    this.app.post("/api/skills/install", async (req, res) => {
+      const id = String(req.body?.id || "").trim();
+      if (!id) return res.status(400).json({ error: "Skill id is required." });
+      try {
+        const result = await this.installSkill(id);
+        if (!result.ok) return res.status(404).json({ error: result.error || "Unknown skill." });
+        this.wsBroadcast({ type: "skill_installed", id, ts: nowIso() });
+        res.json({ ok: true, id });
+      } catch (error) {
+        res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+      }
+    });
+
+    this.app.get("/api/telegram", async (_req, res) => {
+      try {
+        const config = await this.options.getTelegramConfig();
+        res.json(config);
+      } catch (error) {
+        res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+      }
+    });
+
+    this.app.put("/api/telegram", async (req, res) => {
+      try {
+        const config = await this.options.setTelegramConfig(req.body || {});
+        this.wsBroadcast({ type: "telegram_config_updated", payload: config, ts: nowIso() });
+        res.json(config);
+      } catch (error) {
+        res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+      }
+    });
+
+    this.app.post("/api/telegram/disconnect", async (_req, res) => {
+      try {
+        const config = await this.options.disconnectTelegram();
+        this.wsBroadcast({ type: "telegram_config_updated", payload: config, ts: nowIso() });
+        res.json(config);
+      } catch (error) {
+        res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+      }
+    });
+
+    this.app.get("/api/credentials", async (_req, res) => {
+      try {
+        const store = await readCredentialStore();
+        res.json(store);
+      } catch (error) {
+        res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+      }
+    });
+
+    this.app.put("/api/credentials/defaults", async (req, res) => {
+      try {
+        const store = await updateCredentialDefaults(req.body || {});
+        await this.options.onCredentialsUpdated?.(store);
+        this.wsBroadcast({ type: "credentials_updated", payload: store, ts: nowIso() });
+        res.json(store);
+      } catch (error) {
+        res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+      }
+    });
+
+    this.app.post("/api/credentials/upsert", async (req, res) => {
+      try {
+        const store = await upsertCredentialEntry(req.body || {});
+        await this.options.onCredentialsUpdated?.(store);
+        this.wsBroadcast({ type: "credentials_updated", payload: store, ts: nowIso() });
+        res.json(store);
+      } catch (error) {
+        res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+      }
+    });
+
+    this.app.post("/api/credentials/delete", async (req, res) => {
+      try {
+        const id = String(req.body?.id || req.body?.website || "").trim();
+        if (!id) return res.status(400).json({ error: "Credential id or website is required." });
+        const store = await deleteCredentialEntry(id);
+        await this.options.onCredentialsUpdated?.(store);
+        this.wsBroadcast({ type: "credentials_updated", payload: store, ts: nowIso() });
+        res.json(store);
+      } catch (error) {
+        res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+      }
+    });
+
+    this.app.use("/dashboard", express.static(this.dashboardDir));
+
+    this.app.get("/vendor/:file", (req, res) => {
+      const file = String(req.params.file || "");
+      const resolved = this.vendorMap[file];
+      if (!resolved) return res.status(404).end();
+      res.sendFile(resolved, (err) => {
+        if (err) res.status(404).end();
+      });
+    });
+
+    this.app.get("/", (_req, res) => {
+      res.redirect("/dashboard/");
+    });
+  }
+
+  async start(port = 4111) {
+    if (this.started) return;
+    await fs.mkdir(this.options.screenshotDir, { recursive: true });
+    await fs.mkdir(path.dirname(this.chatLogPath), { recursive: true });
+    await this.loadChatHistory();
+    await new Promise<void>((resolve, reject) => {
+      this.server.once("error", reject);
+      this.server.listen(port, "127.0.0.1", () => resolve());
+    });
+    this.started = true;
+  }
+
+  async stop(timeoutMs = 1200) {
+    if (!this.started) return;
+    for (const client of this.wss.clients) {
+      try {
+        client.terminate();
+      } catch {}
+    }
+    await new Promise<void>((resolve) => {
+      let done = false;
+      const finish = () => {
+        if (done) return;
+        done = true;
+        resolve();
+      };
+      const timer = setTimeout(() => {
+        for (const socket of this.sockets) {
+          try {
+            socket.destroy();
+          } catch {}
+        }
+        finish();
+      }, Math.max(200, Number(timeoutMs) || 1200));
+
+      this.wss.close(() => {});
+      this.server.close(() => {
+        clearTimeout(timer);
+        finish();
+      });
+    });
+    this.started = false;
+  }
+
+  async publishChat(entry: Omit<ChatEntry, "id" | "ts">) {
+    const full: ChatEntry = { ...entry, id: id(), ts: nowIso() };
+    this.chatHistory.push(full);
+    if (this.chatHistory.length > 2000) {
+      this.chatHistory = this.chatHistory.slice(this.chatHistory.length - 2000);
+    }
+    await this.persistChatHistory();
+    this.wsBroadcast({ type: "chat_message", payload: full });
+  }
+
+  publishEvent(payload: unknown) {
+    this.wsBroadcast({ type: "event", payload, ts: nowIso() });
+  }
+}