vibepulse 0.2.0 → 0.2.1

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

@@ -0,0 +1,76 @@
+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) {
+    console.error('[opencode-models] command failed', {
+      command: 'opencode models',
+      message: error.message,
+      code: error.code,
+      signal: error.signal,
+      stderr: stderr || undefined,
+      stdoutPreview: stdout ? stdout.slice(0, 300) : undefined,
+    });
+    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 parsedTimeout = Number(process.env.OPENCODE_MODELS_TIMEOUT_MS);
+    const timeout = Number.isFinite(parsedTimeout) && parsedTimeout > 0 ? parsedTimeout : 15000;
+
+    const opencodePath = `${process.env.HOME}/.opencode/bin:${process.env.PATH}`;
+
+    getExecFn()('opencode models', { timeout, env: { ...process.env, PATH: opencodePath } }, (error, stdout, stderr) => {
+      if (error) {
+        console.error('[opencode-models] GET failed', {
+          timeout,
+          opencodePath,
+          cwd: process.cwd(),
+          home: process.env.HOME,
+          path: process.env.PATH,
+        });
+      }
+      const result = handleExecResult(error, stdout, stderr);
+      const status = result.source === 'error' ? 503 : 200;
+      return resolve(NextResponse.json(result, { status }));
+    });
+  });
+}

package/.next/standalone/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/.next/standalone/src/app/api/profiles/[id]/export/route.ts

@@ -0,0 +1,31 @@
+import { NextResponse } from 'next/server';
+import { getProfileById, readProfileConfig } from '@/lib/profiles/storage';
+import { createExportedProfileFile } from '@/lib/profiles/share';
+
+interface RouteParams {
+  params: Promise<{ id: string }>;
+}
+
+export async function GET(_request: Request, { 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);
+    const payload = createExportedProfileFile(profile, config);
+    const filename = `${profile.id}.vibepulse-profile.json`;
+
+    return new NextResponse(JSON.stringify(payload, null, 2), {
+      headers: {
+        'Content-Type': 'application/json; charset=utf-8',
+        'Content-Disposition': `attachment; filename="${filename}"`,
+      },
+    });
+  } catch {
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+  }
+}

package/.next/standalone/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/.next/standalone/src/app/api/profiles/import/route.test.js

@@ -0,0 +1,107 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import * as profileStorage from '@/lib/profiles/storage';
+import * as profileShare from '@/lib/profiles/share';
+import { POST } from './route';
+
+describe('/api/profiles/import', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('returns 400 when request body is invalid JSON', async () => {
+    const request = {
+      json: async () => {
+        throw new SyntaxError('Unexpected token');
+      },
+    };
+
+    const parseSpy = vi.spyOn(profileShare, 'parseImportedProfileFile');
+
+    const response = await POST(request);
+    const payload = await response.json();
+
+    expect(response.status).toBe(400);
+    expect(payload).toEqual({ error: 'Request body must be valid JSON' });
+    expect(parseSpy.mock.calls.length).toBe(0);
+  });
+
+  it('returns 400 when imported profile payload fails validation', async () => {
+    const request = {
+      json: async () => ({ invalid: true }),
+    };
+
+    vi.spyOn(profileShare, 'parseImportedProfileFile').mockImplementation(() => {
+      throw new Error('Imported profile id is required');
+    });
+
+    const response = await POST(request);
+    const payload = await response.json();
+
+    expect(response.status).toBe(400);
+    expect(payload).toEqual({ error: 'Imported profile id is required' });
+  });
+
+  it('rolls back profile index and returns 500 when config write fails', async () => {
+    const requestBody = {
+      profile: { id: 'shared-team', name: 'Shared Team', emoji: '🤝' },
+      config: { agents: { sisyphus: { model: 'anthropic/claude-opus-4-6' } } },
+    };
+    const request = {
+      json: async () => requestBody,
+    };
+
+    vi.spyOn(profileShare, 'parseImportedProfileFile').mockReturnValue({
+      profile: requestBody.profile,
+      config: requestBody.config,
+    });
+
+    const index = {
+      version: 1,
+      profiles: [],
+      activeProfileId: null,
+      lastModified: '2026-01-01T00:00:00.000Z',
+    };
+
+    vi.spyOn(profileStorage, 'readProfileIndexStrict').mockResolvedValue(index);
+    const writeSnapshots = [];
+    const writeProfileIndexSpy = vi.spyOn(profileStorage, 'writeProfileIndex').mockImplementation(async value => {
+      writeSnapshots.push(structuredClone(value));
+    });
+    vi.spyOn(profileStorage, 'writeProfileConfig').mockRejectedValue(new Error('ENOSPC'));
+
+    const response = await POST(request);
+    const payload = await response.json();
+
+    expect(response.status).toBe(500);
+    expect(payload).toEqual({ error: 'Failed to import profile due to a server error' });
+    expect(writeProfileIndexSpy.mock.calls.length).toBe(2);
+
+    const firstWrite = writeSnapshots[0];
+    const secondWrite = writeSnapshots[1];
+
+    expect(firstWrite.profiles.some(profile => profile.id === 'shared-team')).toBe(true);
+    expect(secondWrite.profiles.some(profile => profile.id === 'shared-team')).toBe(false);
+  });
+
+  it('returns 500 when profile index cannot be loaded', async () => {
+    const requestBody = {
+      profile: { id: 'shared-team', name: 'Shared Team', emoji: '🤝' },
+      config: { agents: {} },
+    };
+    const request = {
+      json: async () => requestBody,
+    };
+
+    vi.spyOn(profileShare, 'parseImportedProfileFile').mockReturnValue({
+      profile: requestBody.profile,
+      config: requestBody.config,
+    });
+    vi.spyOn(profileStorage, 'readProfileIndexStrict').mockRejectedValue(new Error('Corrupt index'));
+
+    const response = await POST(request);
+    const payload = await response.json();
+
+    expect(response.status).toBe(500);
+    expect(payload).toEqual({ error: 'Failed to import profile due to a server error' });
+  });
+});

