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

.github/workflows/deployPR.yml

@@ -155,6 +155,16 @@ jobs:
           ENDPOINTS_JSON=$(neon_curl "https://console.neon.tech/api/v2/projects/$NEON_PROJECT_ID/endpoints" "endpoints")
           ENDPOINT_ID=$(echo "$ENDPOINTS_JSON" | jq -r ".endpoints[] | select(.branch_id==\"$BRANCH_ID\") | .id")
 
+          # Validate the cached endpoint is still accessible (it may have been deleted since list was fetched)
+          if [ -n "$ENDPOINT_ID" ] && [ "$ENDPOINT_ID" != "null" ]; then
+            VALIDATE_RESP=$(curl -s -H "Authorization: Bearer $NEON_API_KEY" \
+              "https://console.neon.tech/api/v2/projects/$NEON_PROJECT_ID/endpoints/$ENDPOINT_ID")
+            if ! echo "$VALIDATE_RESP" | jq -e '.endpoint' > /dev/null 2>&1; then
+              echo "⚠️  Endpoint $ENDPOINT_ID found in list but no longer accessible, will create a new one"
+              ENDPOINT_ID=""
+            fi
+          fi
+
           if [ -z "$ENDPOINT_ID" ] || [ "$ENDPOINT_ID" = "null" ]; then
             # Try to create a new endpoint first
             RESPONSE=$(curl -s -H "Authorization: Bearer $NEON_API_KEY" \
@@ -192,7 +202,11 @@ jobs:
 
           # Wait until endpoint is ready (GET endpoint does not return credentials)
           for i in {1..30}; do
-            STATUS=$(neon_curl "https://console.neon.tech/api/v2/projects/$NEON_PROJECT_ID/endpoints/$ENDPOINT_ID" "endpoint")
+            STATUS=$(neon_curl "https://console.neon.tech/api/v2/projects/$NEON_PROJECT_ID/endpoints/$ENDPOINT_ID" "endpoint") || {
+              echo "⚠️  Could not poll endpoint status (attempt $i), retrying..."
+              sleep 5
+              continue
+            }
             STATE=$(echo "$STATUS" | jq -r '.endpoint.current_state')
             DB_HOST=$(echo "$STATUS" | jq -r '.endpoint.host')
             if [ "$STATE" = "ready" ] && [ -n "$DB_HOST" ] && [ "$DB_HOST" != "null" ]; then

src/__tests__/integration/api/github/webhook-pr-merged-notification.test.ts

@@ -132,8 +132,8 @@ describe("GitHub Webhook — TASK_PR_MERGED notification", () => {
     // Route should succeed
     expect([200, 202]).toContain(res.status);
 
-    // Allow async notification to settle
-    await new Promise((r) => setTimeout(r, 300));
+    // Allow async notification to settle (fire-and-forget block runs several DB queries)
+    await new Promise((r) => setTimeout(r, 2000));
 
     const record = await db.notificationTrigger.findFirst({
       where: {

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/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 } },
   GetBoltwallUsers: {
     users: [
       { id: 1, pubkey: "03superadmin0000000000000000000000000000000000000000000000000000001", name: "Super Admin", role: "admin" },
@@ -63,7 +83,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 {
@@ -73,7 +93,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;
+}