Generated with Hive: Fix graph-admin mock routing and extend mock cmd handler for local development

src/__tests__/unit/api/mock/swarm-credentials-and-cmd.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi } from "vitest";
+import { describe, it, expect, vi, beforeEach } from "vitest";
 
 vi.mock("@/config/env", () => ({
   env: {
@@ -246,3 +246,110 @@ describe("GET /api/mock/swarm-super-admin/api/cmd", () => {
     expect(data).toMatchObject({ error: expect.stringContaining("Missing txt") });
   });
 });
+
+// ---------------------------------------------------------------------------
+// Boltwall stateful commands
+// ---------------------------------------------------------------------------
+
+describe("Boltwall stateful mock commands", () => {
+  // Reset state before each test to ensure isolation
+  beforeEach(async () => {
+    const { resetMockBoltwallState } = await import(
+      "@/app/api/mock/swarm-super-admin/api/cmd/state"
+    );
+    resetMockBoltwallState();
+  });
+
+  async function cmdRequest(cmd: object) {
+    const { GET } = await import(
+      "@/app/api/mock/swarm-super-admin/api/cmd/route"
+    );
+    const txt = encodeURIComponent(JSON.stringify(cmd));
+    return GET(
+      makeRequest(
+        `http://localhost/api/mock/swarm-super-admin/api/cmd?txt=${txt}`,
+        { headers: { "x-jwt": "mock-jwt-token" } }
+      )
+    );
+  }
+
+  it("GetBoltwallAccessibility returns { isPublic: false } by default", async () => {
+    const res = await cmdRequest({ cmd: "GetBoltwallAccessibility" });
+    const data = await res.json();
+    expect(res.status).toBe(200);
+    expect(data).toEqual({ isPublic: false });
+  });
+
+  it("UpdateBoltwallAccessibility + GetBoltwallAccessibility round-trip", async () => {
+    // Set to true
+    const updateRes = await cmdRequest({
+      type: "Swarm",
+      data: { cmd: "UpdateBoltwallAccessibility", content: true },
+    });
+    expect(updateRes.status).toBe(200);
+    expect(await updateRes.json()).toEqual({ success: true });
+
+    // Confirm state persisted
+    const getRes = await cmdRequest({ cmd: "GetBoltwallAccessibility" });
+    expect(getRes.status).toBe(200);
+    expect(await getRes.json()).toEqual({ isPublic: true });
+  });
+
+  it("ListPaidEndpoint returns 2 endpoints by default", async () => {
+    const res = await cmdRequest({ cmd: "ListPaidEndpoint" });
+    const data = await res.json();
+    expect(res.status).toBe(200);
+    expect(data.endpoints).toHaveLength(2);
+    expect(data.endpoints[0]).toMatchObject({ id: 1, route: "v2/search" });
+    expect(data.endpoints[1]).toMatchObject({ id: 2, route: "node/content" });
+  });
+
+  it("UpdatePaidEndpoint mutates endpoint status", async () => {
+    // Disable endpoint id=1
+    const updateRes = await cmdRequest({
+      type: "Swarm",
+      data: { cmd: "UpdatePaidEndpoint", content: { id: 1, status: false } },
+    });
+    expect(updateRes.status).toBe(200);
+    expect(await updateRes.json()).toEqual({ success: true });
+
+    // Re-fetch and confirm
+    const listRes = await cmdRequest({ cmd: "ListPaidEndpoint" });
+    const data = await listRes.json();
+    const ep1 = data.endpoints.find((e: { id: number }) => e.id === 1);
+    expect(ep1.status).toBe(false);
+    // Other endpoint unchanged
+    const ep2 = data.endpoints.find((e: { id: number }) => e.id === 2);
+    expect(ep2.status).toBe(true);
+  });
+
+  it("GetBoltwallSuperAdmin returns { pubkey: null, name: null }", async () => {
+    const res = await cmdRequest({ cmd: "GetBoltwallSuperAdmin" });
+    const data = await res.json();
+    expect(res.status).toBe(200);
+    expect(data).toEqual({ pubkey: null, name: null });
+  });
+
+  it("GetBotBalance returns { success: true, data: { msat } }", async () => {
+    const res = await cmdRequest({ cmd: "GetBotBalance" });
+    const data = await res.json();
+    expect(res.status).toBe(200);
+    expect(data).toEqual({ success: true, message: "bot balance retrieved", data: { msat: 30000 } });
+  });
+
+  it("CreateBotInvoice returns an invoice string", async () => {
+    const res = await cmdRequest({
+      type: "Swarm",
+      data: { cmd: "CreateBotInvoice", content: { amt_msat: 1000 } },
+    });
+    const data = await res.json();
+    expect(res.status).toBe(200);
+    expect(typeof data.invoice).toBe("string");
+  });
+
+  it("state resets between tests (isPublic is false again)", async () => {
+    const res = await cmdRequest({ cmd: "GetBoltwallAccessibility" });
+    const data = await res.json();
+    expect(data).toEqual({ isPublic: false });
+  });
+});

src/__tests__/unit/components/features/CompactTasksList.test.tsx

@@ -1611,18 +1611,12 @@ describe("CompactTasksList", () => {
         />
       );
 
+      // Wait until the model select (data-value="") is present, meaning models have loaded
       await waitFor(() => {
-        // Models should be loaded - find the model select by its empty value
         const selects = screen.getAllByTestId("select");
-        expect(selects.length).toBeGreaterThanOrEqual(1);
+        const modelSelect = selects.find((s) => s.getAttribute("data-value") === "");
+        expect(modelSelect).toBeDefined();
       });
-
-      // Simulate onValueChange being called with a model value
-      // The Select mock renders a div with data-testid="select" and data-value
-      // We need to find the model select - it's the one with value="" (task.model is null)
-      const selects = screen.getAllByTestId("select");
-      const modelSelect = selects.find((s) => s.getAttribute("data-value") === "");
-      expect(modelSelect).toBeDefined();
     });
 
     test("shows existing model value in selector", async () => {

src/__tests__/unit/services/swarm/cmd.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect, beforeEach, vi } from "vitest";
+import { describe, test, expect, beforeEach, afterEach, vi } from "vitest";
 
 // Mock fetch globally before importing
 const mockFetch = vi.fn();
@@ -7,8 +7,21 @@ global.fetch = mockFetch;
 const { getSwarmCmdJwt, swarmCmdRequest } = await import("@/services/swarm/cmd");
 
 describe("getSwarmCmdJwt", () => {
+  let savedUseMocks: string | undefined;
+
   beforeEach(() => {
     vi.clearAllMocks();
+    // Ensure production routing (no mocks) for getSwarmCmdJwt tests
+    savedUseMocks = process.env.USE_MOCKS;
+    delete process.env.USE_MOCKS;
+  });
+
+  afterEach(() => {
+    if (savedUseMocks !== undefined) {
+      process.env.USE_MOCKS = savedUseMocks;
+    } else {
+      delete process.env.USE_MOCKS;
+    }
   });
 
   const swarmUrl = "https://swarm42.sphinx.chat";
@@ -114,14 +127,23 @@ describe("getSwarmCmdJwt", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// swarmCmdRequest — USE_MOCKS routing + double-encoded JSON handling
+// ---------------------------------------------------------------------------
+
 describe("swarmCmdRequest", () => {
+  const swarmUrl = "https://swarm42.sphinx.chat";
+  const jwt = "test-jwt-token";
+  const cmd = { type: "Swarm" as const, data: { cmd: "GetBoltwallAccessibility" as const } };
+
   beforeEach(() => {
     vi.clearAllMocks();
+    delete process.env.USE_MOCKS;
   });
 
-  const swarmUrl = "https://swarm42.sphinx.chat";
-  const jwt = "test-jwt-token";
-  const cmd = { type: "Swarm" as const, data: { cmd: "GetBoltwallAccessibility" as const } };
+  afterEach(() => {
+    delete process.env.USE_MOCKS;
+  });
 
   test("parses normal (single-encoded) JSON correctly", async () => {
     mockFetch.mockResolvedValue({
@@ -209,4 +231,33 @@ describe("swarmCmdRequest", () => {
     const [, init] = mockFetch.mock.calls[0];
     expect(init.headers["x-jwt"]).toBe(jwt);
   });
+
+  test("routes to host:8800 in production (no USE_MOCKS)", async () => {
+    mockFetch.mockResolvedValue({
+      ok: true,
+      status: 200,
+      text: async () => JSON.stringify({ isPublic: false }),
+    });
+
+    await swarmCmdRequest({ swarmUrl, jwt, cmd });
+
+    const [url] = mockFetch.mock.calls[0];
+    expect(url).toContain("swarm42.sphinx.chat:8800/api/cmd");
+  });
+
+  test("routes to NEXTAUTH_URL mock endpoint when USE_MOCKS=true", async () => {
+    process.env.USE_MOCKS = "true";
+    process.env.NEXTAUTH_URL = "http://localhost:3000";
+
+    mockFetch.mockResolvedValue({
+      ok: true,
+      status: 200,
+      text: async () => JSON.stringify({ isPublic: false }),
+    });
+
+    await swarmCmdRequest({ swarmUrl, jwt, cmd });
+
+    const [url] = mockFetch.mock.calls[0];
+    expect(url).toContain("localhost:3000/api/mock/swarm-super-admin/api/cmd");
+  });
 });

src/app/api/mock/swarm-super-admin/api/cmd/route.ts

@@ -1,11 +1,20 @@
 import { NextRequest, NextResponse } from "next/server";
+import {
+  mockIsPublic,
+  mockEndpoints,
+  setMockIsPublic,
+  setMockEndpoints,
+} from "./state";
 
 const MOCK_CONTAINERS = [
   { name: "sphinx", status: "running", image: "sphinxlightning/sphinx-relay:latest" },
   { name: "neo4j", status: "running", image: "neo4j:5" },
   { name: "lnd", status: "stopped", image: "lightninglabs/lnd:v0.18" },
 ];
 
+// ---------------------------------------------------------------------------
+// Static responses
+// ---------------------------------------------------------------------------
 const MOCK_RESPONSES: Record<string, unknown> = {
   ListContainers: { containers: MOCK_CONTAINERS },
   StartContainer: { success: true },
@@ -25,6 +34,18 @@ const MOCK_RESPONSES: Record<string, unknown> = {
       "lightninglabs/lnd": "v0.18",
     },
   },
+  // Boltwall admin
+  GetBoltwallSuperAdmin: { pubkey: null, name: null },
+  ListAdmins: { admins: [] },
+  GetBotBalance: { success: true, message: "bot balance retrieved", data: { msat: 30000 } },
+  CreateBotInvoice: { invoice: "lnbcrt1mock000000000" },
+  AddBoltwallUser: { success: true },
+  AddBoltwallAdminPubkey: { success: true },
+  DeleteSubAdmin: { success: true },
+  UpdateUser: { success: true },
+  GetEnrichedBoltwallUsers: { users: [] },
+  UpdateNeo4jConfig: { success: true },
+  UpdateEnv: { success: true },
   GetBoltwallAccessibility: { isPublic: false },
   UpdateBoltwallAccessibility: { success: true },
   ListPaidEndpoint: {
@@ -34,7 +55,6 @@ const MOCK_RESPONSES: Record<string, unknown> = {
     ],
   },
   UpdatePaidEndpoint: { success: true },
-  GetBotBalance: { success: true, message: "bot balance retrieved", data: { msat: 30000 } },
   GetSecondBrainAboutDetails: { title: "mock-graph", description: "" },
   UpdateSecondBrainAbout: { success: true },
 };
@@ -56,7 +76,7 @@ export async function GET(request: NextRequest) {
     return NextResponse.json({ error: "Missing txt param" }, { status: 400 });
   }
 
-  let parsed: { cmd?: string; data?: { cmd?: string } };
+  let parsed: { type?: string; cmd?: string; data?: { cmd?: string; content?: unknown }; content?: unknown };
   try {
     parsed = JSON.parse(txt);
   } catch {
@@ -66,7 +86,44 @@ export async function GET(request: NextRequest) {
   // SwarmCmd shape: { type: "Swarm", data: { cmd: "..." } }
   // Fall back to top-level .cmd for legacy callers
   const cmd = parsed.data?.cmd ?? parsed.cmd;
-  if (!cmd || !(cmd in MOCK_RESPONSES)) {
+  const content = parsed.data?.content ?? parsed.content;
+
+  if (!cmd) {
+    return NextResponse.json({ error: "Unknown cmd: undefined" }, { status: 400 });
+  }
+
+  // ---------------------------------------------------------------------------
+  // Stateful boltwall commands
+  // ---------------------------------------------------------------------------
+  if (cmd === "GetBoltwallAccessibility") {
+    return NextResponse.json({ isPublic: mockIsPublic });
+  }
+
+  if (cmd === "UpdateBoltwallAccessibility") {
+    setMockIsPublic(Boolean(content));
+    return NextResponse.json({ success: true });
+  }
+
+  if (cmd === "ListPaidEndpoint") {
+    return NextResponse.json({ endpoints: mockEndpoints });
+  }
+
+  if (cmd === "UpdatePaidEndpoint") {
+    const update = content as { id?: number; status?: boolean } | undefined;
+    if (update?.id !== undefined) {
+      setMockEndpoints(
+        mockEndpoints.map((ep) =>
+          ep.id === update.id ? { ...ep, status: Boolean(update.status) } : ep
+        )
+      );
+    }
+    return NextResponse.json({ success: true });
+  }
+
+  // ---------------------------------------------------------------------------
+  // Static responses
+  // ---------------------------------------------------------------------------
+  if (!(cmd in MOCK_RESPONSES)) {
     return NextResponse.json({ error: `Unknown cmd: ${cmd}` }, { status: 400 });
   }
 

src/app/api/mock/swarm-super-admin/api/cmd/state.ts

@@ -0,0 +1,32 @@
+// ---------------------------------------------------------------------------
+// Mutable boltwall state (reset between tests via resetMockBoltwallState)
+// ---------------------------------------------------------------------------
+export interface PaidEndpoint {
+  id: number;
+  route: string;
+  method: string;
+  status: boolean;
+  fee: number;
+}
+
+export let mockIsPublic = false;
+export let mockEndpoints: PaidEndpoint[] = [
+  { id: 1, route: "v2/search", method: "GET", status: true, fee: 10 },
+  { id: 2, route: "node/content", method: "POST", status: true, fee: 10 },
+];
+
+export function resetMockBoltwallState() {
+  mockIsPublic = false;
+  mockEndpoints = [
+    { id: 1, route: "v2/search", method: "GET", status: true, fee: 10 },
+    { id: 2, route: "node/content", method: "POST", status: true, fee: 10 },
+  ];
+}
+
+export function setMockIsPublic(value: boolean) {
+  mockIsPublic = value;
+}
+
+export function setMockEndpoints(endpoints: PaidEndpoint[]) {
+  mockEndpoints = endpoints;
+}

src/lib/auth/nextauth.ts

@@ -1,7 +1,7 @@
 import { db } from "@/lib/db";
 import { EncryptionService } from "@/lib/encryption";
 import { logger } from "@/lib/logger";
-import { ensureMockWorkspaceForUser, ensureStakworkMockWorkspace, ensureMockOrgData } from "@/utils/mockSetup";
+import { ensureMockWorkspaceForUser, ensureStakworkMockWorkspace, ensureMockOrgData, ensureGraphMindsetMockWorkspace } from "@/utils/mockSetup";
 import { isSuperAdminUserId } from "@/config/env";
 import { PrismaAdapter } from "@auth/prisma-adapter";
 import axios from "axios";
@@ -271,6 +271,17 @@ export const authOptions: NextAuthOptions = {
               error
             );
           }
+
+          // Create graph_mindset workspace for testing /graph-admin — non-fatal
+          try {
+            await ensureGraphMindsetMockWorkspace(user.id as string);
+          } catch (error) {
+            logger.authError(
+              "Failed to create graph_mindset mock workspace - continuing authentication",
+              "SIGNIN_GRAPH_MINDSET_FAILED",
+              error
+            );
+          }
         } catch (error) {
           logger.authError("Failed to handle mock authentication", "SIGNIN_MOCK", error);
           return false;