vibepulse 0.1.12 → 0.2.1

package/.next/standalone/src/app/api/nodes/route.test.ts

@@ -0,0 +1,237 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mkdtemp, rm } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+describe('/api/nodes route', () => {
+  let testHomeDir: string;
+  let originalHome: string | undefined;
+  let originalRuntimeRole: string | undefined;
+  let route: typeof import('./route');
+  let nodeRegistry: typeof import('@/lib/nodeRegistry');
+
+  beforeEach(async () => {
+    vi.resetModules();
+    testHomeDir = await mkdtemp(join(tmpdir(), 'vibepulse-api-nodes-'));
+    originalHome = process.env.HOME;
+    originalRuntimeRole = process.env.VIBEPULSE_RUNTIME_ROLE;
+    process.env.HOME = testHomeDir;
+    process.env.VIBEPULSE_RUNTIME_ROLE = 'hub';
+
+    route = await import('./route');
+    nodeRegistry = await import('@/lib/nodeRegistry');
+  });
+
+  afterEach(async () => {
+    process.env.HOME = originalHome;
+    process.env.VIBEPULSE_RUNTIME_ROLE = originalRuntimeRole;
+    await rm(testHomeDir, { recursive: true, force: true });
+  });
+
+  it('rejects node registry access while running in node mode', async () => {
+    process.env.VIBEPULSE_RUNTIME_ROLE = 'node';
+
+    const listResponse = await route.GET();
+    const listData = await listResponse.json();
+    expect(listResponse.status).toBe(404);
+    expect(listData).toEqual({ error: 'Route unavailable in node mode' });
+
+    const createResponse = await route.POST(
+      new Request('http://localhost/api/nodes', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+          nodeLabel: 'Blocked Node',
+          baseUrl: 'https://blocked.example.com',
+          token: 'blocked',
+          enabled: true,
+        }),
+      }) as never
+    );
+    const createData = await createResponse.json();
+    expect(createResponse.status).toBe(404);
+    expect(createData).toEqual({ error: 'Route unavailable in node mode' });
+  });
+
+  it('creates and lists sanitized nodes while persisting tokens server-side', async () => {
+    const createResponse = await route.POST(
+      new Request('http://localhost/api/nodes', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+          nodeLabel: 'Primary Node',
+          baseUrl: 'https://primary-node.example.com/',
+          token: 'secret-token',
+          enabled: true,
+        }),
+      }) as never
+    );
+    const createData = await createResponse.json();
+
+    expect(createResponse.status).toBe(201);
+    expect(createData.node).toMatchObject({
+      nodeLabel: 'Primary Node',
+      baseUrl: 'https://primary-node.example.com',
+      enabled: true,
+      tokenConfigured: true,
+    });
+    expect(createData.node.token).toBeUndefined();
+
+    const stored = await nodeRegistry.listNodeRecords();
+    expect(stored).toHaveLength(1);
+    expect(stored[0].token).toBe('secret-token');
+
+    const listResponse = await route.GET();
+    const listData = await listResponse.json();
+
+    expect(listResponse.status).toBe(200);
+    expect(listData.nodes).toHaveLength(1);
+    expect(listData.nodes[0].token).toBeUndefined();
+    expect(listData.nodes[0].tokenConfigured).toBe(true);
+  });
+
+  it('rejects duplicate normalized baseUrl submissions with explicit validation error', async () => {
+    await route.POST(
+      new Request('http://localhost/api/nodes', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+          nodeLabel: 'Node A',
+          baseUrl: 'https://dup-node.example.com',
+          token: 'token-a',
+        }),
+      }) as never
+    );
+
+    const duplicateResponse = await route.POST(
+      new Request('http://localhost/api/nodes', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+          nodeLabel: 'Node B',
+          baseUrl: 'https://dup-node.example.com/',
+          token: 'token-b',
+        }),
+      }) as never
+    );
+    const duplicateData = await duplicateResponse.json();
+
+    expect(duplicateResponse.status).toBe(409);
+    expect(duplicateData.code).toBe('duplicate_base_url');
+    expect(duplicateData.error).toContain('already exists');
+  });
+
+  it('rejects malformed URLs and allows blank token input', async () => {
+    const malformedResponse = await route.POST(
+      new Request('http://localhost/api/nodes', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+          nodeLabel: 'Malformed URL Node',
+          baseUrl: 'ftp://bad.example.com',
+          token: 'token',
+        }),
+      }) as never
+    );
+    const malformedData = await malformedResponse.json();
+
+    expect(malformedResponse.status).toBe(400);
+    expect(malformedData.code).toBe('invalid_base_url');
+    expect(malformedData.error).toContain('unsupported_protocol');
+
+    const blankTokenResponse = await route.POST(
+      new Request('http://localhost/api/nodes', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+          nodeLabel: 'Blank Token Node',
+          baseUrl: 'https://blank-token.example.com',
+          token: '  ',
+        }),
+      }) as never
+    );
+    const blankTokenData = await blankTokenResponse.json();
+
+    expect(blankTokenResponse.status).toBe(201);
+    expect(blankTokenData.node).toMatchObject({
+      nodeLabel: 'Blank Token Node',
+      baseUrl: 'https://blank-token.example.com',
+      tokenConfigured: false,
+    });
+
+    const stored = await nodeRegistry.listNodeRecords();
+    const blankTokenNode = stored.find((node) => node.baseUrl === 'https://blank-token.example.com');
+    expect(blankTokenNode?.token).toBe('');
+  });
+
+  it('updates, toggles, and deletes a node', async () => {
+    const createResponse = await route.POST(
+      new Request('http://localhost/api/nodes', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+          nodeLabel: 'Mutable Node',
+          baseUrl: 'https://mutable-node.example.com',
+          token: 'token-1',
+          enabled: true,
+        }),
+      }) as never
+    );
+    const createData = await createResponse.json();
+    const nodeId = createData.node.nodeId as string;
+
+    const updateResponse = await route.PUT(
+      new Request('http://localhost/api/nodes', {
+        method: 'PUT',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+          nodeId,
+          nodeLabel: 'Mutable Node Updated',
+          baseUrl: 'https://mutable-node-updated.example.com/',
+          token: 'token-2',
+          enabled: false,
+        }),
+      }) as never
+    );
+    const updateData = await updateResponse.json();
+
+    expect(updateResponse.status).toBe(200);
+    expect(updateData.node).toMatchObject({
+      nodeId,
+      nodeLabel: 'Mutable Node Updated',
+      baseUrl: 'https://mutable-node-updated.example.com',
+      enabled: false,
+      tokenConfigured: true,
+    });
+    expect(updateData.node.token).toBeUndefined();
+
+    const toggleResponse = await route.PATCH(
+      new Request('http://localhost/api/nodes', {
+        method: 'PATCH',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ nodeId }),
+      }) as never
+    );
+    const toggleData = await toggleResponse.json();
+
+    expect(toggleResponse.status).toBe(200);
+    expect(toggleData.node.enabled).toBe(true);
+    expect(toggleData.node.token).toBeUndefined();
+
+    const deleteResponse = await route.DELETE(
+      new Request('http://localhost/api/nodes', {
+        method: 'DELETE',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ nodeId }),
+      }) as never
+    );
+    const deleteData = await deleteResponse.json();
+
+    expect(deleteResponse.status).toBe(200);
+    expect(deleteData).toEqual({ deleted: true, nodeId });
+
+    const listResponse = await route.GET();
+    const listData = await listResponse.json();
+    expect(listData.nodes).toEqual([]);
+  });
+});

