vibepulse 0.1.0 → 0.1.2

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

@@ -0,0 +1,304 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { readConfig, writeConfig } from '@/lib/opencodeConfig';
+
+// Allowed fields to expose in the API
+const ALLOWED_AGENT_FIELDS = ['model', 'temperature', 'top_p', 'variant', 'prompt_append'] as const;
+
+/**
+ * Filters an agent config to only include allowed fields
+ */
+function filterAgentConfig(agent: Record<string, unknown>): Record<string, unknown> {
+  const filtered: Record<string, unknown> = {};
+  
+  for (const field of ALLOWED_AGENT_FIELDS) {
+    if (agent[field] !== undefined) {
+      filtered[field] = agent[field];
+    }
+  }
+  
+  return filtered;
+}
+
+/**
+ * GET /api/opencode-config
+ * Returns filtered agent configuration
+ * Only exposes: model, temperature, top_p
+ * Filters out sensitive fields (apiKey, token, password, etc.)
+ */
+export async function GET() {
+  try {
+    const config = await readConfig();
+    const agents = config.agents || {};
+    const filteredAgents: Record<string, Record<string, unknown>> = {};
+    
+    for (const [agentName, agentConfig] of Object.entries(agents)) {
+      if (typeof agentConfig === 'object' && agentConfig !== null) {
+        filteredAgents[agentName] = filterAgentConfig(agentConfig as Record<string, unknown>);
+      }
+    }
+
+    const categories = config.categories || {};
+    const filteredCategories: Record<string, Record<string, unknown>> = {};
+    
+    for (const [catName, catConfig] of Object.entries(categories)) {
+      if (typeof catConfig === 'object' && catConfig !== null && !Array.isArray(catConfig)) {
+        filteredCategories[catName] = filterAgentConfig(catConfig as Record<string, unknown>);
+      }
+    }
+
+    return NextResponse.json({ 
+      agents: filteredAgents,
+      categories: filteredCategories
+    });
+  } catch (error) {
+    console.error('Error reading config:', error);
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * POST /api/opencode-config
+ * Updates agent configuration with validation
+ * Only allows: model, temperature, top_p
+ * Rejects sensitive fields (apiKey, token, password, secret, etc.)
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+
+    // Validate request structure
+    if (!body || typeof body !== 'object') {
+      return NextResponse.json(
+        { error: 'Invalid request body' },
+        { status: 400 }
+      );
+    }
+
+    const { agents, categories } = body;
+
+    // If neither agents nor categories provided, nothing to update
+    if (agents === undefined && categories === undefined) {
+      return NextResponse.json(
+        { error: 'Missing agents or categories field' },
+        { status: 400 }
+      );
+    }
+
+    // Validate agents is an object (if provided)
+    if (agents !== undefined && (typeof agents !== 'object' || agents === null || Array.isArray(agents))) {
+      return NextResponse.json(
+        { error: 'Agents must be an object' },
+        { status: 400 }
+      );
+    }
+    
+    // Validate categories is an object (if provided)
+    if (categories !== undefined && (typeof categories !== 'object' || categories === null || Array.isArray(categories))) {
+      return NextResponse.json(
+        { error: 'Categories must be an object' },
+        { status: 400 }
+      );
+    }
+
+    // Read current config
+    const currentConfig = await readConfig();
+    const currentAgents = currentConfig.agents || {};
+
+    // Validate and merge agent updates
+    const updatedAgents: Record<string, Record<string, unknown>> = {};
+
+    for (const [name, config] of Object.entries(currentAgents)) {
+      if (typeof config === 'object' && config !== null && !Array.isArray(config)) {
+        updatedAgents[name] = config as Record<string, unknown>;
+      }
+    }
+
+    if (agents !== undefined) {
+      for (const [agentName, agentConfig] of Object.entries(agents)) {
+        if (typeof agentConfig !== 'object' || agentConfig === null || Array.isArray(agentConfig)) {
+          return NextResponse.json(
+            { error: `Agent '${agentName}' config must be an object` },
+            { status: 400 }
+          );
+        }
+
+        const config = agentConfig as Record<string, unknown>;
+        const disallowedFields: string[] = [];
+
+        for (const key of Object.keys(config)) {
+          const lowerKey = key.toLowerCase();
+          if (
+            lowerKey.includes('api') ||
+            lowerKey.includes('key') ||
+            lowerKey.includes('token') ||
+            lowerKey.includes('secret') ||
+            lowerKey.includes('password') ||
+            lowerKey.includes('auth') ||
+            lowerKey.includes('credential') ||
+            lowerKey.includes('private') ||
+            lowerKey.includes('cert')
+          ) {
+            disallowedFields.push(key);
+          }
+        }
+
+        if (disallowedFields.length > 0) {
+          return NextResponse.json(
+          {
+            error: `Agent '${agentName}' contains disallowed fields: ${disallowedFields.join(', ')}`
+          },
+          { status: 403 }
+        );
+      }
+
+      const validatedConfig: Record<string, unknown> = {};
+
+      for (const [field, value] of Object.entries(config)) {
+        const lowerField = field.toLowerCase();
+
+        if (lowerField === 'model') {
+          if (typeof value !== 'string' || value.trim() === '') {
+            return NextResponse.json(
+              { error: `Agent '${agentName}': model must be a non-empty string` },
+              { status: 400 }
+            );
+          }
+          validatedConfig[field] = value;
+        } else if (lowerField === 'temperature') {
+          const temp = Number(value);
+          if (isNaN(temp) || temp < 0 || temp > 2) {
+            return NextResponse.json(
+              { error: `Agent '${agentName}': temperature must be a number between 0 and 2` },
+              { status: 400 }
+            );
+          }
+          validatedConfig[field] = temp;
+         } else if (lowerField === 'top_p') {
+           const topP = Number(value);
+           if (isNaN(topP) || topP < 0 || topP > 1) {
+             return NextResponse.json(
+               { error: `Agent '${agentName}': top_p must be a number between 0 and 1` },
+               { status: 400 }
+             );
+           }
+           validatedConfig[field] = topP;
+         } else if (lowerField === 'variant') {
+           if (typeof value !== 'string') {
+             return NextResponse.json(
+               { error: `Agent '${agentName}': variant must be a string` },
+               { status: 400 }
+             );
+           }
+           validatedConfig[field] = value;
+         } else if (lowerField === 'prompt_append') {
+           if (typeof value !== 'string') {
+             return NextResponse.json(
+               { error: `Agent '${agentName}': prompt_append must be a string` },
+               { status: 400 }
+             );
+           }
+           validatedConfig[field] = value;
+         } else {
+           return NextResponse.json(
+             {
+               error: `Agent '${agentName}': unknown field '${field}'. Allowed fields: model, temperature, top_p, variant, prompt_append`
+             },
+             { status: 400 }
+           );
+        }
+      }
+
+      updatedAgents[agentName] = {
+        ...(currentAgents[agentName] as Record<string, unknown> || {}),
+        ...validatedConfig
+      };
+    }
+  }
+
+  // Process categories updates if provided
+  const updatedCategories: Record<string, Record<string, unknown>> = {};
+  const currentCategories = (currentConfig.categories || {}) as Record<string, Record<string, unknown>>;
+
+  for (const [name, config] of Object.entries(currentCategories)) {
+    if (typeof config === 'object' && config !== null && !Array.isArray(config)) {
+      updatedCategories[name] = config as Record<string, unknown>;
+    }
+  }
+
+  if (categories !== undefined) {
+    for (const [categoryName, categoryConfig] of Object.entries(categories)) {
+      if (typeof categoryConfig !== 'object' || categoryConfig === null || Array.isArray(categoryConfig)) {
+        return NextResponse.json(
+          { error: `Category '${categoryName}' config must be an object` },
+          { status: 400 }
+        );
+      }
+
+      const configObj = categoryConfig as Record<string, unknown>;
+      const validatedCategoryConfig: Record<string, unknown> = {};
+
+      for (const [field, value] of Object.entries(configObj)) {
+        if (field === 'model' || field === 'variant' || field === 'prompt_append' || field === 'description') {
+          if (value !== undefined && typeof value !== 'string') {
+             return NextResponse.json(
+               { error: `Category '${categoryName}': '${field}' must be a string` },
+               { status: 400 }
+             );
+          }
+          validatedCategoryConfig[field] = value;
+        } else if (field === 'temperature' || field === 'top_p') {
+          if (value !== undefined && typeof value !== 'number') {
+             return NextResponse.json(
+               { error: `Category '${categoryName}': '${field}' must be a number` },
+               { status: 400 }
+             );
+          }
+          
+          const numValue = value as number;
+          const temp = field === 'temperature' ? Math.max(0, Math.min(2, numValue)) : numValue;
+          const topP = field === 'top_p' ? Math.max(0, Math.min(1, numValue)) : numValue;
+          
+          validatedCategoryConfig[field] = field === 'temperature' ? temp : topP;
+        } else {
+           return NextResponse.json(
+             { error: `Category '${categoryName}': unknown field '${field}'` },
+             { status: 400 }
+           );
+        }
+      }
+      
+      updatedCategories[categoryName] = {
+        ...((currentCategories[categoryName] as Record<string, unknown>) || {}),
+        ...validatedCategoryConfig
+      };
+    }
+  }
+
+  // Update config and save
+  const newConfig = { ...currentConfig } as Record<string, unknown>;
+  if (agents !== undefined) newConfig.agents = updatedAgents;
+  if (categories !== undefined) newConfig.categories = updatedCategories;
+  
+  // writeConfig type doesn't natively expose categories yet, safely bypassing
+  await writeConfig(
+    newConfig as { 
+      agents?: Record<string, Record<string, unknown>>; 
+      categories?: Record<string, Record<string, unknown>>; 
+    }
+  );
+
+  return NextResponse.json(
+    { success: true, agents: updatedAgents, categories: updatedCategories },
+    { status: 200 }
+  );
+} catch (error) {
+  console.error('Error updating config:', error);
+  return NextResponse.json(
+    { error: 'Internal server error' },
+    { status: 500 }
+  );
+}
+}

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 }
+    );
+  }
+}