vibepulse 0.2.0 → 0.2.1

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

@@ -0,0 +1,190 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('@/lib/opencodeDiscovery', () => ({
+  discoverOpencodePortsWithMeta: vi.fn(),
+}));
+
+import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
+import { createNodeRequestHeaders } from '@/lib/nodeProtocol';
+
+import { GET } from './route';
+
+const mockDiscoverOpencodePortsWithMeta: any = discoverOpencodePortsWithMeta;
+
+describe('/api/node/health', () => {
+  const originalRuntimeRole = process.env.VIBEPULSE_RUNTIME_ROLE;
+  const originalNodeToken = process.env.VIBEPULSE_NODE_TOKEN;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    process.env.VIBEPULSE_RUNTIME_ROLE = 'node';
+    process.env.VIBEPULSE_NODE_TOKEN = 'shared-secret';
+    mockDiscoverOpencodePortsWithMeta.mockReturnValue({ ports: [7777], timedOut: false });
+  });
+
+  afterEach(() => {
+    process.env.VIBEPULSE_RUNTIME_ROLE = originalRuntimeRole;
+    process.env.VIBEPULSE_NODE_TOKEN = originalNodeToken;
+  });
+
+  it('returns 200 only for valid node-mode authenticated requests', async () => {
+    const response = await GET(new Request('http://localhost/api/node/health', {
+      headers: createNodeRequestHeaders('shared-secret'),
+    }));
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data).toEqual({
+      ok: true,
+      role: 'node',
+      protocolVersion: '1',
+      upstream: {
+        kind: 'opencode',
+        reachable: true,
+      },
+    });
+  });
+
+  it('rejects requests without bearer auth', async () => {
+    const response = await GET(new Request('http://localhost/api/node/health', {
+      headers: { 'x-vibepulse-node-version': '1' },
+    }));
+    const data = await response.json();
+
+    expect(response.status).toBe(401);
+    expect(data).toEqual({
+      ok: false,
+      reason: 'unauthorized',
+      protocolVersion: '1',
+    });
+    expect(mockDiscoverOpencodePortsWithMeta.mock.calls).toHaveLength(0);
+  });
+
+  it('accepts requests without bearer auth when node token is unset', async () => {
+    process.env.VIBEPULSE_NODE_TOKEN = '   ';
+
+    const response = await GET(new Request('http://localhost/api/node/health', {
+      headers: { 'x-vibepulse-node-version': '1' },
+    }));
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data).toEqual({
+      ok: true,
+      role: 'node',
+      protocolVersion: '1',
+      upstream: {
+        kind: 'opencode',
+        reachable: true,
+      },
+    });
+  });
+
+  it('rejects requests with the wrong bearer token', async () => {
+    const response = await GET(new Request('http://localhost/api/node/health', {
+      headers: createNodeRequestHeaders('wrong-secret'),
+    }));
+    const data = await response.json();
+
+    expect(response.status).toBe(401);
+    expect(data.reason).toBe('unauthorized');
+    expect(mockDiscoverOpencodePortsWithMeta.mock.calls).toHaveLength(0);
+  });
+
+  it('rejects requests without the required protocol version header', async () => {
+    const response = await GET(new Request('http://localhost/api/node/health', {
+      headers: { authorization: 'Bearer shared-secret' },
+    }));
+    const data = await response.json();
+
+    expect(response.status).toBe(426);
+    expect(data).toEqual({
+      ok: false,
+      reason: 'unsupported_node_version',
+      protocolVersion: '1',
+    });
+    expect(mockDiscoverOpencodePortsWithMeta.mock.calls).toHaveLength(0);
+  });
+
+  it('fails deterministically when the server is running in hub mode', async () => {
+    process.env.VIBEPULSE_RUNTIME_ROLE = 'hub';
+
+    const response = await GET(new Request('http://localhost/api/node/health', {
+      headers: createNodeRequestHeaders('shared-secret'),
+    }));
+    const data = await response.json();
+
+    expect(response.status).toBe(503);
+    expect(data).toEqual({
+      ok: false,
+      reason: 'node_misconfigured',
+      protocolVersion: '1',
+      degraded: true,
+    });
+    expect(mockDiscoverOpencodePortsWithMeta.mock.calls).toHaveLength(0);
+  });
+
+  it('returns upstream_unreachable when local OpenCode is unavailable', async () => {
+    mockDiscoverOpencodePortsWithMeta.mockReturnValue({ ports: [], timedOut: false });
+
+    const response = await GET(new Request('http://localhost/api/node/health', {
+      headers: createNodeRequestHeaders('shared-secret'),
+    }));
+    const data = await response.json();
+
+    expect(response.status).toBe(503);
+    expect(data).toEqual({
+      ok: false,
+      reason: 'upstream_unreachable',
+      protocolVersion: '1',
+      degraded: true,
+      role: 'node',
+      upstream: {
+        kind: 'opencode',
+        reachable: false,
+      },
+    });
+  });
+
+  it('returns upstream_timeout when local OpenCode discovery times out', async () => {
+    mockDiscoverOpencodePortsWithMeta.mockReturnValue({ ports: [], timedOut: true });
+
+    const response = await GET(new Request('http://localhost/api/node/health', {
+      headers: createNodeRequestHeaders('shared-secret'),
+    }));
+    const data = await response.json();
+
+    expect(response.status).toBe(504);
+    expect(data).toEqual({
+      ok: false,
+      reason: 'upstream_timeout',
+      protocolVersion: '1',
+      degraded: true,
+      role: 'node',
+      upstream: {
+        kind: 'opencode',
+        reachable: false,
+      },
+    });
+  });
+
+  it('returns healthy when discovery partially timed out but usable ports exist', async () => {
+    mockDiscoverOpencodePortsWithMeta.mockReturnValue({ ports: [7777], timedOut: true });
+
+    const response = await GET(new Request('http://localhost/api/node/health', {
+      headers: createNodeRequestHeaders('shared-secret'),
+    }));
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data).toEqual({
+      ok: true,
+      role: 'node',
+      protocolVersion: '1',
+      upstream: {
+        kind: 'opencode',
+        reachable: true,
+      },
+    });
+  });
+});

