vibepulse 0.1.0 → 0.1.2

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

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

@@ -0,0 +1,45 @@
+import { createOpencodeClient } from '@opencode-ai/sdk';
+import { discoverOpencodePorts } from '@/lib/opencodeDiscovery';
+
+export async function GET(
+    _: Request,
+    { params }: { params: Promise<{ id: string }> }
+) {
+    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 { id } = await params;
+        for (const port of ports) {
+            try {
+                const client = createOpencodeClient({ baseUrl: `http://localhost:${port}` });
+                const result = await client.session.get({ path: { id } });
+                if (result.data) {
+                    return Response.json({ session: result.data });
+                }
+            } catch {
+                // Try next port
+            }
+        }
+        return Response.json({ error: 'Session not found' }, { status: 404 });
+    } catch (error) {
+        console.error('Error fetching session:', error);
+        return Response.json(
+            {
+                error: 'Failed to fetch session',
+                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 }
+        );
+    }
+}