vibepulse 0.2.2 → 0.3.1-beta

package/.next/standalone/src/app/api/node/sessions/[id]/archive/route.test.ts

@@ -5,16 +5,28 @@ vi.mock('@/lib/opencodeDiscovery', () => ({
 }));
 
 vi.mock('@/lib/sessionArchiveOverrides', () => ({
+  clearSessionStickyStatusBlocked: vi.fn(),
   clearSessionForceUnarchived: vi.fn(),
+  markSessionForceUnarchived: vi.fn(),
   markSessionStickyStatusBlocked: vi.fn(),
 }));
 
 import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
 import { createNodeRequestHeaders } from '@/lib/nodeProtocol';
+import {
+  clearSessionStickyStatusBlocked,
+  clearSessionForceUnarchived,
+  markSessionForceUnarchived,
+  markSessionStickyStatusBlocked,
+} from '@/lib/sessionArchiveOverrides';
 
-import { POST } from './route';
+import { DELETE, POST } from './route';
 
 const mockDiscoverOpencodePortsWithMeta: any = discoverOpencodePortsWithMeta;
+const mockClearSessionStickyStatusBlocked: any = clearSessionStickyStatusBlocked;
+const mockClearSessionForceUnarchived: any = clearSessionForceUnarchived;
+const mockMarkSessionForceUnarchived: any = markSessionForceUnarchived;
+const mockMarkSessionStickyStatusBlocked: any = markSessionStickyStatusBlocked;
 
 describe('/api/node/sessions/[id]/archive', () => {
   const originalRuntimeRole = process.env.VIBEPULSE_RUNTIME_ROLE;
@@ -52,6 +64,53 @@ describe('/api/node/sessions/[id]/archive', () => {
       'http://localhost:7777/session/ses_123',
       expect.objectContaining({ method: 'PATCH' })
     );
+    expect(mockClearSessionForceUnarchived).toHaveBeenCalledWith('ses_123');
+    expect(mockMarkSessionStickyStatusBlocked).toHaveBeenCalledWith('ses_123');
+  });
+
+  it('restores a node-local session with valid auth', async () => {
+    const response = await DELETE(
+      new Request('http://localhost/api/node/sessions/ses_123/archive', {
+        method: 'DELETE',
+        headers: createNodeRequestHeaders('shared-secret'),
+      }),
+      { params: Promise.resolve({ id: 'ses_123' }) }
+    );
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data).toEqual({ success: true });
+    expect(globalThis.fetch).toHaveBeenCalledWith(
+      'http://localhost:7777/session/ses_123',
+      expect.objectContaining({ method: 'PATCH', body: JSON.stringify({ time: { archived: null } }) })
+    );
+    expect(mockMarkSessionForceUnarchived).toHaveBeenCalledWith('ses_123');
+    expect(mockClearSessionStickyStatusBlocked).toHaveBeenCalledWith('ses_123');
+  });
+
+  it('does not mutate restore overrides when upstream restore fails', async () => {
+    Object.defineProperty(globalThis, 'fetch', {
+      value: vi.fn(async () => new Response(JSON.stringify({ error: 'boom' }), { status: 500 })),
+      configurable: true,
+    });
+
+    const response = await DELETE(
+      new Request('http://localhost/api/node/sessions/ses_123/archive', {
+        method: 'DELETE',
+        headers: createNodeRequestHeaders('shared-secret'),
+      }),
+      { params: Promise.resolve({ id: 'ses_123' }) }
+    );
+    const data = await response.json();
+
+    expect(response.status).toBe(500);
+    expect(data).toEqual({
+      error: 'Failed to restore session',
+      reason: 'node_request_failed_500',
+      message: JSON.stringify({ error: 'boom' }),
+    });
+    expect(mockMarkSessionForceUnarchived).not.toHaveBeenCalled();
+    expect(mockClearSessionStickyStatusBlocked).not.toHaveBeenCalled();
   });
 
   it('rejects invalid auth before mutating', async () => {

package/.next/standalone/src/app/api/node/sessions/[id]/archive/route.ts

@@ -5,7 +5,9 @@ import {
   toNodeRequestGuardResponse,
 } from '@/lib/nodeProtocol';
 import {
+  clearSessionStickyStatusBlocked,
   clearSessionForceUnarchived,
+  markSessionForceUnarchived,
   markSessionStickyStatusBlocked,
 } from '@/lib/sessionArchiveOverrides';
 
@@ -20,28 +22,34 @@ function resolveNodeLocalSessionId(id: string): string | null {
 
 export const dynamic = 'force-dynamic';
 
-export async function POST(request: Request, { params }: { params: Promise<{ id: string }> }) {
-  const guardResult = guardNodeRequest(request);
-  if (!guardResult.ok) {
-    return toNodeRequestGuardResponse(guardResult);
-  }
-
-  const { id } = await params;
-  const sessionId = resolveNodeLocalSessionId(id);
+function createInvalidNodeSessionIdResponse() {
+  return Response.json({ error: 'Invalid node session id' }, { status: 400 });
+}
 
-  if (!sessionId) {
-    return Response.json({ error: 'Invalid node session id' }, { status: 400 });
-  }
+function createNodeUpstreamUnavailableResponse(timedOut: boolean) {
+  return createNodeFailureResponse(timedOut ? 'upstream_timeout' : 'upstream_unreachable', {
+    role: 'node',
+    upstream: {
+      kind: 'opencode',
+      reachable: false,
+    },
+  });
+}
 
+async function runArchiveMutation({
+  sessionId,
+  archived,
+  failureMessage,
+  onSuccess,
+}: {
+  sessionId: string;
+  archived: number | null;
+  failureMessage: string;
+  onSuccess: () => void;
+}): Promise<Response> {
   const { ports, timedOut } = discoverOpencodePortsWithMeta();
   if (!ports.length) {
-    return createNodeFailureResponse(timedOut ? 'upstream_timeout' : 'upstream_unreachable', {
-      role: 'node',
-      upstream: {
-        kind: 'opencode',
-        reachable: false,
-      },
-    });
+    return createNodeUpstreamUnavailableResponse(timedOut);
   }
 
   let sawNotFound = false;
@@ -55,12 +63,11 @@ export async function POST(request: Request, { params }: { params: Promise<{ id:
         headers: {
           'Content-Type': 'application/json',
         },
-        body: JSON.stringify({ time: { archived: Date.now() } }),
+        body: JSON.stringify({ time: { archived } }),
       });
 
       if (response.ok) {
-        clearSessionForceUnarchived(sessionId);
-        markSessionStickyStatusBlocked(sessionId);
+        onSuccess();
         return Response.json({ success: true });
       }
 
@@ -81,7 +88,7 @@ export async function POST(request: Request, { params }: { params: Promise<{ id:
   if (lastFailureStatus !== null) {
     return Response.json(
       {
-        error: 'Failed to archive session',
+        error: failureMessage,
         reason: lastFailureStatus === 503 ? 'upstream_unreachable' : `node_request_failed_${lastFailureStatus}`,
         ...(lastFailureMessage ? { message: lastFailureMessage } : {}),
       },
@@ -95,3 +102,51 @@ export async function POST(request: Request, { params }: { params: Promise<{ id:
 
   return Response.json({ error: 'Session not found', reason: 'session_not_found' }, { status: 404 });
 }
+
+export async function POST(request: Request, { params }: { params: Promise<{ id: string }> }) {
+  const guardResult = guardNodeRequest(request);
+  if (!guardResult.ok) {
+    return toNodeRequestGuardResponse(guardResult);
+  }
+
+  const { id } = await params;
+  const sessionId = resolveNodeLocalSessionId(id);
+
+  if (!sessionId) {
+    return createInvalidNodeSessionIdResponse();
+  }
+
+  return runArchiveMutation({
+    sessionId,
+    archived: Date.now(),
+    failureMessage: 'Failed to archive session',
+    onSuccess: () => {
+      clearSessionForceUnarchived(sessionId);
+      markSessionStickyStatusBlocked(sessionId);
+    },
+  });
+}
+
+export async function DELETE(request: Request, { params }: { params: Promise<{ id: string }> }) {
+  const guardResult = guardNodeRequest(request);
+  if (!guardResult.ok) {
+    return toNodeRequestGuardResponse(guardResult);
+  }
+
+  const { id } = await params;
+  const sessionId = resolveNodeLocalSessionId(id);
+
+  if (!sessionId) {
+    return createInvalidNodeSessionIdResponse();
+  }
+
+  return runArchiveMutation({
+    sessionId,
+    archived: null,
+    failureMessage: 'Failed to restore session',
+    onSuccess: () => {
+      markSessionForceUnarchived(sessionId);
+      clearSessionStickyStatusBlocked(sessionId);
+    },
+  });
+}

package/.next/standalone/src/app/api/node/sessions/[id]/delete/route.ts

@@ -1,10 +1,10 @@
-import { createOpencodeClient } from '@opencode-ai/sdk';
 import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
 import {
   createNodeFailureResponse,
   guardNodeRequest,
   toNodeRequestGuardResponse,
 } from '@/lib/nodeProtocol';
+import { createVibePulseOpencodeClient, deleteOpencodeSession, formatOpencodeSdkError } from '@/lib/session-providers/opencodeSdkCompat';
 import {
   clearSessionForceUnarchived,
   clearSessionStickyStatusBlocked,
@@ -48,8 +48,8 @@ export async function POST(request: Request, { params }: { params: Promise<{ id:
   const errors: Error[] = [];
   for (const port of ports) {
     try {
-      const client = createOpencodeClient({ baseUrl: `http://localhost:${port}` });
-      await client.session.delete({ path: { id: sessionId } });
+      const client = createVibePulseOpencodeClient(`http://localhost:${port}`);
+      await deleteOpencodeSession(client, sessionId);
       clearSessionForceUnarchived(sessionId);
       clearSessionStickyStatusBlocked(sessionId);
       return Response.json({ success: true });
@@ -58,8 +58,9 @@ export async function POST(request: Request, { params }: { params: Promise<{ id:
     }
   }
 
-  const lastErrorMessage = errors[errors.length - 1]?.message;
-  if (errors.length > 0 && errors.every((error) => /not found|404/i.test(error.message))) {
+  const lastError = errors[errors.length - 1];
+  const lastErrorMessage = lastError ? formatOpencodeSdkError(lastError) : undefined;
+  if (errors.length > 0 && errors.every((error) => /not found|404/i.test(formatOpencodeSdkError(error)))) {
     return Response.json(
       {
         error: 'Session not found',

package/.next/standalone/src/app/api/node/sessions/[id]/open-editor/route.ts

@@ -1,4 +1,3 @@
-import { createOpencodeClient } from '@opencode-ai/sdk';
 import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
 import type { OpenEditorTool } from '@/lib/editorLauncher';
 import { openEditorOnCurrentMachine } from '@/lib/editorLauncher.server';
@@ -7,6 +6,7 @@ import {
   guardNodeRequest,
   toNodeRequestGuardResponse,
 } from '@/lib/nodeProtocol';
+import { createVibePulseOpencodeClient, formatOpencodeSdkError, getOpencodeSession } from '@/lib/session-providers/opencodeSdkCompat';
 
 function resolveNodeLocalSessionId(id: string): string | null {
   const trimmedId = id.trim();
@@ -65,8 +65,8 @@ export async function POST(request: Request, { params }: { params: Promise<{ id:
 
   for (const port of ports) {
     try {
-      const client = createOpencodeClient({ baseUrl: `http://localhost:${port}` });
-      const result = await client.session.get({ path: { id: sessionId } });
+      const client = createVibePulseOpencodeClient(`http://localhost:${port}`);
+      const result = await getOpencodeSession(client, sessionId);
       const directory = result.data?.directory;
 
       if (typeof directory !== 'string' || !directory.trim()) {
@@ -104,8 +104,9 @@ export async function POST(request: Request, { params }: { params: Promise<{ id:
   }
 
   if (errors.length > 0) {
-    const lastErrorMessage = errors[errors.length - 1]?.message;
-    if (errors.every((error) => /not found|404/i.test(error.message))) {
+    const lastError = errors[errors.length - 1];
+    const lastErrorMessage = lastError ? formatOpencodeSdkError(lastError) : undefined;
+    if (errors.every((error) => /not found|404/i.test(formatOpencodeSdkError(error)))) {
       return Response.json({ error: 'Session not found', reason: 'session_not_found' }, { status: 404 });
     }
 

package/.next/standalone/src/app/api/node/sessions/route.test.ts

@@ -13,6 +13,12 @@ vi.mock('@/lib/opencodeConfig', () => ({
   readConfig: vi.fn(),
 }));
 
+vi.mock('@/lib/session-providers/claudeCode', () => ({
+  claudeCodeLocalSessionProvider: {
+    getSessionsResult: vi.fn(),
+  },
+}));
+
 vi.mock('child_process', async () => {
   const execSync = vi.fn();
   return {
@@ -39,6 +45,7 @@ import {
   discoverOpencodeProcessCwdsWithoutPortWithMeta,
 } from '@/lib/opencodeDiscovery';
 import { readConfig } from '@/lib/opencodeConfig';
+import { claudeCodeLocalSessionProvider } from '@/lib/session-providers/claudeCode';
 import { createNodeRequestHeaders } from '@/lib/nodeProtocol';
 
 import { GET } from './route';
@@ -50,6 +57,7 @@ const mockCreateOpencodeClient: any = createOpencodeClient;
 const mockDiscoverPortsWithMeta: any = discoverOpencodePortsWithMeta;
 const mockDiscoverProcessCwdsWithoutPortWithMeta: any = discoverOpencodeProcessCwdsWithoutPortWithMeta;
 const mockReadConfig: any = readConfig;
+const mockClaudeLocalProviderGetSessionsResult: any = claudeCodeLocalSessionProvider.getSessionsResult;
 const mockExecSync: any = execSync;
 
 function resetDefaultClientMock(): void {
@@ -82,6 +90,13 @@ function createNeverResolvingPromise<T>(signal?: AbortSignal): Promise<T> {
 
 function setupLocalSessionsMocks(): void {
   resetDefaultClientMock();
+  mockClaudeLocalProviderGetSessionsResult.mockResolvedValue({
+    payload: {
+      sessions: [],
+      processHints: [],
+    },
+    sourceMeta: { online: false },
+  });
 
   mockReadConfig.mockResolvedValue({
     vibepulse: {
@@ -225,9 +240,276 @@ describe('/api/node/sessions', () => {
       waitingForUser: true,
     });
     expect(JSON.stringify(data).includes('baseUrl')).toBe(false);
+    expect(data.sessions.every((session: any) => session.hostId === 'local')).toBe(true);
+    expect(data.sessions.every((session: any) => !session.baseUrl)).toBe(true);
     expect(mockCreateOpencodeClient.mock.calls).toEqual([[{ baseUrl: 'http://localhost:7777' }]]);
   });
 
+  it('carries nested Claude child topology in node polling payloads with provider-aware local ids', async () => {
+    mockClaudeLocalProviderGetSessionsResult.mockResolvedValue({
+      payload: {
+        sessions: [
+          {
+            id: 'claude~550e8400-e29b-41d4-a716-446655440000',
+            slug: '550e8400-e29b-41d4-a716-446655440000',
+            title: 'Claude Parent',
+            directory: '/repo/project-one',
+            projectName: 'project-one',
+            branch: 'main',
+            provider: 'claude-code',
+            providerRawId: '550e8400-e29b-41d4-a716-446655440000',
+            rawSessionId: '550e8400-e29b-41d4-a716-446655440000',
+            topology: { childSessions: 'authoritative' },
+            readOnly: true,
+            realTimeStatus: 'busy',
+            waitingForUser: false,
+            children: [
+              {
+                id: '660e8400-e29b-41d4-a716-446655440000',
+                parentID: '550e8400-e29b-41d4-a716-446655440000',
+                rawSessionId: '660e8400-e29b-41d4-a716-446655440000',
+                providerRawId: '660e8400-e29b-41d4-a716-446655440000',
+                title: 'Claude Child',
+                directory: '/repo/project-one',
+                realTimeStatus: 'busy',
+                waitingForUser: false,
+                readOnly: true,
+                topology: { childSessions: 'authoritative' },
+                time: { created: 2_100, updated: Date.now() - 900 },
+              },
+            ],
+            time: { created: 2_000, updated: Date.now() - 1_000 },
+          },
+        ],
+        processHints: [],
+      },
+      sourceMeta: { online: true },
+    });
+
+    const response = await GET(
+      new Request('http://localhost/api/node/sessions', {
+        headers: createNodeRequestHeaders('shared-secret'),
+      })
+    );
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data.sessions).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: 'local:parent-1' }),
+        expect.objectContaining({
+          id: 'local:claude~550e8400-e29b-41d4-a716-446655440000',
+          rawSessionId: '550e8400-e29b-41d4-a716-446655440000',
+          sourceSessionKey: 'local:claude~550e8400-e29b-41d4-a716-446655440000',
+          provider: 'claude-code',
+          providerRawId: '550e8400-e29b-41d4-a716-446655440000',
+          readOnly: true,
+          topology: { childSessions: 'authoritative' },
+          children: [
+            expect.objectContaining({
+              id: 'local:claude~660e8400-e29b-41d4-a716-446655440000',
+              rawSessionId: '660e8400-e29b-41d4-a716-446655440000',
+              sourceSessionKey: 'local:claude~660e8400-e29b-41d4-a716-446655440000',
+              parentID: 'local:claude~550e8400-e29b-41d4-a716-446655440000',
+              provider: 'claude-code',
+              providerRawId: '660e8400-e29b-41d4-a716-446655440000',
+              hostId: 'local',
+              hostLabel: 'Local',
+              hostKind: 'local',
+              readOnly: true,
+              topology: { childSessions: 'authoritative' },
+            }),
+          ],
+        }),
+      ])
+    );
+  });
+
+  it('keeps flat Claude polling payloads backward-compatible when provider metadata is sparse', async () => {
+    mockClaudeLocalProviderGetSessionsResult.mockResolvedValue({
+      payload: {
+        sessions: [
+          {
+            id: 'claude~550e8400-e29b-41d4-a716-446655440000',
+            slug: '550e8400-e29b-41d4-a716-446655440000',
+            title: 'Claude Flat Session',
+            directory: '/repo/project-one',
+            projectName: 'project-one',
+            branch: 'main',
+            realTimeStatus: 'idle',
+            waitingForUser: false,
+            readOnly: true,
+            children: [],
+            time: { created: 3_000, updated: Date.now() - 1_500 },
+          },
+        ],
+        processHints: [],
+      },
+      sourceMeta: { online: true },
+    });
+
+    const response = await GET(
+      new Request('http://localhost/api/node/sessions', {
+        headers: createNodeRequestHeaders('shared-secret'),
+      })
+    );
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data.sessions).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: 'local:claude~550e8400-e29b-41d4-a716-446655440000',
+          rawSessionId: '550e8400-e29b-41d4-a716-446655440000',
+          sourceSessionKey: 'local:claude~550e8400-e29b-41d4-a716-446655440000',
+          provider: 'claude-code',
+          providerRawId: '550e8400-e29b-41d4-a716-446655440000',
+          readOnly: true,
+          children: [],
+        }),
+      ])
+    );
+  });
+
+  it('returns Claude polling sessions when OpenCode ports are absent but Claude provider is available', async () => {
+    mockDiscoverProcessCwdsWithoutPortWithMeta.mockReturnValue({
+      processes: [],
+      timedOut: false,
+    });
+    mockDiscoverPortsWithMeta.mockReturnValue({
+      ports: [],
+      timedOut: false,
+    });
+    mockClaudeLocalProviderGetSessionsResult.mockResolvedValue({
+      payload: {
+        sessions: [
+          {
+            id: 'claude~550e8400-e29b-41d4-a716-446655440000',
+            slug: '550e8400-e29b-41d4-a716-446655440000',
+            title: 'Claude Only Session',
+            directory: '/repo/claude-only-project',
+            projectName: 'claude-only-project',
+            branch: 'main',
+            provider: 'claude-code',
+            providerRawId: '550e8400-e29b-41d4-a716-446655440000',
+            rawSessionId: '550e8400-e29b-41d4-a716-446655440000',
+            readOnly: true,
+            topology: { childSessions: 'flat' },
+            realTimeStatus: 'busy',
+            waitingForUser: false,
+            children: [],
+            time: { created: 4_000, updated: Date.now() - 1_000 },
+          },
+        ],
+        processHints: [],
+      },
+      sourceMeta: { online: true },
+    });
+
+    const response = await GET(
+      new Request('http://localhost/api/node/sessions', {
+        headers: createNodeRequestHeaders('shared-secret'),
+      })
+    );
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data).toMatchObject({
+      ok: true,
+      role: 'node',
+      protocolVersion: '1',
+      source: { hostId: 'local', hostLabel: 'Local', hostKind: 'local' },
+      upstream: { kind: 'opencode', reachable: true },
+      processHints: [],
+      hosts: [{ hostId: 'local', hostLabel: 'Local', hostKind: 'local', online: true }],
+      hostStatuses: [{ hostId: 'local', hostLabel: 'Local', hostKind: 'local', online: true }],
+    });
+    expect(data.sessions).toEqual([
+      expect.objectContaining({
+        id: 'local:claude~550e8400-e29b-41d4-a716-446655440000',
+        rawSessionId: '550e8400-e29b-41d4-a716-446655440000',
+        sourceSessionKey: 'local:claude~550e8400-e29b-41d4-a716-446655440000',
+        provider: 'claude-code',
+        providerRawId: '550e8400-e29b-41d4-a716-446655440000',
+        hostId: 'local',
+        hostLabel: 'Local',
+        hostKind: 'local',
+        readOnly: true,
+        topology: { childSessions: 'flat' },
+        children: [],
+      }),
+    ]);
+    expect(mockCreateOpencodeClient).not.toHaveBeenCalled();
+  });
+
+  it('returns degraded Claude fallback sessions when all discovered OpenCode ports fail', async () => {
+    setupLocalSessionsMocks();
+    mockDiscoverPortsWithMeta.mockReturnValue({
+      ports: [7777, 7778],
+      timedOut: false,
+    });
+    mockSessionList.mockRejectedValue(new Error('ECONNREFUSED'));
+    mockClaudeLocalProviderGetSessionsResult.mockResolvedValue({
+      payload: {
+        sessions: [
+          {
+            id: 'claude~550e8400-e29b-41d4-a716-446655440000',
+            slug: '550e8400-e29b-41d4-a716-446655440000',
+            title: 'Claude Fallback Session',
+            directory: '/repo/claude-fallback',
+            projectName: 'claude-fallback',
+            branch: 'main',
+            provider: 'claude-code',
+            providerRawId: '550e8400-e29b-41d4-a716-446655440000',
+            rawSessionId: '550e8400-e29b-41d4-a716-446655440000',
+            readOnly: true,
+            topology: { childSessions: 'flat' },
+            realTimeStatus: 'busy',
+            waitingForUser: false,
+            children: [],
+            time: { created: 5_000, updated: Date.now() - 1_000 },
+          },
+        ],
+        processHints: [],
+      },
+      sourceMeta: { online: true },
+    });
+
+    const response = await GET(
+      new Request('http://localhost/api/node/sessions', {
+        headers: createNodeRequestHeaders('shared-secret'),
+      })
+    );
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data.degraded).toBe(true);
+    expect(data.failedPorts).toEqual([
+      expect.objectContaining({ port: 7777 }),
+      expect.objectContaining({ port: 7778 }),
+    ]);
+    expect(data.sessions).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: 'local:claude~550e8400-e29b-41d4-a716-446655440000',
+          provider: 'claude-code',
+          sourceSessionKey: 'local:claude~550e8400-e29b-41d4-a716-446655440000',
+        }),
+      ])
+    );
+    expect(data.hostStatuses).toEqual([
+      expect.objectContaining({
+        hostId: 'local',
+        online: true,
+        degraded: true,
+      }),
+    ]);
+    expect(mockCreateOpencodeClient.mock.calls).toEqual([
+      [{ baseUrl: 'http://localhost:7777' }],
+      [{ baseUrl: 'http://localhost:7778' }],
+    ]);
+  });
+
   it('rejects unauthenticated requests before running discovery', async () => {
     const response = await GET(
       new Request('http://localhost/api/node/sessions', {