package/.next/standalone/src/app/api/node/health/route.ts

@@ -0,0 +1,48 @@
+import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
+import {
+  NODE_PROTOCOL_VERSION,
+  createNodeFailureResponse,
+  guardNodeRequest,
+  toNodeRequestGuardResponse,
+} from '@/lib/nodeProtocol';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(request: Request) {
+  const guardResult = guardNodeRequest(request);
+  if (!guardResult.ok) {
+    return toNodeRequestGuardResponse(guardResult);
+  }
+
+  const discovery = discoverOpencodePortsWithMeta();
+
+  if (discovery.ports.length === 0) {
+    if (discovery.timedOut) {
+      return createNodeFailureResponse('upstream_timeout', {
+        role: 'node',
+        upstream: {
+          kind: 'opencode',
+          reachable: false,
+        },
+      });
+    }
+
+    return createNodeFailureResponse('upstream_unreachable', {
+      role: 'node',
+      upstream: {
+        kind: 'opencode',
+        reachable: false,
+      },
+    });
+  }
+
+  return Response.json({
+    ok: true,
+    role: 'node',
+    protocolVersion: NODE_PROTOCOL_VERSION,
+    upstream: {
+      kind: 'opencode',
+      reachable: true,
+    },
+  });
+}

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

@@ -0,0 +1,128 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('@/lib/opencodeDiscovery', () => ({
+  discoverOpencodePortsWithMeta: vi.fn(),
+}));
+
+vi.mock('@/lib/sessionArchiveOverrides', () => ({
+  clearSessionForceUnarchived: vi.fn(),
+  markSessionStickyStatusBlocked: vi.fn(),
+}));
+
+import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
+import { createNodeRequestHeaders } from '@/lib/nodeProtocol';
+
+import { POST } from './route';
+
+const mockDiscoverOpencodePortsWithMeta: any = discoverOpencodePortsWithMeta;
+
+describe('/api/node/sessions/[id]/archive', () => {
+  const originalRuntimeRole = process.env.VIBEPULSE_RUNTIME_ROLE;
+  const originalNodeToken = process.env.VIBEPULSE_NODE_TOKEN;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    process.env.VIBEPULSE_RUNTIME_ROLE = 'node';
+    process.env.VIBEPULSE_NODE_TOKEN = 'shared-secret';
+    mockDiscoverOpencodePortsWithMeta.mockReturnValue({ ports: [7777], timedOut: false });
+    Object.defineProperty(globalThis, 'fetch', {
+      value: vi.fn(async () => new Response(JSON.stringify({ success: true }), { status: 200 })),
+      configurable: true,
+    });
+  });
+
+  afterEach(() => {
+    process.env.VIBEPULSE_RUNTIME_ROLE = originalRuntimeRole;
+    process.env.VIBEPULSE_NODE_TOKEN = originalNodeToken;
+  });
+
+  it('archives a node-local session with valid auth', async () => {
+    const response = await POST(
+      new Request('http://localhost/api/node/sessions/ses_123/archive', {
+        method: 'POST',
+        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' })
+    );
+  });
+
+  it('rejects invalid auth before mutating', async () => {
+    const response = await POST(
+      new Request('http://localhost/api/node/sessions/ses_123/archive', {
+        method: 'POST',
+        headers: createNodeRequestHeaders('wrong-secret'),
+      }),
+      { params: Promise.resolve({ id: 'ses_123' }) }
+    );
+    const data = await response.json();
+
+    expect(response.status).toBe(401);
+    expect(data.reason).toBe('unauthorized');
+    expect(globalThis.fetch).not.toHaveBeenCalled();
+  });
+
+  it('rejects composed ids for node-local routes', async () => {
+    const response = await POST(
+      new Request('http://localhost/api/node/sessions/local:ses_123/archive', {
+        method: 'POST',
+        headers: createNodeRequestHeaders('shared-secret'),
+      }),
+      { params: Promise.resolve({ id: 'local:ses_123' }) }
+    );
+    const data = await response.json();
+
+    expect(response.status).toBe(400);
+    expect(data.error).toBe('Invalid node session id');
+    expect(globalThis.fetch).not.toHaveBeenCalled();
+  });
+
+  it('returns session_not_found when the node session is missing', async () => {
+    Object.defineProperty(globalThis, 'fetch', {
+      value: vi.fn(async () => new Response(JSON.stringify({ error: 'missing' }), { status: 404 })),
+      configurable: true,
+    });
+
+    const response = await POST(
+      new Request('http://localhost/api/node/sessions/ses_123/archive', {
+        method: 'POST',
+        headers: createNodeRequestHeaders('shared-secret'),
+      }),
+      { params: Promise.resolve({ id: 'ses_123' }) }
+    );
+    const data = await response.json();
+
+    expect(response.status).toBe(404);
+    expect(data).toEqual({ error: 'Session not found', reason: 'session_not_found' });
+  });
+
+  it('surfaces non-404 upstream archive failures', async () => {
+    Object.defineProperty(globalThis, 'fetch', {
+      value: vi.fn(async () => new Response(JSON.stringify({ error: 'boom' }), { status: 500 })),
+      configurable: true,
+    });
+
+    const response = await POST(
+      new Request('http://localhost/api/node/sessions/ses_123/archive', {
+        method: 'POST',
+        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 archive session',
+      reason: 'node_request_failed_500',
+      message: JSON.stringify({ error: 'boom' }),
+    });
+  });
+});

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

@@ -0,0 +1,97 @@
+import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
+import {
+  createNodeFailureResponse,
+  guardNodeRequest,
+  toNodeRequestGuardResponse,
+} from '@/lib/nodeProtocol';
+import {
+  clearSessionForceUnarchived,
+  markSessionStickyStatusBlocked,
+} from '@/lib/sessionArchiveOverrides';
+
+function resolveNodeLocalSessionId(id: string): string | null {
+  const trimmedId = id.trim();
+  if (!trimmedId || trimmedId.includes(':')) {
+    return null;
+  }
+
+  return trimmedId;
+}
+
+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);
+
+  if (!sessionId) {
+    return Response.json({ error: 'Invalid node session id' }, { status: 400 });
+  }
+
+  const { ports, timedOut } = discoverOpencodePortsWithMeta();
+  if (!ports.length) {
+    return createNodeFailureResponse(timedOut ? 'upstream_timeout' : 'upstream_unreachable', {
+      role: 'node',
+      upstream: {
+        kind: 'opencode',
+        reachable: false,
+      },
+    });
+  }
+
+  let sawNotFound = false;
+  let lastFailureStatus: number | null = null;
+  let lastFailureMessage: string | undefined;
+
+  for (const port of ports) {
+    try {
+      const response = await fetch(`http://localhost:${port}/session/${sessionId}`, {
+        method: 'PATCH',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ time: { archived: Date.now() } }),
+      });
+
+      if (response.ok) {
+        clearSessionForceUnarchived(sessionId);
+        markSessionStickyStatusBlocked(sessionId);
+        return Response.json({ success: true });
+      }
+
+      if (response.status === 404) {
+        sawNotFound = true;
+        continue;
+      }
+
+      lastFailureStatus = response.status;
+      const responseBody = await response.text().catch(() => '');
+      lastFailureMessage = responseBody || undefined;
+    } catch (error) {
+      lastFailureStatus = 503;
+      lastFailureMessage = error instanceof Error ? error.message : String(error);
+    }
+  }
+
+  if (lastFailureStatus !== null) {
+    return Response.json(
+      {
+        error: 'Failed to archive session',
+        reason: lastFailureStatus === 503 ? 'upstream_unreachable' : `node_request_failed_${lastFailureStatus}`,
+        ...(lastFailureMessage ? { message: lastFailureMessage } : {}),
+      },
+      { status: lastFailureStatus }
+    );
+  }
+
+  if (sawNotFound) {
+    return Response.json({ error: 'Session not found', reason: 'session_not_found' }, { status: 404 });
+  }
+
+  return Response.json({ error: 'Session not found', reason: 'session_not_found' }, { status: 404 });
+}

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

