@krmxd/onegpt 0.0.0-beta

package/src/web.js

@@ -0,0 +1,270 @@
+// Token dashboard for oGPT - the Node twin of ogpt/web (Flask build).
+// Same endpoints, same single-file UI, zero npm dependencies: served with
+// the plain http module and wired into the SAME agent singleton the
+// terminal uses, so dashboard and TUI share one brain and one counter.
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const http = require("http");
+const { getConfig } = require("./config");
+
+const STARTED_AT = Date.now();
+const runs = []; // per-run metrics, capped like Python's deque(maxlen=300)
+let server = null;
+let dashUrl = null;
+
+function recordRun(stats) {
+  stats = stats || {};
+  runs.push({
+    ts: Date.now() / 1000,
+    tokens: stats.tokens || 0,
+    tps: stats.tps || 0,
+    ttft: stats.ttft,
+    duration: stats.duration,
+    promptTokens: stats.promptTokens || 0,
+  });
+  if (runs.length > 300) runs.splice(0, runs.length - 300);
+}
+
+function runsTail(n = 80) {
+  return runs.slice(-n);
+}
+
+function shortCwd() {
+  try {
+    const cwd = process.cwd();
+    const home = os.homedir();
+    return cwd.startsWith(home) ? "~" + cwd.slice(home.length) : cwd;
+  } catch {
+    return "";
+  }
+}
+
+function sessionsDir() {
+  return path.join(os.homedir(), ".config", "ogpt", "sessions");
+}
+
+// Simple async mutex so web requests never interleave AI turns with the TUI.
+let chain = Promise.resolve();
+function withLock(fn) {
+  const p = chain.then(fn, fn);
+  chain = p.catch(() => {});
+  return p;
+}
+
+function json(res, code, obj) {
+  const body = JSON.stringify(obj);
+  res.writeHead(code, { "Content-Type": "application/json" });
+  res.end(body);
+}
+
+function readBody(req) {
+  return new Promise((resolve) => {
+    let data = "";
+    req.on("data", (c) => {
+      data += c;
+      if (data.length > 1e6) req.destroy();
+    });
+    req.on("end", () => resolve(data));
+    req.on("error", () => resolve(""));
+  });
+}
+
+function historyView(agent) {
+  const out = [];
+  for (const m of agent.history || []) {
+    if (m.role === "tool" || m.role === "system") continue;
+    const content = String(m.content || "").trim();
+    if (!content || content.startsWith("[Conversation summary]")) continue;
+    if (m.toolCalls && m.role === "assistant") continue;
+    out.push({ role: m.role, ts: m.ts || null, content: content.slice(0, 4000) });
+  }
+  return out.slice(-60);
+}
+
+// Heuristic chunk classifier matching ogpt.ui.stream.classify_chunk.
+function classifyChunk(chunk) {
+  if (typeof chunk !== "string") return ["text", chunk];
+  const s = chunk.trimStart();
+  if (s.startsWith("[Tool:")) return ["tool", chunk.trim()];
+  if (/^(⚠|\[error\]|\[Engine)/i.test(s)) return ["error", chunk];
+  return ["text", chunk];
+}
+
+async function chatOnce(cli, msg) {
+  let reply = "";
+  for await (const c of cli.agent.runStream(msg)) {
+    const [kind, payload] = classifyChunk(c);
+    if (kind === "text") reply += c;
+  }
+  return reply.trim();
+}
+
+function createDashboard(cli) {
+  return http.createServer(async (req, res) => {
+    const url = new URL(req.url, "http://localhost");
+    const cfg = cli.cfg || getConfig();
+    const agent = () => cli.agent;
+    const name = cfg.displayName();
+    try {
+      if (url.pathname === "/api/health") {
+        return json(res, 200, {
+          ok: true,
+          app: "OGPT",
+          version: "1.1.0",
+          model: name,
+          provider: "Ollama",
+          uptime_s: Math.round((Date.now() - STARTED_AT) / 100) / 10,
+        });
+      }
+
+      if (url.pathname === "/api/stats") {
+        const a = agent();
+        const usage = (a && a.usage) || { prompt: 0, completion: 0, total: 0 };
+        const lastRun = (a && a.lastRun) || {};
+        const tpsVals = runs.filter((r) => r.tps).map((r) => r.tps);
+        let session = null;
+        let sessionsCount = 0;
+        try {
+          sessionsCount = fs.readdirSync(sessionsDir()).filter((f) => f.endsWith(".meta.json")).length;
+          if (cli.currentSession) session = cli.currentSession;
+          else if (cli._sessionId) session = cli._sessionId;
+        } catch {}
+        let toolsCount = 0;
+        try {
+          toolsCount = cli.tools.listTools().length;
+        } catch {}
+        let modelsInstalled = 0;
+        try {
+          modelsInstalled = (await require("./catalog").listModels()).length;
+        } catch {}
+        return json(res, 200, {
+          ok: true,
+          version: "1.1.0",
+          model: name,
+          model_id: name,
+          provider: "Ollama",
+          cwd: shortCwd(),
+          uptime_s: Math.round((Date.now() - STARTED_AT) / 100) / 10,
+          session,
+          messages: a.history.filter((m) => !["tool", "system"].includes(m.role)).length,
+          tokens: { prompt: usage.prompt || 0, completion: usage.completion || 0, total: usage.total || 0 },
+          last_run: lastRun,
+          runs: runsTail(80),
+          runs_count: runs.length,
+          avg_tps: tpsVals.length ? Math.round((tpsVals.reduce((a2, b) => a2 + b, 0) / tpsVals.length) * 100) / 100 : null,
+          best_tps: tpsVals.length ? Math.max(...tpsVals) : null,
+          tools_count: toolsCount,
+          sessions_count: sessionsCount,
+          models_installed: modelsInstalled,
+        });
+      }
+
+      if (url.pathname === "/api/history") {
+        return json(res, 200, historyView(agent()));
+      }
+
+      if (url.pathname === "/api/chat" && req.method === "POST") {
+        const body = JSON.parse((await readBody(req)) || "{}");
+        const msg = String(body.message || "").trim();
+        if (!msg) return json(res, 400, { error: "message required" });
+        const reply = await withLock(() => chatOnce(cli, msg));
+        return json(res, 200, { reply, stats: agent().lastRun || {} });
+      }
+
+      if (url.pathname === "/api/chat/stream") {
+        const msg = (url.searchParams.get("msg") || "").trim();
+        if (!msg) return json(res, 400, { error: "msg required" });
+        res.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          "X-Accel-Buffering": "no",
+        });
+        const sse = (o) => res.write(`data: ${JSON.stringify(o)}\n\n`);
+        await withLock(async () => {
+          try {
+            for await (const c of agent().runStream(msg)) {
+              const [kind, payload] = classifyChunk(c);
+              if (kind === "tool") sse({ tool: payload });
+              else if (kind === "error") sse({ error: payload });
+              else sse({ t: c });
+            }
+          } catch (e) {
+            sse({ error: e.message });
+          }
+        });
+        sse({ done: true, stats: agent().lastRun || {} });
+        return res.end();
+      }
+
+      if (url.pathname === "/api/sessions") {
+        try {
+          const dir = sessionsDir();
+          const rows = fs.readdirSync(dir)
+            .filter((f) => f.endsWith(".meta.json"))
+            .map((f) => {
+              try {
+                const m = JSON.parse(fs.readFileSync(path.join(dir, f), "utf-8"));
+                return { id: m.id || f.replace(".meta.json", ""), title: m.title || "",
+                         msgs: m.msgs ?? 0, updated: m.updated || 0 };
+              } catch { return null; }
+            })
+            .filter(Boolean)
+            .sort((a, b) => a.updated - b.updated)
+            .slice(-25);
+          return json(res, 200, rows);
+        } catch {
+          return json(res, 200, []);
+        }
+      }
+
+      if (url.pathname === "/api/tools") {
+        try {
+          return json(res, 200, cli.tools.listTools().map((t) => t.name));
+        } catch {
+          return json(res, 200, []);
+        }
+      }
+
+      if (url.pathname === "/" || url.pathname === "/index.html") {
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        return res.end(require("./static"));
+      }
+
+      json(res, 404, { error: "not found" });
+    } catch (e) {
+      json(res, 500, { error: e.message });
+    }
+  });
+}
+
+function listenOn(srv, host, port) {
+  return new Promise((resolve) => {
+    const onError = () => resolve(false);
+    srv.once("error", onError);
+    srv.listen(port, host, () => {
+      srv.removeListener("error", onError);
+      resolve(true);
+    });
+  });
+}
+
+async function startDashboard(cli) {
+  if (dashUrl) return dashUrl;
+  const cfg = cli.cfg || getConfig();
+  if (!cfg.get("web.enabled", true)) return null;
+  const host = String(cfg.get("web.host", "127.0.0.1"));
+  const basePort = parseInt(cfg.get("web.port", 8756), 10) || 8756;
+  const srv = createDashboard(cli);
+  for (let p = basePort; p < basePort + 12; p++) {
+    if (await listenOn(srv, host, p)) {
+      server = srv;
+      dashUrl = `http://${host}:${p}`;
+      return dashUrl;
+    }
+    srv.removeAllListeners("error");
+  }
+  return null;
+}
+
+module.exports = { startDashboard, recordRun, runsTail };