vibepulse 0.2.0 → 0.2.1

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

@@ -0,0 +1,206 @@
+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/editorLauncher.server', () => ({
+  openEditorOnCurrentMachine: vi.fn(),
+}));
+
+import { createOpencodeClient } from '@opencode-ai/sdk';
+import { openEditorOnCurrentMachine } from '@/lib/editorLauncher.server';
+import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
+import { createNodeRequestHeaders } from '@/lib/nodeProtocol';
+
+import { POST } from './route';
+
+const mockCreateOpencodeClient: any = createOpencodeClient;
+const mockDiscoverOpencodePortsWithMeta: any = discoverOpencodePortsWithMeta;
+const mockOpenEditorOnCurrentMachine: any = openEditorOnCurrentMachine;
+const mockSessionGet = vi.fn();
+
+describe('/api/node/sessions/[id]/open-editor', () => {
+  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: {
+        get: mockSessionGet,
+      },
+    });
+    mockSessionGet.mockResolvedValue({
+      data: {
+        id: 'ses_123',
+        directory: '/tmp/demo',
+      },
+    });
+    mockOpenEditorOnCurrentMachine.mockResolvedValue('vscode://file/tmp/demo');
+  });
+
+  afterEach(() => {
+    process.env.VIBEPULSE_RUNTIME_ROLE = originalRuntimeRole;
+    process.env.VIBEPULSE_NODE_TOKEN = originalNodeToken;
+  });
+
+  it('opens a node-local session with valid auth and raw session id', async () => {
+    const response = await POST(
+      new Request('http://localhost/api/node/sessions/ses_123/open-editor', {
+        method: 'POST',
+        headers: createNodeRequestHeaders('shared-secret'),
+        body: JSON.stringify({ tool: 'vscode' }),
+      }),
+      { params: Promise.resolve({ id: 'ses_123' }) }
+    );
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(mockSessionGet).toHaveBeenCalledWith({ path: { id: 'ses_123' } });
+    expect(mockOpenEditorOnCurrentMachine).toHaveBeenCalledWith('vscode', '/tmp/demo');
+    expect(data).toEqual({ success: true, uri: 'vscode://file/tmp/demo' });
+  });
+
+  it('treats null JSON body as empty and defaults tool to vscode', async () => {
+    const response = await POST(
+      new Request('http://localhost/api/node/sessions/ses_123/open-editor', {
+        method: 'POST',
+        headers: createNodeRequestHeaders('shared-secret'),
+        body: 'null',
+      }),
+      { params: Promise.resolve({ id: 'ses_123' }) }
+    );
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(mockOpenEditorOnCurrentMachine).toHaveBeenCalledWith('vscode', '/tmp/demo');
+    expect(data).toEqual({ success: true, uri: 'vscode://file/tmp/demo' });
+  });
+
+  it('rejects invalid auth before attempting editor launch', async () => {
+    const response = await POST(
+      new Request('http://localhost/api/node/sessions/ses_123/open-editor', {
+        method: 'POST',
+        headers: createNodeRequestHeaders('wrong-secret'),
+        body: JSON.stringify({ tool: 'vscode' }),
+      }),
+      { params: Promise.resolve({ id: 'ses_123' }) }
+    );
+    const data = await response.json();
+
+    expect(response.status).toBe(401);
+    expect(data.reason).toBe('unauthorized');
+    expect(mockSessionGet).not.toHaveBeenCalled();
+    expect(mockOpenEditorOnCurrentMachine).not.toHaveBeenCalled();
+  });
+
+  it('surfaces editor execution failures without fallback', async () => {
+    mockOpenEditorOnCurrentMachine.mockRejectedValue(new Error('open command failed'));
+
+    const response = await POST(
+      new Request('http://localhost/api/node/sessions/ses_123/open-editor', {
+        method: 'POST',
+        headers: createNodeRequestHeaders('shared-secret'),
+        body: JSON.stringify({ tool: 'vscode' }),
+      }),
+      { params: Promise.resolve({ id: 'ses_123' }) }
+    );
+    const data = await response.json();
+
+    expect(response.status).toBe(503);
+    expect(data).toEqual({
+      error: 'Editor unavailable',
+      reason: 'editor_unavailable',
+      message: 'open command failed',
+    });
+  });
+
+  it('returns a session_not_found reason when the node session no longer exists', async () => {
+    mockSessionGet.mockRejectedValue(new Error('not found'));
+
+    const response = await POST(
+      new Request('http://localhost/api/node/sessions/ses_123/open-editor', {
+        method: 'POST',
+        headers: createNodeRequestHeaders('shared-secret'),
+        body: JSON.stringify({ tool: 'vscode' }),
+      }),
+      { 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 lookup failures without misclassifying as not found', async () => {
+    mockSessionGet.mockRejectedValue(new Error('connection refused'));
+
+    const response = await POST(
+      new Request('http://localhost/api/node/sessions/ses_123/open-editor', {
+        method: 'POST',
+        headers: createNodeRequestHeaders('shared-secret'),
+        body: JSON.stringify({ tool: 'vscode' }),
+      }),
+      { params: Promise.resolve({ id: 'ses_123' }) }
+    );
+    const data = await response.json();
+
+    expect(response.status).toBe(503);
+    expect(data).toEqual({
+      error: 'Failed to open editor for session',
+      reason: 'upstream_unreachable',
+      message: 'connection refused',
+    });
+  });
+
+  it('returns editor_unavailable when session directory is missing', async () => {
+    mockSessionGet.mockResolvedValue({
+      data: {
+        id: 'ses_123',
+        directory: '   ',
+      },
+    });
+
+    const response = await POST(
+      new Request('http://localhost/api/node/sessions/ses_123/open-editor', {
+        method: 'POST',
+        headers: createNodeRequestHeaders('shared-secret'),
+        body: JSON.stringify({ tool: 'vscode' }),
+      }),
+      { params: Promise.resolve({ id: 'ses_123' }) }
+    );
+    const data = await response.json();
+
+    expect(response.status).toBe(503);
+    expect(data).toEqual({
+      error: 'Editor unavailable',
+      reason: 'editor_unavailable',
+      message: 'Session directory is missing or empty',
+    });
+    expect(mockOpenEditorOnCurrentMachine).not.toHaveBeenCalled();
+  });
+
+  it('rejects invalid open tools', async () => {
+    const response = await POST(
+      new Request('http://localhost/api/node/sessions/ses_123/open-editor', {
+        method: 'POST',
+        headers: createNodeRequestHeaders('shared-secret'),
+        body: JSON.stringify({ tool: 'desktop' }),
+      }),
+      { params: Promise.resolve({ id: 'ses_123' }) }
+    );
+    const data = await response.json();
+
+    expect(response.status).toBe(400);
+    expect(data).toEqual({ error: 'Invalid open tool' });
+    expect(mockOpenEditorOnCurrentMachine).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,123 @@
+import { createOpencodeClient } from '@opencode-ai/sdk';
+import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
+import type { OpenEditorTool } from '@/lib/editorLauncher';
+import { openEditorOnCurrentMachine } from '@/lib/editorLauncher.server';
+import {
+  createNodeFailureResponse,
+  guardNodeRequest,
+  toNodeRequestGuardResponse,
+} from '@/lib/nodeProtocol';
+
+function resolveNodeLocalSessionId(id: string): string | null {
+  const trimmedId = id.trim();
+  if (!trimmedId || trimmedId.includes(':')) {
+    return null;
+  }
+
+  return trimmedId;
+}
+
+function resolveOpenEditorTool(value: unknown): OpenEditorTool | null {
+  return value === 'antigravity' || value === 'vscode' ? value : null;
+}
+
+function toRequestBodyRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+}
+
+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 parsedBody = await request.json().catch(() => ({}));
+  const body = toRequestBodyRecord(parsedBody);
+  const tool = resolveOpenEditorTool(body.tool ?? 'vscode');
+  if (!tool) {
+    return Response.json({ error: 'Invalid open tool' }, { status: 400 });
+  }
+
+  const { ports, timedOut } = discoverOpencodePortsWithMeta();
+  if (!ports.length) {
+    return createNodeFailureResponse(timedOut ? 'upstream_timeout' : 'upstream_unreachable', {
+      role: 'node',
+      upstream: {
+        kind: 'opencode',
+        reachable: false,
+      },
+    });
+  }
+
+  let sawMissingDirectory = false;
+  const errors: Error[] = [];
+
+  for (const port of ports) {
+    try {
+      const client = createOpencodeClient({ baseUrl: `http://localhost:${port}` });
+      const result = await client.session.get({ path: { id: sessionId } });
+      const directory = result.data?.directory;
+
+      if (typeof directory !== 'string' || !directory.trim()) {
+        sawMissingDirectory = true;
+        continue;
+      }
+
+      try {
+        const uri = await openEditorOnCurrentMachine(tool, directory);
+        return Response.json({ success: true, uri });
+      } catch (error) {
+        return Response.json(
+          {
+            error: 'Editor unavailable',
+            reason: 'editor_unavailable',
+            message: error instanceof Error ? error.message : String(error),
+          },
+          { status: 503 }
+        );
+      }
+    } catch (error) {
+      errors.push(error as Error);
+    }
+  }
+
+  if (sawMissingDirectory) {
+    return Response.json(
+      {
+        error: 'Editor unavailable',
+        reason: 'editor_unavailable',
+        message: 'Session directory is missing or empty',
+      },
+      { status: 503 }
+    );
+  }
+
+  if (errors.length > 0) {
+    const lastErrorMessage = errors[errors.length - 1]?.message;
+    if (errors.every((error) => /not found|404/i.test(error.message))) {
+      return Response.json({ error: 'Session not found', reason: 'session_not_found' }, { status: 404 });
+    }
+
+    return Response.json(
+      {
+        error: 'Failed to open editor for session',
+        reason: 'upstream_unreachable',
+        ...(lastErrorMessage ? { message: lastErrorMessage } : {}),
+      },
+      { status: 503 }
+    );
+  }
+
+  return Response.json({ error: 'Session not found', reason: 'session_not_found' }, { status: 404 });
+}