package/.next/standalone/src/app/api/profiles/import/route.ts

@@ -0,0 +1,65 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { readProfileIndexStrict, writeProfileConfig, writeProfileIndex } from '@/lib/profiles/storage';
+import { parseImportedProfileFile } from '@/lib/profiles/share';
+import type { Profile } from '@/types/opencodeConfig';
+
+class ImportBadRequestError extends Error {}
+
+export async function POST(request: NextRequest) {
+  try {
+    let body: unknown;
+    try {
+      body = await request.json();
+    } catch {
+      throw new ImportBadRequestError('Request body must be valid JSON');
+    }
+
+    let importedProfile: { id: string; name: string; emoji: string; description?: string };
+    let config: Parameters<typeof writeProfileConfig>[1];
+    try {
+      ({ profile: importedProfile, config } = parseImportedProfileFile(body));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Imported profile file is invalid';
+      throw new ImportBadRequestError(message);
+    }
+
+    const index = await readProfileIndexStrict();
+    const existingProfile = index.profiles.find(profile => profile.id === importedProfile.id);
+    if (existingProfile) {
+      return NextResponse.json(
+        { error: `Profile with id '${importedProfile.id}' already exists` },
+        { status: 400 }
+      );
+    }
+
+    const now = new Date().toISOString();
+    const profile: Profile = {
+      id: importedProfile.id,
+      name: importedProfile.name,
+      emoji: importedProfile.emoji,
+      description: importedProfile.description,
+      createdAt: now,
+      updatedAt: now,
+      isBuiltIn: false,
+      isDefault: false,
+    };
+
+    index.profiles.push(profile);
+    await writeProfileIndex(index);
+    try {
+      await writeProfileConfig(profile.id, config);
+    } catch {
+      index.profiles = index.profiles.filter(existing => existing.id !== profile.id);
+      await writeProfileIndex(index);
+      throw new Error('Failed to persist imported profile config');
+    }
+
+    return NextResponse.json({ profile }, { status: 201 });
+  } catch (error) {
+    const message =
+      error instanceof ImportBadRequestError ? error.message : 'Failed to import profile due to a server error';
+    const status = error instanceof ImportBadRequestError ? 400 : 500;
+
+    return NextResponse.json({ error: message }, { status });
+  }
+}

package/.next/standalone/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 }
+    );
+  }
+}