vibepulse 0.2.0 → 0.2.1

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

@@ -0,0 +1,136 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('@/lib/opencodeDiscovery', () => ({
+  discoverOpencodePortsWithMeta: vi.fn(),
+}));
+
+vi.mock('@/lib/nodeRegistry', () => ({
+  listNodeRecords: vi.fn(),
+}));
+
+vi.mock('@/lib/sessionArchiveOverrides', () => ({
+  clearSessionForceUnarchived: vi.fn(),
+  markSessionStickyStatusBlocked: vi.fn(),
+}));
+
+import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
+import { listNodeRecords } from '@/lib/nodeRegistry';
+
+import { POST } from './route';
+
+const mockDiscoverPortsWithMeta: any = discoverOpencodePortsWithMeta;
+const mockListNodeRecords: any = listNodeRecords;
+
+describe('/api/sessions/[id]/archive', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockDiscoverPortsWithMeta.mockReturnValue({ ports: [7777], timedOut: false });
+    mockListNodeRecords.mockResolvedValue([]);
+  });
+
+  it('archives local composite ids against the local opencode port', async () => {
+    const mockFetch = vi.fn(async () => new Response('', { status: 200 }));
+    vi.stubGlobal('fetch', mockFetch);
+
+    const response = await POST(new Request('http://localhost/api/sessions/local:abc/archive', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'local:abc' }),
+    });
+
+    expect(response.status).toBe(200);
+    expect(mockFetch).toHaveBeenCalledWith('http://localhost:7777/session/abc', expect.objectContaining({ method: 'PATCH' }));
+  });
+
+  it('forwards remote archive ids to the matching node endpoint', async () => {
+    mockListNodeRecords.mockResolvedValue([
+      {
+        nodeId: 'node-1',
+        nodeLabel: 'Node 1',
+        baseUrl: 'https://node-1.test',
+        enabled: true,
+        token: 'node-token',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      },
+    ]);
+    const mockFetch = vi.fn(async () => new Response(JSON.stringify({ success: true }), { status: 200 }));
+    vi.stubGlobal('fetch', mockFetch);
+
+    const response = await POST(new Request('http://localhost/api/sessions/node-1:abc/archive', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'node-1:abc' }),
+    });
+
+    expect(response.status).toBe(200);
+    expect(mockFetch).toHaveBeenCalledWith('https://node-1.test/api/node/sessions/abc/archive', expect.objectContaining({ method: 'POST' }));
+  });
+
+  it('returns session_not_found when the remote node record is missing', async () => {
+    mockListNodeRecords.mockResolvedValue([]);
+
+    const response = await POST(new Request('http://localhost/api/sessions/node-1:abc/archive', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'node-1:abc' }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(404);
+    expect(data).toEqual({ error: 'Session not found', reason: 'session_not_found' });
+  });
+
+  it('returns a deterministic invalid-action error for malformed ids', async () => {
+    const response = await POST(new Request('http://localhost/api/sessions/node-1:/archive', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'node-1:' }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(400);
+    expect(data).toEqual({ error: 'Invalid action session id', reason: 'invalid_action_session_id' });
+  });
+
+  it('returns session_not_found for a missing local session archive', async () => {
+    const mockFetch = vi.fn(async () => new Response(JSON.stringify({ error: 'missing' }), { status: 404 }));
+    vi.stubGlobal('fetch', mockFetch);
+
+    const response = await POST(new Request('http://localhost/api/sessions/local:abc/archive', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'local:abc' }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(404);
+    expect(data).toEqual({ error: 'Session not found', reason: 'session_not_found' });
+  });
+
+  it('does not misclassify non-404 local archive failures as session_not_found', async () => {
+    const mockFetch = vi.fn(async () => new Response(JSON.stringify({ error: 'boom' }), { status: 500 }));
+    vi.stubGlobal('fetch', mockFetch);
+
+    const response = await POST(new Request('http://localhost/api/sessions/local:abc/archive', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'local:abc' }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(500);
+    expect(data).toEqual({
+      error: 'Failed to archive session',
+      reason: 'archive_request_failed',
+      message: JSON.stringify({ error: 'boom' }),
+    });
+  });
+
+  it('maps local archive transport failures to upstream_unreachable', async () => {
+    const mockFetch = vi.fn(async () => {
+      throw new Error('ECONNREFUSED');
+    });
+    vi.stubGlobal('fetch', mockFetch);
+
+    const response = await POST(new Request('http://localhost/api/sessions/local:abc/archive', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'local:abc' }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(503);
+    expect(data).toEqual({
+      error: 'Failed to archive session',
+      reason: 'upstream_unreachable',
+      message: 'ECONNREFUSED',
+    });
+  });
+});

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

@@ -0,0 +1,170 @@
+import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
+import { parseActionSessionReference, resolveLocalActionSessionId } from '@/lib/hostIdentity';
+import { listNodeRecords } from '@/lib/nodeRegistry';
+import { createNodeRequestHeaders } from '@/lib/nodeProtocol';
+import {
+    clearSessionForceUnarchived,
+    markSessionStickyStatusBlocked,
+} from '@/lib/sessionArchiveOverrides';
+
+const REMOTE_NODE_ACTION_TIMEOUT_MS = 5_000;
+
+function createInvalidActionSessionIdResponse() {
+    return Response.json(
+        { error: 'Invalid action session id', reason: 'invalid_action_session_id' },
+        { status: 400 }
+    );
+}
+
+function createSessionNotFoundResponse() {
+    return Response.json(
+        { error: 'Session not found', reason: 'session_not_found' },
+        { status: 404 }
+    );
+}
+
+function createArchiveFailureResponse(
+    status: number,
+    message?: string,
+    reason: 'archive_request_failed' | 'upstream_unreachable' = 'archive_request_failed'
+) {
+    return Response.json(
+        {
+            error: 'Failed to archive session',
+            reason,
+            ...(message ? { message } : {}),
+        },
+        { status }
+    );
+}
+
+async function forwardRemoteArchive(hostId: string, sessionId: string): Promise<Response> {
+    const nodeRecords = await listNodeRecords();
+    const nodeRecord = nodeRecords.find((node) => node.nodeId === hostId);
+
+    if (!nodeRecord || !nodeRecord.enabled) {
+        return createSessionNotFoundResponse();
+    }
+
+    const abortController = new AbortController();
+    let timedOut = false;
+    const timeoutHandle = setTimeout(() => {
+        timedOut = true;
+        abortController.abort();
+    }, REMOTE_NODE_ACTION_TIMEOUT_MS);
+
+    try {
+        const response = await fetch(`${nodeRecord.baseUrl}/api/node/sessions/${sessionId}/archive`, {
+            method: 'POST',
+            headers: createNodeRequestHeaders(nodeRecord.token),
+            signal: abortController.signal,
+        });
+
+        if (response.ok) {
+            return Response.json({ success: true });
+        }
+
+        const body = await response.json().catch(() => ({}));
+        return Response.json(
+            {
+                error: 'Remote archive failed',
+                reason: typeof body.reason === 'string' ? body.reason : `node_request_failed_${response.status}`,
+            },
+            { status: response.status }
+        );
+    } catch {
+        return Response.json(
+            {
+                error: timedOut ? 'Remote node request timed out' : 'Remote node request failed',
+                reason: timedOut ? 'upstream_timeout' : 'upstream_unreachable',
+            },
+            { status: timedOut ? 504 : 503 }
+        );
+    } finally {
+        clearTimeout(timeoutHandle);
+    }
+}
+
+export async function POST(_: Request, { params }: { params: Promise<{ id: string }> }) {
+    const { id } = await params;
+    const sessionId = resolveLocalActionSessionId(id);
+
+    if (!sessionId) {
+        try {
+            const actionTarget = parseActionSessionReference(id);
+            if (actionTarget.isRemote) {
+                return forwardRemoteArchive(actionTarget.hostId, actionTarget.sessionId);
+            }
+        } catch {
+            return createInvalidActionSessionIdResponse();
+        }
+    }
+
+    if (!sessionId) {
+        return createInvalidActionSessionIdResponse();
+    }
+
+    const { ports, timedOut } = discoverOpencodePortsWithMeta();
+    if (!ports.length) {
+        if (timedOut) {
+            return Response.json(
+                { error: 'OpenCode discovery timed out' },
+                { status: 503 }
+            );
+        }
+
+        return Response.json(
+            { error: 'OpenCode server not found' },
+            { status: 503 }
+        );
+    }
+    let sawNotFound = false;
+    let lastFailureStatus: number | null = null;
+    let lastFailureMessage: string | undefined;
+    let lastFailureReason: 'archive_request_failed' | 'upstream_unreachable' = 'archive_request_failed';
+
+    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) {
+                clearSessionForceUnarchived(sessionId);
+                markSessionStickyStatusBlocked(sessionId);
+                return Response.json({ success: true });
+            }
+
+            const responseText = await response.text();
+            console.error(`Failed to archive session on port ${port}:`, responseText);
+
+            if (response.status === 404) {
+                sawNotFound = true;
+                continue;
+            }
+
+            lastFailureStatus = response.status;
+            lastFailureMessage = responseText || undefined;
+            lastFailureReason = 'archive_request_failed';
+        } catch (error) {
+            console.error(`Failed to archive session on port ${port}:`, error);
+            lastFailureStatus = 503;
+            lastFailureMessage = error instanceof Error ? error.message : String(error);
+            lastFailureReason = 'upstream_unreachable';
+        }
+    }
+
+    if (lastFailureStatus !== null) {
+        return createArchiveFailureResponse(lastFailureStatus, lastFailureMessage, lastFailureReason);
+    }
+
+    if (sawNotFound) {
+        return createSessionNotFoundResponse();
+    }
+
+    return createArchiveFailureResponse(500);
+}

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

