vibepulse 0.1.1 → 0.1.2

package/src/app/api/opencode-config/status/route.ts

@@ -0,0 +1,31 @@
+import { detectConfig, CONFIG_PATH } from '@/lib/opencodeConfig';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+async function detectPlugin(): Promise<boolean> {
+  try {
+    // Check if oh-my-opencode CLI is available
+    await execAsync('opencode --version');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function GET() {
+  const hasConfig = detectConfig();
+  const hasPlugin = await detectPlugin();
+
+  const response: { hasConfig: boolean; hasPlugin: boolean; path?: string } = {
+    hasConfig,
+    hasPlugin,
+  };
+
+  if (hasConfig) {
+    response.path = CONFIG_PATH;
+  }
+
+  return Response.json(response);
+}

package/src/app/api/opencode-events/route.ts

@@ -0,0 +1,86 @@
+import { createOpencodeClient } from '@opencode-ai/sdk';
+import { discoverOpencodePorts } from '@/lib/opencodeDiscovery';
+
+export async function GET() {
+    const encoder = new TextEncoder();
+    const ports = discoverOpencodePorts();
+    
+    if (!ports.length) {
+        return Response.json(
+            {
+                error: 'OpenCode server not found',
+    hint: 'Make sure OpenCode is running with an exposed API port. Example: opencode --port <PORT> (VibePulse auto-detects active ports).'
+            },
+            { status: 503 }
+        );
+    }
+
+    try {
+        const stream = new ReadableStream({
+            async start(controller) {
+                let isClosed = false;
+                
+                try {
+                    // Connect to each port independently - failures don't block others
+                    const results = await Promise.allSettled(ports.map(async port => {
+                        const client = createOpencodeClient({ baseUrl: `http://localhost:${port}` });
+                        return client.global.event();
+                    }));
+
+                    const connectedStreams: AsyncIterable<unknown>[] = [];
+                    for (const r of results) {
+                        if (r.status === 'fulfilled') {
+                            connectedStreams.push(r.value.stream);
+                        } else {
+                            console.warn('Failed to connect to OpenCode port:', r.reason);
+                        }
+                    }
+
+                    if (!connectedStreams.length) {
+                        console.error('All OpenCode port connections failed');
+                        try { controller.close(); } catch { /* noop */ }
+                        return;
+                    }
+
+                    const tasks = connectedStreams.map(s => (async () => {
+                        for await (const event of s) {
+                            if (isClosed) break;
+                            try {
+                                controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}\n\n`));
+                            } catch { break; }
+                        }
+                    })());
+
+                    await Promise.allSettled(tasks);
+                } catch (error) {
+                    console.error('Error in event stream:', error);
+                } finally {
+                    isClosed = true;
+                    try {
+                        controller.close();
+                    } catch {
+                        // Connection may already be closed
+                    }
+                }
+            },
+        });
+
+        return new Response(stream, {
+            headers: {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                Connection: 'keep-alive',
+            },
+        });
+    } catch (error) {
+        console.error('Error creating event stream:', error);
+        return Response.json(
+            {
+                error: 'Failed to create event stream',
+                details: error instanceof Error ? error.message : String(error),
+          hint: 'Make sure OpenCode is running with an exposed API port. Example: opencode --port <PORT> (VibePulse auto-detects active ports).'
+            },
+            { status: 500 }
+        );
+    }
+}

package/src/app/api/opencode-models/route.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect, vi, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
+import type { ExecException } from 'child_process';
+import { handleExecResult, GET, setExecFn } from './route';
+
+type ExecCallback = (error: ExecException | null, stdout: string, stderr: string) => void;
+type MockExecFn = (cmd: string, opts: unknown, callback: ExecCallback) => void;
+
+describe('/api/opencode-models', () => {
+  describe('handleExecResult', () => {
+    it('should return error when CLI does not exist', () => {
+      const error = new Error('spawn opencode ENOENT') as ExecException;
+      const result = handleExecResult(error, '', 'command not found');
+
+      expect(result.source).toBe('error');
+      expect(result.models).toEqual([]);
+      expect(result.error).toBeTruthy();
+    });
+
+    it('should return error on timeout', () => {
+      const error = new Error('timeout') as ExecException;
+      const result = handleExecResult(error, '', '');
+
+      expect(result.source).toBe('error');
+      expect(result.models).toEqual([]);
+    });
+
+    it('should return error on empty output', () => {
+      const result = handleExecResult(null, '', '');
+
+      expect(result.source).toBe('error');
+      expect(result.models).toEqual([]);
+      expect(result.error).toContain('No models found');
+    });
+
+    it('should return models when only stderr but stdout is valid', () => {
+      const result = handleExecResult(null, 'anthropic/claude\nopenai/gpt-4', 'some warning from CLI');
+
+      expect(result.source).toBe('opencode');
+      expect(result.models).toContain('anthropic/claude');
+    });
+
+    it('should return error when only stderr and stdout is empty', () => {
+      const result = handleExecResult(null, '', 'some error in stderr');
+
+      expect(result.source).toBe('error');
+      expect(result.models).toEqual([]);
+    });
+
+    it('should return CLI models in normal case', () => {
+      const result = handleExecResult(null, 'anthropic/claude\nopenai/gpt-4', '');
+
+      expect(result.source).toBe('opencode');
+      expect(result.models).toContain('anthropic/claude');
+    });
+  });
+
+  describe('GET API Integration Tests', () => {
+    const originalHome = process.env.HOME;
+    const originalPath = process.env.PATH;
+
+    let mockExec: ReturnType<typeof vi.fn<MockExecFn>>;
+
+    beforeAll(() => {
+      process.env.HOME = '/tmp';
+      process.env.PATH = '/usr/bin';
+    });
+
+    afterAll(() => {
+      process.env.HOME = originalHome;
+      process.env.PATH = originalPath;
+    });
+
+    beforeEach(() => {
+      mockExec = vi.fn<MockExecFn>();
+      setExecFn(mockExec as never);
+    });
+
+    afterEach(() => {
+      const { exec } = vi.importActual<typeof import('child_process')>('child_process') as never as { exec: MockExecFn };
+      setExecFn(exec as never);
+    });
+
+    it('should return source=opencode and real model list on successful GET', async () => {
+      mockExec.mockImplementation((_cmd: unknown, _opts: unknown, callback: ExecCallback) => {
+        callback(null, 'anthropic/claude-3.5-sonnet\nopenai/gpt-4o\ndeepseek/deepseek-chat\n', '');
+      });
+
+      const response = await GET();
+      const data = await response.json();
+
+      expect(response.status).toBe(200);
+      expect(data.source).toBe('opencode');
+      expect(data.models).toContain('anthropic/claude-3.5-sonnet');
+    });
+
+    it('should return source=opencode when CLI has stderr but stdout is valid', async () => {
+      mockExec.mockImplementation((_cmd: unknown, _opts: unknown, callback: ExecCallback) => {
+        callback(null, 'anthropic/claude-3.5-sonnet\n', 'Warning: newer version available');
+      });
+
+      const response = await GET();
+      const data = await response.json();
+
+      expect(response.status).toBe(200);
+      expect(data.source).toBe('opencode');
+    });
+
+    it('should return 503 error when CLI fails', async () => {
+      mockExec.mockImplementation((_cmd: unknown, _opts: unknown, callback: ExecCallback) => {
+        callback(new Error('spawn opencode ENOENT') as ExecException, '', 'command not found');
+      });
+
+      const response = await GET();
+      const data = await response.json();
+
+      expect(response.status).toBe(503);
+      expect(data.source).toBe('error');
+      expect(data.models).toEqual([]);
+      expect(data.error).toBeTruthy();
+    });
+
+    it('should return 503 error when GET returns empty models', async () => {
+      mockExec.mockImplementation((_cmd: unknown, _opts: unknown, callback: ExecCallback) => {
+        callback(null, '', '');
+      });
+
+      const response = await GET();
+      const data = await response.json();
+
+      expect(response.status).toBe(503);
+      expect(data.source).toBe('error');
+      expect(data.models).toEqual([]);
+    });
+  });
+});

package/src/app/api/opencode-models/route.ts

@@ -0,0 +1,58 @@
+import { NextResponse } from 'next/server';
+import { type ExecException } from 'child_process';
+
+type ExecFn = (
+  command: string,
+  options: { timeout: number; env: NodeJS.ProcessEnv },
+  callback: (error: ExecException | null, stdout: string, stderr: string) => void
+) => void;
+
+let _execFn: ExecFn | null = null;
+
+function getExecFn(): ExecFn {
+  if (_execFn) return _execFn;
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  return require('child_process').exec as ExecFn;
+}
+
+export function setExecFn(fn: ExecFn | null) {
+  _execFn = fn;
+}
+
+export function handleExecResult(
+  error: ExecException | null,
+  stdout: string,
+  stderr: string
+): { models: string[]; source: string; error?: string } {
+  if (error) {
+    return { models: [], source: 'error', error: error.message || 'Failed to fetch models from CLI' };
+  }
+
+  if (stderr) {
+    console.warn('[opencode-models] stderr:', stderr);
+  }
+
+  try {
+    const models = stdout.trim().split('\n').filter(line => line.includes('/'));
+    if (models.length === 0) {
+      return { models: [], source: 'error', error: 'No models found. Please check your OpenCode installation.' };
+    }
+    return { models, source: 'opencode' };
+  } catch {
+    return { models: [], source: 'error', error: 'Failed to parse models output' };
+  }
+}
+
+export async function GET(): Promise<Response> {
+  return new Promise<Response>((resolve) => {
+    const timeout = 5000;
+
+    const opencodePath = `${process.env.HOME}/.opencode/bin:${process.env.PATH}`;
+
+    getExecFn()('opencode models', { timeout, env: { ...process.env, PATH: opencodePath } }, (error, stdout, stderr) => {
+      const result = handleExecResult(error, stdout, stderr);
+      const status = result.error ? 503 : 200;
+      return resolve(NextResponse.json(result, { status }));
+    });
+  });
+}

package/src/app/api/profiles/[id]/apply/route.ts

@@ -0,0 +1,49 @@
+import { NextRequest, NextResponse } from 'next/server';
+import {
+  readProfileConfig,
+  getProfileById,
+  setActiveProfileId,
+} from '@/lib/profiles/storage';
+import { readConfig, writeConfig } from '@/lib/opencodeConfig';
+
+interface RouteParams {
+  params: Promise<{ id: string }>;
+}
+
+export async function POST(_request: NextRequest, { params }: RouteParams) {
+  try {
+    const { id } = await params;
+    const profile = await getProfileById(id);
+
+    if (!profile) {
+      return NextResponse.json(
+        { error: 'Profile not found' },
+        { status: 404 }
+      );
+    }
+
+    const profileConfig = await readProfileConfig(id);
+    const currentConfig = await readConfig();
+
+    const mergedConfig = {
+      ...currentConfig,
+      agents: profileConfig.agents,
+      categories: profileConfig.categories,
+    };
+
+    await writeConfig(mergedConfig);
+    await setActiveProfileId(id);
+
+    return NextResponse.json({
+      message: 'Profile applied successfully',
+      profile,
+      config: profileConfig,
+    });
+  } catch (error) {
+    console.error('Error applying profile:', error);
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/profiles/[id]/route.ts

@@ -0,0 +1,160 @@
+import { NextRequest, NextResponse } from 'next/server';
+import {
+  readProfileIndex,
+  writeProfileIndex,
+  getProfileById,
+  readProfileConfig,
+  writeProfileConfig,
+  deleteProfileConfig,
+} from '@/lib/profiles/storage';
+
+
+interface RouteParams {
+  params: Promise<{ id: string }>;
+}
+
+export async function GET(_request: NextRequest, { params }: RouteParams) {
+  try {
+    const { id } = await params;
+    const profile = await getProfileById(id);
+
+    if (!profile) {
+      return NextResponse.json(
+        { error: 'Profile not found' },
+        { status: 404 }
+      );
+    }
+
+    const config = await readProfileConfig(id);
+
+    return NextResponse.json({
+      profile,
+      config,
+    });
+  } catch (error) {
+    console.error('Error reading profile:', error);
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}
+
+export async function PUT(request: NextRequest, { params }: RouteParams) {
+  try {
+    const { id } = await params;
+    const profile = await getProfileById(id);
+
+    if (!profile) {
+      return NextResponse.json(
+        { error: 'Profile not found' },
+        { status: 404 }
+      );
+    }
+
+    const body = await request.json();
+
+    if (!body || typeof body !== 'object') {
+      return NextResponse.json(
+        { error: 'Invalid request body' },
+        { status: 400 }
+      );
+    }
+
+    // Support both { name, ... } and { profile: { name, ... }, config } formats
+    const profileData = body.profile || body;
+    const { name, description, emoji } = profileData;
+    const config = body.config || profileData.config;
+
+    if (name !== undefined) {
+      if (typeof name !== 'string' || name.trim() === '') {
+        return NextResponse.json(
+          { error: 'name must be a non-empty string' },
+          { status: 400 }
+        );
+      }
+      profile.name = name.trim();
+    }
+
+    if (description !== undefined) {
+      profile.description = description?.trim() || undefined;
+    }
+
+    if (emoji !== undefined) {
+      profile.emoji = emoji || '⚙️';
+    }
+
+    profile.updatedAt = new Date().toISOString();
+
+    const index = await readProfileIndex();
+    const profileIndex = index.profiles.findIndex(p => p.id === id);
+
+    if (profileIndex === -1) {
+      return NextResponse.json(
+        { error: 'Profile not found in index' },
+        { status: 404 }
+      );
+    }
+
+    index.profiles[profileIndex] = profile;
+    await writeProfileIndex(index);
+
+    if (config && typeof config === 'object') {
+      await writeProfileConfig(id, {
+        agents: config.agents || {},
+        categories: config.categories,
+      });
+    }
+
+    return NextResponse.json({ profile });
+  } catch (error) {
+    console.error('Error updating profile:', error);
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}
+
+export async function DELETE(_request: NextRequest, { params }: RouteParams) {
+  try {
+    const { id } = await params;
+    const profile = await getProfileById(id);
+
+    if (!profile) {
+      return NextResponse.json(
+        { error: 'Profile not found' },
+        { status: 404 }
+      );
+    }
+
+    if (profile.isBuiltIn) {
+      await deleteProfileConfig(id);
+
+      return NextResponse.json({
+        message: 'Built-in profile reset to defaults',
+        profile,
+      });
+    }
+
+    const index = await readProfileIndex();
+    index.profiles = index.profiles.filter(p => p.id !== id);
+
+    if (index.activeProfileId === id) {
+      index.activeProfileId = null;
+    }
+
+    await writeProfileIndex(index);
+    await deleteProfileConfig(id);
+
+    return NextResponse.json({
+      message: 'Profile deleted successfully',
+    });
+  } catch (error) {
+    console.error('Error deleting profile:', error);
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/profiles/route.ts

@@ -0,0 +1,107 @@
+import { NextRequest, NextResponse } from 'next/server';
+import {
+  readProfileIndex,
+  writeProfileIndex,
+  getProfileById,
+  writeProfileConfig,
+} from '@/lib/profiles/storage';
+import type { Profile, ProfileConfig } from '@/lib/profiles/storage';
+
+export async function GET() {
+  try {
+    const index = await readProfileIndex();
+    
+    return NextResponse.json({
+      profiles: index.profiles,
+      activeProfileId: index.activeProfileId,
+    });
+  } catch (error) {
+    console.error('Error reading profiles:', error);
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+
+    if (!body || typeof body !== 'object') {
+      return NextResponse.json(
+        { error: 'Invalid request body' },
+        { status: 400 }
+      );
+    }
+
+    // Support both { id, name, ... } and { profile: { id, name, ... }, config } formats
+    const profileData = body.profile || body;
+    const { id, name, emoji, description } = profileData;
+    const config = body.config || profileData.config;
+
+    if (!id || typeof id !== 'string' || id.trim() === '') {
+      return NextResponse.json(
+        { error: 'id is required and must be a non-empty string' },
+        { status: 400 }
+      );
+    }
+
+    if (!name || typeof name !== 'string' || name.trim() === '') {
+      return NextResponse.json(
+        { error: 'name is required and must be a non-empty string' },
+        { status: 400 }
+      );
+    }
+
+    const existingProfile = await getProfileById(id);
+    if (existingProfile) {
+      return NextResponse.json(
+        { error: `Profile with id '${id}' already exists` },
+        { status: 400 }
+      );
+    }
+
+    if (!/^[a-zA-Z0-9_-]+$/.test(id)) {
+      return NextResponse.json(
+        { error: 'id must contain only letters, numbers, hyphens, and underscores' },
+        { status: 400 }
+      );
+    }
+
+    const now = new Date().toISOString();
+    const newProfile: Profile = {
+      id: id.trim(),
+      name: name.trim(),
+      emoji: emoji || '⚙️',
+      description: description?.trim() || undefined,
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    const index = await readProfileIndex();
+    index.profiles.push(newProfile);
+    await writeProfileIndex(index);
+
+    if (config && typeof config === 'object') {
+      const profileConfig: ProfileConfig = {
+        agents: config.agents || {},
+        categories: config.categories,
+      };
+      await writeProfileConfig(id, profileConfig);
+    } else {
+      await writeProfileConfig(id, { agents: {} });
+    }
+
+    return NextResponse.json(
+      { profile: newProfile },
+      { status: 201 }
+    );
+  } catch (error) {
+    console.error('Error creating profile:', error);
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,35 @@
+import { discoverOpencodePorts } from '@/lib/opencodeDiscovery';
+
+export async function POST(_: Request, { params }: { params: Promise<{ id: string }> }) {
+    const { id: sessionId } = await params;
+    const ports = discoverOpencodePorts();
+    if (!ports.length) {
+        return Response.json(
+            { error: 'OpenCode server not found' },
+            { status: 503 }
+        );
+    }
+    for (const port of ports) {
+        try {
+            const baseUrl = `http://localhost:${port}`;
+            const response = await fetch(`${baseUrl}/session/${sessionId}`, {
+                method: 'PATCH',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ time: { archived: Date.now() } })
+            });
+            if (response.ok) {
+                return Response.json({ success: true });
+            }
+            console.error(`Failed to archive session on port ${port}:`, await response.text());
+        } catch (error) {
+            console.error(`Failed to archive session on port ${port}:`, error);
+        }
+    }
+
+    return Response.json(
+        { error: 'Session not found' },
+        { status: 404 }
+    );
+}

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

@@ -0,0 +1,26 @@
+import { createOpencodeClient } from '@opencode-ai/sdk';
+import { discoverOpencodePorts } from '@/lib/opencodeDiscovery';
+
+export async function POST(_: Request, { params }: { params: Promise<{ id: string }> }) {
+    const { id: sessionId } = await params;
+    const ports = discoverOpencodePorts();
+    if (!ports.length) {
+        return Response.json(
+            { error: 'OpenCode server not found' },
+            { status: 503 }
+        );
+    }
+    for (const port of ports) {
+        try {
+            const client = createOpencodeClient({ baseUrl: `http://localhost:${port}` });
+            await client.session.delete({ path: { id: sessionId } });
+            return Response.json({ success: true });
+        } catch {
+        }
+    }
+
+    return Response.json(
+        { error: 'Session not found' },
+        { status: 404 }
+    );
+}