@@ -0,0 +1,113 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('@opencode-ai/sdk', () => ({
+  createOpencodeClient: vi.fn(),
+}));
+
+vi.mock('@/lib/opencodeDiscovery', () => ({
+  discoverOpencodePortsWithMeta: vi.fn(),
+}));
+
+vi.mock('@/lib/sessionArchiveOverrides', () => ({
+  clearSessionForceUnarchived: vi.fn(),
+  clearSessionStickyStatusBlocked: vi.fn(),
+}));
+
+import { createOpencodeClient } from '@opencode-ai/sdk';
+import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
+import { createNodeRequestHeaders } from '@/lib/nodeProtocol';
+
+import { POST } from './route';
+
+const mockCreateOpencodeClient: any = createOpencodeClient;
+const mockDiscoverOpencodePortsWithMeta: any = discoverOpencodePortsWithMeta;
+const mockSessionDelete = vi.fn();
+
+describe('/api/node/sessions/[id]/delete', () => {
+  const originalRuntimeRole = process.env.VIBEPULSE_RUNTIME_ROLE;
+  const originalNodeToken = process.env.VIBEPULSE_NODE_TOKEN;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    process.env.VIBEPULSE_RUNTIME_ROLE = 'node';
+    process.env.VIBEPULSE_NODE_TOKEN = 'shared-secret';
+    mockDiscoverOpencodePortsWithMeta.mockReturnValue({ ports: [7777], timedOut: false });
+    mockCreateOpencodeClient.mockReturnValue({
+      session: {
+        delete: mockSessionDelete,
+      },
+    });
+    mockSessionDelete.mockResolvedValue({});
+  });
+
+  afterEach(() => {
+    process.env.VIBEPULSE_RUNTIME_ROLE = originalRuntimeRole;
+    process.env.VIBEPULSE_NODE_TOKEN = originalNodeToken;
+  });
+
+  it('deletes a node-local session with valid auth', async () => {
+    const response = await POST(
+      new Request('http://localhost/api/node/sessions/ses_123/delete', {
+        method: 'POST',
+        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(mockCreateOpencodeClient).toHaveBeenCalledWith({ baseUrl: 'http://localhost:7777' });
+    expect(mockSessionDelete).toHaveBeenCalledWith({ path: { id: 'ses_123' } });
+  });
+
+  it('rejects invalid auth before mutating', async () => {
+    const response = await POST(
+      new Request('http://localhost/api/node/sessions/ses_123/delete', {
+        method: 'POST',
+        headers: createNodeRequestHeaders('wrong-secret'),
+      }),
+      { params: Promise.resolve({ id: 'ses_123' }) }
+    );
+    const data = await response.json();
+
+    expect(response.status).toBe(401);
+    expect(data.reason).toBe('unauthorized');
+    expect(mockSessionDelete).not.toHaveBeenCalled();
+  });
+
+  it('rejects composed ids for node-local routes', async () => {
+    const response = await POST(
+      new Request('http://localhost/api/node/sessions/local:ses_123/delete', {
+        method: 'POST',
+        headers: createNodeRequestHeaders('shared-secret'),
+      }),
+      { params: Promise.resolve({ id: 'local:ses_123' }) }
+    );
+    const data = await response.json();
+
+    expect(response.status).toBe(400);
+    expect(data.error).toBe('Invalid node session id');
+    expect(mockSessionDelete).not.toHaveBeenCalled();
+  });
+
+  it('returns session_not_found when delete reports a missing node session', async () => {
+    mockSessionDelete.mockRejectedValue(new Error('404 not found'));
+
+    const response = await POST(
+      new Request('http://localhost/api/node/sessions/ses_123/delete', {
+        method: 'POST',
+        headers: createNodeRequestHeaders('shared-secret'),
+      }),
+      { params: Promise.resolve({ id: 'ses_123' }) }
+    );
+    const data = await response.json();
+
+    expect(response.status).toBe(404);
+    expect(data).toEqual({
+      error: 'Session not found',
+      reason: 'session_not_found',
+      message: '404 not found',
+    });
+  });
+});

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

@@ -0,0 +1,81 @@
+import { createOpencodeClient } from '@opencode-ai/sdk';
+import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
+import {
+  createNodeFailureResponse,
+  guardNodeRequest,
+  toNodeRequestGuardResponse,
+} from '@/lib/nodeProtocol';
+import {
+  clearSessionForceUnarchived,
+  clearSessionStickyStatusBlocked,
+} from '@/lib/sessionArchiveOverrides';
+
+function resolveNodeLocalSessionId(id: string): string | null {
+  const trimmedId = id.trim();
+  if (!trimmedId || trimmedId.includes(':')) {
+    return null;
+  }
+
+  return trimmedId;
+}
+
+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);
+
+  if (!sessionId) {
+    return Response.json({ error: 'Invalid node session id' }, { status: 400 });
+  }
+
+  const { ports, timedOut } = discoverOpencodePortsWithMeta();
+  if (!ports.length) {
+    return createNodeFailureResponse(timedOut ? 'upstream_timeout' : 'upstream_unreachable', {
+      role: 'node',
+      upstream: {
+        kind: 'opencode',
+        reachable: false,
+      },
+    });
+  }
+
+  const errors: Error[] = [];
+  for (const port of ports) {
+    try {
+      const client = createOpencodeClient({ baseUrl: `http://localhost:${port}` });
+      await client.session.delete({ path: { id: sessionId } });
+      clearSessionForceUnarchived(sessionId);
+      clearSessionStickyStatusBlocked(sessionId);
+      return Response.json({ success: true });
+    } catch (error) {
+      errors.push(error as Error);
+    }
+  }
+
+  const lastErrorMessage = errors[errors.length - 1]?.message;
+  if (errors.length > 0 && errors.every((error) => /not found|404/i.test(error.message))) {
+    return Response.json(
+      {
+        error: 'Session not found',
+        reason: 'session_not_found',
+        message: lastErrorMessage,
+      },
+      { status: 404 }
+    );
+  }
+
+  return Response.json(
+    {
+      error: 'Failed to delete session',
+      message: lastErrorMessage,
+      portsTried: ports.length,
+    },
+    { status: 500 }
+  );
+}