package/.next/standalone/src/app/api/nodes/route.ts

@@ -0,0 +1,176 @@
+import { NextRequest, NextResponse } from 'next/server';
+import {
+  NodeRegistryError,
+  createNode,
+  deleteNode,
+  listNodes,
+  toggleNode,
+  updateNode,
+} from '@/lib/nodeRegistry';
+import { RUNTIME_ROLE_ENV_VAR } from '@/lib/runtimeMode';
+
+function requireHubRuntime(): NextResponse | null {
+  if (process.env[RUNTIME_ROLE_ENV_VAR] === 'node') {
+    return NextResponse.json({ error: 'Route unavailable in node mode' }, { status: 404 });
+  }
+
+  return null;
+}
+
+function mapRegistryError(error: NodeRegistryError): { status: number; payload: Record<string, unknown> } {
+  if (error.code === 'node_not_found') {
+    return {
+      status: 404,
+      payload: {
+        error: error.message,
+        code: error.code,
+      },
+    };
+  }
+
+  if (error.code === 'duplicate_base_url') {
+    return {
+      status: 409,
+      payload: {
+        error: error.message,
+        code: error.code,
+      },
+    };
+  }
+
+  return {
+    status: 400,
+    payload: {
+      error: error.message,
+      code: error.code,
+    },
+  };
+}
+
+function handleUnknownError(error: unknown, fallbackMessage: string): NextResponse {
+  if (error instanceof NodeRegistryError) {
+    const mapped = mapRegistryError(error);
+    return NextResponse.json(mapped.payload, { status: mapped.status });
+  }
+
+  console.error(fallbackMessage, error);
+  return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+}
+
+async function parseJsonBody(request: NextRequest): Promise<Record<string, unknown> | null> {
+  try {
+    const body = await request.json();
+    if (!body || typeof body !== 'object' || Array.isArray(body)) {
+      return null;
+    }
+    return body as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+}
+
+export async function GET() {
+  const guardResponse = requireHubRuntime();
+  if (guardResponse) {
+    return guardResponse;
+  }
+
+  try {
+    const nodes = await listNodes();
+    return NextResponse.json({ nodes });
+  } catch (error) {
+    return handleUnknownError(error, 'Error listing nodes:');
+  }
+}
+
+export async function POST(request: NextRequest) {
+  const guardResponse = requireHubRuntime();
+  if (guardResponse) {
+    return guardResponse;
+  }
+
+  const body = await parseJsonBody(request);
+  if (!body) {
+    return NextResponse.json({ error: 'Invalid request body' }, { status: 400 });
+  }
+
+  try {
+    const node = await createNode({
+      nodeLabel: body.nodeLabel as string,
+      baseUrl: body.baseUrl as string,
+      token: body.token as string,
+      enabled: body.enabled as boolean | undefined,
+    });
+
+    return NextResponse.json({ node }, { status: 201 });
+  } catch (error) {
+    return handleUnknownError(error, 'Error creating node:');
+  }
+}
+
+export async function PUT(request: NextRequest) {
+  const guardResponse = requireHubRuntime();
+  if (guardResponse) {
+    return guardResponse;
+  }
+
+  const body = await parseJsonBody(request);
+  if (!body) {
+    return NextResponse.json({ error: 'Invalid request body' }, { status: 400 });
+  }
+
+  try {
+    const node = await updateNode(body.nodeId, {
+      nodeLabel: body.nodeLabel as string | undefined,
+      baseUrl: body.baseUrl as string | undefined,
+      token: body.token as string | undefined,
+      enabled: body.enabled as boolean | undefined,
+    });
+
+    return NextResponse.json({ node });
+  } catch (error) {
+    return handleUnknownError(error, 'Error updating node:');
+  }
+}
+
+export async function PATCH(request: NextRequest) {
+  const guardResponse = requireHubRuntime();
+  if (guardResponse) {
+    return guardResponse;
+  }
+
+  const body = await parseJsonBody(request);
+  if (!body) {
+    return NextResponse.json({ error: 'Invalid request body' }, { status: 400 });
+  }
+
+  try {
+    const node = await toggleNode(body.nodeId, body.enabled);
+    return NextResponse.json({ node });
+  } catch (error) {
+    return handleUnknownError(error, 'Error toggling node:');
+  }
+}
+
+export async function DELETE(request: NextRequest) {
+  const guardResponse = requireHubRuntime();
+  if (guardResponse) {
+    return guardResponse;
+  }
+
+  const body = await parseJsonBody(request);
+  if (!body) {
+    return NextResponse.json({ error: 'Invalid request body' }, { status: 400 });
+  }
+
+  try {
+    const deleted = await deleteNode(body.nodeId);
+    if (!deleted) {
+      return NextResponse.json({ error: `Node '${String(body.nodeId)}' not found`, code: 'node_not_found' }, { status: 404 });
+    }
+
+    return NextResponse.json({ deleted: true, nodeId: body.nodeId });
+  } catch (error) {
+    return handleUnknownError(error, 'Error deleting node:');
+  }
+}

package/.next/standalone/src/app/api/opencode-config/route.test.ts

@@ -0,0 +1,86 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('@/lib/opencodeConfig', async () => {
+  const actual = await vi.importActual<typeof import('@/lib/opencodeConfig')>('@/lib/opencodeConfig');
+  return {
+    ...actual,
+    readConfig: vi.fn(),
+    writeConfig: vi.fn(),
+  };
+});
+
+import { readConfig, writeConfig } from '@/lib/opencodeConfig';
+import { GET, POST } from './route';
+
+const mockReadConfig = vi.mocked(readConfig);
+const mockWriteConfig = vi.mocked(writeConfig);
+
+describe('/api/opencode-config', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('returns remote as the default openEditorTargetMode when vibepulse config is missing', async () => {
+    mockReadConfig.mockResolvedValue({});
+
+    const response = await GET();
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data.vibepulse).toEqual({ openEditorTargetMode: 'remote' });
+  });
+
+  it('rejects invalid openEditorTargetMode updates', async () => {
+    mockReadConfig.mockResolvedValue({ vibepulse: { stickyBusyDelayMs: 1000 } });
+
+    const response = await POST(new Request('http://localhost/api/opencode-config', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        vibepulse: {
+          openEditorTargetMode: 'desktop',
+        },
+      }),
+    }) as never);
+    const data = await response.json();
+
+    expect(response.status).toBe(400);
+    expect(data.error).toContain('openEditorTargetMode');
+    expect(mockWriteConfig).not.toHaveBeenCalled();
+  });
+
+  it('persists a valid openEditorTargetMode update', async () => {
+    mockReadConfig.mockResolvedValue({
+      vibepulse: {
+        stickyBusyDelayMs: 1000,
+        sessionsRefreshIntervalMs: 5000,
+      },
+    });
+    mockWriteConfig.mockResolvedValue();
+
+    const response = await POST(new Request('http://localhost/api/opencode-config', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        vibepulse: {
+          openEditorTargetMode: 'hub',
+        },
+      }),
+    }) as never);
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data.vibepulse).toEqual({
+      stickyBusyDelayMs: 1000,
+      sessionsRefreshIntervalMs: 5000,
+      openEditorTargetMode: 'hub',
+    });
+    expect(mockWriteConfig).toHaveBeenCalledWith(expect.objectContaining({
+      vibepulse: {
+        stickyBusyDelayMs: 1000,
+        sessionsRefreshIntervalMs: 5000,
+        openEditorTargetMode: 'hub',
+      },
+    }));
+  });
+});