@serkanalgur/opencode-nexus 2.6.0 → 2.8.0

package/dist/tui.js

@@ -116,6 +116,14 @@ var DEFAULT_CONFIG = {
     enabled: true,
     maxRetries: 3,
     contextTransfer: true
+  },
+  dashboard: {
+    enabled: true,
+    port: 4747,
+    host: "127.0.0.1"
+  },
+  notifications: {
+    enabled: true
   }
 };
 
@@ -124,9 +132,13 @@ class NexusConfigManager {
   globalConfig = null;
   storageConfig = null;
   loadInfo = null;
-  constructor() {
+  dashboardBase;
+  notificationsBase;
+  constructor(dashboardBase, notificationsBase) {
     this.projectConfig = null;
     this.globalConfig = null;
+    this.dashboardBase = { ...DEFAULT_CONFIG.dashboard, ...dashboardBase };
+    this.notificationsBase = { ...DEFAULT_CONFIG.notifications, ...notificationsBase };
   }
   loadConfigs(basePath) {
     if (this.loadInfo === null)
@@ -188,6 +200,14 @@ class NexusConfigManager {
         ...this.globalConfig?.selfHealing,
         ...this.projectConfig?.selfHealing,
         ...this.storageConfig?.selfHealing
+      },
+      dashboard: {
+        enabled: this.storageConfig?.dashboard?.enabled ?? this.projectConfig?.dashboard?.enabled ?? this.globalConfig?.dashboard?.enabled ?? this.dashboardBase.enabled,
+        port: this.storageConfig?.dashboard?.port ?? this.projectConfig?.dashboard?.port ?? this.globalConfig?.dashboard?.port ?? this.dashboardBase.port,
+        host: this.storageConfig?.dashboard?.host ?? this.projectConfig?.dashboard?.host ?? this.globalConfig?.dashboard?.host ?? this.dashboardBase.host
+      },
+      notifications: {
+        enabled: this.storageConfig?.notifications?.enabled ?? this.projectConfig?.notifications?.enabled ?? this.globalConfig?.notifications?.enabled ?? this.notificationsBase.enabled
       }
     };
   }
@@ -308,6 +328,8 @@ class NexusConfigManager {
     result.models = { ...current.models };
     result.budget = { ...current.budget };
     result.selfHealing = { ...current.selfHealing };
+    result.dashboard = { ...current.dashboard };
+    result.notifications = { ...current.notifications };
     return result;
   }
   resetToDefaults() {
@@ -528,6 +550,185 @@ function mergeSidebarAgents(agents, polled, childIDs) {
   }
   return next.filter((a) => a.sessionID && childIDs.includes(a.sessionID) || a.status === "completed" || a.status === "failed");
 }
+async function probeDashboard(host, port, fetchImpl = fetch) {
+  const url = `http://${host}:${port}/api/health`;
+  let response;
+  try {
+    response = await fetchImpl(url);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    const refused = /ECONNREFUSED|fetch failed|Failed to fetch|NetworkError|ECONNRESET/i.test(detail);
+    return {
+      listening: false,
+      isNexusDashboard: false,
+      detail: refused ? `nothing is listening on ${host}:${port}` : `could not reach ${host}:${port} (${detail})`
+    };
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    return {
+      listening: true,
+      isNexusDashboard: false,
+      detail: `${host}:${port} answered ${response.status} but not with dashboard JSON`
+    };
+  }
+  if (body !== null && typeof body === "object" && !Array.isArray(body)) {
+    const record = body;
+    if (record.ok === true && typeof record.uptime === "number") {
+      return {
+        listening: true,
+        isNexusDashboard: true,
+        detail: `a nexus dashboard is serving ${host}:${port}`
+      };
+    }
+  }
+  return {
+    listening: true,
+    isNexusDashboard: false,
+    detail: `something else is listening on ${host}:${port} and it is not a nexus dashboard`
+  };
+}
+function parseWebDashboardTarget(input, fallback) {
+  const parts = (input ?? "").trim().split(/\s+/).filter(Boolean);
+  let port = fallback.port;
+  let host = fallback.host;
+  if (parts.length > 0) {
+    const parsed = Number(parts[0]);
+    if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65535) {
+      return { error: `"${parts[0]}" is not a port number. Give a port between 1 and 65535.` };
+    }
+    port = parsed;
+  }
+  if (parts.length > 1) {
+    host = parts[1];
+  }
+  return { target: { port, host } };
+}
+var LISTEN_CONFIRM_ATTEMPTS = 15;
+var LISTEN_CONFIRM_INTERVAL_MS = 200;
+function defaultWait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function handleWebDashboard(input, deps) {
+  const parsed = parseWebDashboardTarget(input, {
+    port: deps.dashboard.port,
+    host: deps.dashboard.host
+  });
+  if ("error" in parsed) {
+    deps.showToast({ title: "Nexus Web Dashboard", message: parsed.error, variant: "error" });
+    return;
+  }
+  const { port, host } = parsed.target;
+  const url = `http://${host}:${port}`;
+  if (!deps.dashboard.enabled) {
+    deps.showToast({
+      title: "Nexus Web Dashboard \u2014 disabled",
+      message: [
+        `The dashboard is switched off: \`dashboard.enabled\` is false in your nexus.jsonc,`,
+        "so nothing will listen on any port and no browser was opened.",
+        "",
+        "Set it to true (or delete the `dashboard` block, which defaults to enabled),",
+        "then run /nexus web again."
+      ].join(`
+`),
+      variant: "error",
+      duration: 12000
+    });
+    return;
+  }
+  const probe = await probeDashboard(host, port, deps.fetchImpl);
+  if (probe.isNexusDashboard) {
+    await deps.openBrowser(url);
+    deps.showToast({
+      title: "\u26A1 Nexus Web Dashboard",
+      message: `Opened ${url} \u2014 a dashboard is already running there, so nothing was started.`,
+      variant: "success",
+      duration: 6000
+    });
+    return;
+  }
+  if (probe.listening) {
+    deps.showToast({
+      title: "Nexus Web Dashboard \u2014 port in use",
+      message: [
+        `${probe.detail}.`,
+        "",
+        "No browser was opened: that address is not the dashboard.",
+        "Run /nexus web with a different port, e.g. /nexus web 4748."
+      ].join(`
+`),
+      variant: "error",
+      duration: 12000
+    });
+    return;
+  }
+  let submitted;
+  try {
+    await deps.submitCommand(`/nexus dashboard ${port} ${host}`);
+    submitted = `/nexus dashboard ${port} ${host}`;
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    deps.showToast({
+      title: "Nexus Web Dashboard \u2014 could not start",
+      message: [
+        `The dashboard start command never reached the OpenCode server: ${detail}`,
+        "",
+        "No server is listening on that port and no browser was opened.",
+        "The dashboard runs in the server process, so this needs the server's",
+        "HTTP endpoint to be reachable from the TUI."
+      ].join(`
+`),
+      variant: "error",
+      duration: 15000
+    });
+    return;
+  }
+  const wait = deps.waitImpl ?? defaultWait;
+  const attempts = deps.confirmAttempts ?? LISTEN_CONFIRM_ATTEMPTS;
+  const intervalMs = deps.confirmIntervalMs ?? LISTEN_CONFIRM_INTERVAL_MS;
+  for (let attempt = 0;attempt < attempts; attempt++) {
+    if (attempt > 0)
+      await wait(intervalMs);
+    const check = await probeDashboard(host, port, deps.fetchImpl);
+    if (check.isNexusDashboard) {
+      await deps.openBrowser(url);
+      deps.showToast({
+        title: "\u26A1 Nexus Web Dashboard",
+        message: `Started and opened ${url} \u2014 a dashboard is serving there now.`,
+        variant: "success",
+        duration: 8000
+      });
+      return;
+    }
+  }
+  deps.showToast({
+    title: "Nexus Web Dashboard \u2014 not started",
+    message: [
+      `Ran \`${submitted}\`, but nothing is serving on ${host}:${port} after ${Math.round(attempts * intervalMs / 1000)}s,`,
+      "so no browser was opened and there is no URL to give you.",
+      "",
+      "The command runs in the OpenCode server process, which is the only place",
+      "the dashboard can start. If a Nexus plugin is active in that process, its",
+      `result is in this session as the reply to \`${submitted}\` \u2014 that text names`,
+      "the reason (a port already in use, or `dashboard.enabled: false`). If no",
+      "plugin is active there, the command was never handled at all. If the port",
+      "is held by another process, free it or pass a different one:",
+      "/nexus web 4748."
+    ].join(`
+`),
+    variant: "error",
+    duration: 20000
+  });
+}
+async function openInBrowser(url) {
+  try {
+    const { exec } = await import("child_process");
+    const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    exec(`${command} ${url}`);
+  } catch {}
+}
 var tui_default = define({
   id: "nexus.cli",
   setup(context) {
@@ -619,10 +820,31 @@ var tui_default = define({
         variant: "success"
       });
     };
-    const handleDashboard = async () => {
+    const activeSessionID = () => {
+      const route = context.ui.router.current();
+      if (route.type === "session")
+        return route.sessionID;
+      return context.ui.tabs.list().find((tab) => tab.active)?.sessionID;
+    };
+    const submitServerCommand = async (text) => {
+      const sessionID = activeSessionID();
+      if (!sessionID) {
+        throw new Error("no session is open to run the command in");
+      }
+      await context.client.session.prompt({ sessionID, text });
+    };
+    const runWebDashboard = async (input) => {
+      await handleWebDashboard(input, {
+        dashboard: configManager.getConfig().dashboard,
+        showToast: (options) => context.ui.toast.show(options),
+        openBrowser: openInBrowser,
+        submitCommand: submitServerCommand
+      });
+    };
+    const handleOverview = async () => {
       const config = configManager.getConfig();
       const lines = [
-        "\u26A1 Nexus Dashboard",
+        "\u26A1 Nexus Overview",
         "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550",
         "",
         "\uD83E\uDD16 Agent Models:"
@@ -646,6 +868,9 @@ var tui_default = define({
       lines.push("  /nexus status   - Show config summary");
       lines.push("  /nexus config   - Configure models & budget");
       lines.push("  /nexus model    - Select model for role");
+      lines.push("  /nexus dashboard - Start the web dashboard and open it");
+      lines.push("  /nexus web      - Same: start it if needed, then open it");
+      lines.push("  /nexus overview - Show this overview");
       lines.push("  /nexus reset    - Reset to defaults");
       lines.push("");
       lines.push("\uD83D\uDD27 Tools (use in agent prompt):");
@@ -653,8 +878,14 @@ var tui_default = define({
       lines.push("  nexus.agents    - List spawned agents");
       lines.push("  nexus.costs     - Cost report");
       lines.push("  nexus.spawn     - Spawn a sub-agent");
+      lines.push("  nexus.dashboard.start - Start the web dashboard server");
+      lines.push("");
+      lines.push("\uD83D\uDCCA Web Dashboard:");
+      lines.push(`  Enabled: ${config.dashboard.enabled ? "\u2705" : "\u274C"}`);
+      lines.push(`  Address: http://${config.dashboard.host}:${config.dashboard.port} (when running)`);
+      lines.push("  Not running? /nexus dashboard starts it and opens it.");
       context.ui.toast.show({
-        title: "Nexus Dashboard",
+        title: "Nexus Overview",
         message: lines.join(`
 `),
         variant: "info",
@@ -697,34 +928,14 @@ var tui_default = define({
                       break;
                     case "dashboard":
                     case "d":
-                      await handleDashboard();
+                      await runWebDashboard(parts.slice(1).join(" "));
+                      break;
+                    case "overview":
+                      await handleOverview();
                       break;
                     case "web":
                     case "w":
-                      {
-                        const port = parts[1] ? parseInt(parts[1]) : 4747;
-                        const host = parts[2] || "127.0.0.1";
-                        context.ui.toast.show({
-                          title: "\u26A1 Nexus Web Dashboard",
-                          message: [
-                            `Starting dashboard on port ${port}...`,
-                            "",
-                            `Ask the agent to run: nexus.dashboard.start(port=${port})`,
-                            "",
-                            `Or type: nexus.dashboard.start with port=${port} in your next message`,
-                            "",
-                            `Then open: http://${host}:${port}`
-                          ].join(`
-`),
-                          variant: "success",
-                          duration: 8000
-                        });
-                        try {
-                          const { exec } = await import("child_process");
-                          const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-                          exec(`${cmd} http://${host}:${port}`);
-                        } catch {}
-                      }
+                      await runWebDashboard(parts.slice(1).join(" "));
                       break;
                     case "model":
                     case "m":
@@ -762,7 +973,7 @@ var tui_default = define({
                     default:
                       context.ui.toast.show({
                         title: "Nexus",
-                        message: "Commands: config, status, dashboard, web [port], model <role>, reset",
+                        message: "Commands: config, status, dashboard [port], web [port], overview, model <role>, reset",
                         variant: "info"
                       });
                   }
@@ -783,45 +994,42 @@ var tui_default = define({
                 await handleFullConfig();
               }
             },
+            {
+              id: "nexus.overview",
+              title: "Nexus Overview (config, budget, dashboard status)",
+              group: "Nexus",
+              palette: true,
+              slash: { name: "nexus-overview", aliases: ["no"], arguments: true },
+              enabled: () => true,
+              suggested: true,
+              run: async () => {
+                await handleOverview();
+              }
+            },
             {
               id: "nexus.dashboard",
-              title: "Nexus Dashboard",
+              title: "Start the Nexus Web Dashboard",
+              description: "Starts the dashboard server if it is not already running, then opens it in your browser",
               group: "Nexus",
               palette: true,
               slash: { name: "nexus-dashboard", aliases: ["nd"], arguments: true },
               enabled: () => true,
               suggested: true,
-              run: async () => {
-                await handleDashboard();
+              run: async (input) => {
+                await runWebDashboard(input);
               }
             },
             {
               id: "nexus.web",
-              title: "Start Nexus Web Dashboard",
+              title: "Open the Nexus Web Dashboard",
+              description: "Alias of Nexus Dashboard: starts it if needed, then opens it in your browser",
               group: "Nexus",
               palette: true,
               slash: { name: "nexus-web", aliases: ["nw"], arguments: true },
               enabled: () => true,
               suggested: true,
               run: async (input) => {
-                const port = input ? parseInt(input) : 4747;
-                const host = "127.0.0.1";
-                context.ui.toast.show({
-                  title: "\u26A1 Nexus Web Dashboard",
-                  message: [
-                    `Port: ${port}  Host: ${host}`,
-                    "",
-                    "To start the dashboard, ask the agent:",
-                    `  nexus.dashboard.start(port=${port}, host="${host}")`,
-                    "",
-                    `Then open: http://${host}:${port}`,
-                    "",
-                    "Tip: The dashboard shows live agent status, costs, and history."
-                  ].join(`
-`),
-                  variant: "info",
-                  duration: 12000
-                });
+                await runWebDashboard(input);
               }
             },
             {
@@ -1064,9 +1272,15 @@ var tui_default = define({
   }
 });
 export {
+  LISTEN_CONFIRM_ATTEMPTS,
+  LISTEN_CONFIRM_INTERVAL_MS,
   collectSidebarAgents,
   tui_default as default,
+  handleWebDashboard,
   mergeSidebarAgents,
+  openInBrowser,
+  parseWebDashboardTarget,
+  probeDashboard,
   sidebarAgentFor,
   sidebarChildSessionIDs
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serkanalgur/opencode-nexus",
-  "version": "2.6.0",
+  "version": "2.8.0",
   "description": "Adaptive Multi-Agent Orchestration with Cost Intelligence for OpenCode V2",
   "keywords": [
     "opencode",
@@ -44,18 +44,17 @@
     "dev": "bun run --watch src/index.ts",
     "typecheck": "tsc --noEmit",
     "test": "bun test",
-    "lint": "biome check src/",
-    "format": "biome format --write src/",
+    "lint": "biome check src/ test/ && tsc --noEmit && bun -e 'const page = \"dashboard/index.html\"; const html = await Bun.file(page).text(); const inline = [...html.matchAll(/<script(?![^>]*\\bsrc=)[^>]*>([\\s\\S]*?)<\\/script>/g)]; if (inline.length === 0) throw new Error(page + \" has no inline <script> to check\"); inline.forEach(m => { new Function(m[1]); }); console.log(\"lint: \" + page + \" - \" + inline.length + \" inline script(s) parse clean\");'",
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
     "@opencode/plugin": "latest"
   },
   "devDependencies": {
+    "@biomejs/biome": "latest",
     "@opentui/core": "^0.5.8",
     "@opentui/solid": "^0.5.8",
     "@types/bun": "latest",
-    "biome": "latest",
     "bun-types": "^1.4.2",
     "solid-js": "^1.9.0",
     "typescript": "^5.5.0"