@@ -0,0 +1,113 @@
+import { 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/nodeRegistry', () => ({
+  listNodeRecords: vi.fn(),
+}));
+
+vi.mock('@/lib/sessionArchiveOverrides', () => ({
+  clearSessionForceUnarchived: vi.fn(),
+  clearSessionStickyStatusBlocked: vi.fn(),
+}));
+
+import { createOpencodeClient } from '@opencode-ai/sdk';
+import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
+import { listNodeRecords } from '@/lib/nodeRegistry';
+
+import { POST } from './route';
+
+const mockCreateOpencodeClient: any = createOpencodeClient;
+const mockDiscoverPortsWithMeta: any = discoverOpencodePortsWithMeta;
+const mockListNodeRecords: any = listNodeRecords;
+const mockSessionDelete = vi.fn();
+
+describe('/api/sessions/[id]/delete', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockDiscoverPortsWithMeta.mockReturnValue({ ports: [7777], timedOut: false });
+    mockListNodeRecords.mockResolvedValue([]);
+    mockCreateOpencodeClient.mockReturnValue({
+      session: {
+        delete: mockSessionDelete,
+      },
+    });
+    mockSessionDelete.mockResolvedValue(undefined);
+  });
+
+  it('deletes local composite ids against the local opencode port', async () => {
+    const response = await POST(new Request('http://localhost/api/sessions/local:abc/delete', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'local:abc' }),
+    });
+
+    expect(response.status).toBe(200);
+    expect(mockSessionDelete).toHaveBeenCalledWith({ path: { id: 'abc' } });
+  });
+
+  it('forwards remote delete ids to the matching node endpoint', async () => {
+    mockListNodeRecords.mockResolvedValue([
+      {
+        nodeId: 'node-1',
+        nodeLabel: 'Node 1',
+        baseUrl: 'https://node-1.test',
+        enabled: true,
+        token: 'node-token',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      },
+    ]);
+    const mockFetch = vi.fn(async () => new Response(JSON.stringify({ success: true }), { status: 200 }));
+    vi.stubGlobal('fetch', mockFetch);
+
+    const response = await POST(new Request('http://localhost/api/sessions/node-1:abc/delete', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'node-1:abc' }),
+    });
+
+    expect(response.status).toBe(200);
+    expect(mockFetch).toHaveBeenCalledWith('https://node-1.test/api/node/sessions/abc/delete', expect.objectContaining({ method: 'POST' }));
+  });
+
+  it('returns session_not_found when the remote node record is missing', async () => {
+    mockListNodeRecords.mockResolvedValue([]);
+
+    const response = await POST(new Request('http://localhost/api/sessions/node-1:abc/delete', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'node-1:abc' }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(404);
+    expect(data).toEqual({ error: 'Session not found', reason: 'session_not_found' });
+  });
+
+  it('returns a deterministic invalid-action error for malformed ids', async () => {
+    const response = await POST(new Request('http://localhost/api/sessions/node-1:/delete', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'node-1:' }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(400);
+    expect(data).toEqual({ error: 'Invalid action session id', reason: 'invalid_action_session_id' });
+  });
+
+  it('returns session_not_found for a missing local session delete', async () => {
+    mockSessionDelete.mockRejectedValue(new Error('404 not found'));
+
+    const response = await POST(new Request('http://localhost/api/sessions/local:abc/delete', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'local:abc' }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(404);
+    expect(data).toEqual({
+      error: 'Session not found',
+      reason: 'session_not_found',
+      message: '404 not found',
+    });
+  });
+});

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

@@ -0,0 +1,137 @@
+import { createOpencodeClient } from '@opencode-ai/sdk';
+import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
+import { parseActionSessionReference, resolveLocalActionSessionId } from '@/lib/hostIdentity';
+import { listNodeRecords } from '@/lib/nodeRegistry';
+import { createNodeRequestHeaders } from '@/lib/nodeProtocol';
+import {
+    clearSessionForceUnarchived,
+    clearSessionStickyStatusBlocked,
+} from '@/lib/sessionArchiveOverrides';
+
+const REMOTE_NODE_ACTION_TIMEOUT_MS = 5_000;
+
+function createInvalidActionSessionIdResponse() {
+    return Response.json(
+        { error: 'Invalid action session id', reason: 'invalid_action_session_id' },
+        { status: 400 }
+    );
+}
+
+function createSessionNotFoundResponse(message?: string) {
+    return Response.json(
+        {
+            error: 'Session not found',
+            reason: 'session_not_found',
+            ...(message ? { message } : {}),
+        },
+        { status: 404 }
+    );
+}
+
+async function forwardRemoteDelete(hostId: string, sessionId: string): Promise<Response> {
+    const nodeRecords = await listNodeRecords();
+    const nodeRecord = nodeRecords.find((node) => node.nodeId === hostId);
+
+    if (!nodeRecord || !nodeRecord.enabled) {
+        return createSessionNotFoundResponse();
+    }
+
+    const abortController = new AbortController();
+    let timedOut = false;
+    const timeoutHandle = setTimeout(() => {
+        timedOut = true;
+        abortController.abort();
+    }, REMOTE_NODE_ACTION_TIMEOUT_MS);
+
+    try {
+        const response = await fetch(`${nodeRecord.baseUrl}/api/node/sessions/${sessionId}/delete`, {
+            method: 'POST',
+            headers: createNodeRequestHeaders(nodeRecord.token),
+            signal: abortController.signal,
+        });
+
+        if (response.ok) {
+            return Response.json({ success: true });
+        }
+
+        const body = await response.json().catch(() => ({}));
+        return Response.json(
+            {
+                error: 'Remote delete failed',
+                reason: typeof body.reason === 'string' ? body.reason : `node_request_failed_${response.status}`,
+            },
+            { status: response.status }
+        );
+    } catch {
+        return Response.json(
+            {
+                error: timedOut ? 'Remote node request timed out' : 'Remote node request failed',
+                reason: timedOut ? 'upstream_timeout' : 'upstream_unreachable',
+            },
+            { status: timedOut ? 504 : 503 }
+        );
+    } finally {
+        clearTimeout(timeoutHandle);
+    }
+}
+
+export async function POST(_: Request, { params }: { params: Promise<{ id: string }> }) {
+    const { id } = await params;
+    const sessionId = resolveLocalActionSessionId(id);
+
+    if (!sessionId) {
+        try {
+            const actionTarget = parseActionSessionReference(id);
+            if (actionTarget.isRemote) {
+                return forwardRemoteDelete(actionTarget.hostId, actionTarget.sessionId);
+            }
+        } catch {
+            return createInvalidActionSessionIdResponse();
+        }
+    }
+
+    if (!sessionId) {
+        return createInvalidActionSessionIdResponse();
+    }
+
+    const { ports, timedOut } = discoverOpencodePortsWithMeta();
+    if (!ports.length) {
+        if (timedOut) {
+            return Response.json(
+                { error: 'OpenCode discovery timed out' },
+                { status: 503 }
+            );
+        }
+
+        return Response.json(
+            { error: 'OpenCode server not found' },
+            { status: 503 }
+        );
+    }
+    const errors: Error[] = [];
+    for (const port of ports) {
+        try {
+            const client = createOpencodeClient({ baseUrl: `http://localhost:${port}` });
+            await client.session.delete({ path: { id: sessionId } });
+            clearSessionForceUnarchived(sessionId);
+            clearSessionStickyStatusBlocked(sessionId);
+            return Response.json({ success: true });
+        } catch (err) {
+            errors.push(err as Error);
+        }
+    }
+
+    const lastError = errors[errors.length - 1];
+    if (errors.length > 0 && errors.every((error) => /not found|404/i.test(error.message))) {
+        return createSessionNotFoundResponse(lastError?.message);
+    }
+
+    return Response.json(
+        {
+            error: 'Failed to delete session',
+            message: lastError?.message,
+            portsTried: ports.length,
+        },
+        { status: 500 }
+    );
+}