vibepulse 0.2.1 → 0.3.0-beta.0

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

@@ -0,0 +1,186 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('@/lib/opencodeDiscovery', () => ({
+  discoverOpencodePortsWithMeta: vi.fn(() => ({ ports: [], timedOut: false })),
+}));
+
+vi.mock('@/lib/nodeRegistry', () => ({
+  listNodeRecords: vi.fn(async () => []),
+}));
+
+vi.mock('@/lib/sessionArchiveOverrides', () => ({
+  markSessionForceUnarchived: vi.fn(),
+  clearSessionStickyStatusBlocked: vi.fn(),
+}));
+
+vi.mock('@/lib/claudeSessionOverrides', () => ({
+  clearClaudeSessionArchived: vi.fn(),
+}));
+
+import { POST } from './route';
+import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
+import { listNodeRecords } from '@/lib/nodeRegistry';
+import { clearClaudeSessionArchived } from '@/lib/claudeSessionOverrides';
+import {
+  clearSessionStickyStatusBlocked,
+  markSessionForceUnarchived,
+} from '@/lib/sessionArchiveOverrides';
+
+const mockDiscoverOpencodePortsWithMeta: any = discoverOpencodePortsWithMeta;
+const mockListNodeRecords: any = listNodeRecords;
+const mockClearClaudeSessionArchived: any = clearClaudeSessionArchived;
+const mockMarkSessionForceUnarchived: any = markSessionForceUnarchived;
+const mockClearSessionStickyStatusBlocked: any = clearSessionStickyStatusBlocked;
+
+describe('/api/sessions/[id]/restore', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockDiscoverOpencodePortsWithMeta.mockReturnValue({ ports: [], timedOut: false });
+    mockListNodeRecords.mockResolvedValue([]);
+  });
+
+  it('restores Claude sessions through local override storage', async () => {
+    const response = await POST(new Request('http://localhost/api/sessions/local:claude~550e8400-e29b-41d4-a716-446655440000/restore', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'local:claude~550e8400-e29b-41d4-a716-446655440000' }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data).toEqual({ success: true });
+    expect(mockMarkSessionForceUnarchived).toHaveBeenCalledWith('claude~550e8400-e29b-41d4-a716-446655440000');
+    expect(mockClearSessionStickyStatusBlocked).toHaveBeenCalledWith('claude~550e8400-e29b-41d4-a716-446655440000');
+    expect(mockClearClaudeSessionArchived).toHaveBeenCalledWith('550e8400-e29b-41d4-a716-446655440000');
+    expect(mockListNodeRecords).not.toHaveBeenCalled();
+    expect(mockDiscoverOpencodePortsWithMeta).not.toHaveBeenCalled();
+  });
+
+  it('restores scoped Claude sidechain sessions through local override storage', async () => {
+    const scopedSessionId = '550e8400-e29b-41d4-a716-446655440000__agent-a123';
+    const response = await POST(new Request(`http://localhost/api/sessions/local:${scopedSessionId}/restore`, { method: 'POST' }), {
+      params: Promise.resolve({ id: `local:${scopedSessionId}` }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data).toEqual({ success: true });
+    expect(mockMarkSessionForceUnarchived).toHaveBeenCalledWith(scopedSessionId);
+    expect(mockClearSessionStickyStatusBlocked).toHaveBeenCalledWith(scopedSessionId);
+    expect(mockClearClaudeSessionArchived).toHaveBeenCalledWith(scopedSessionId);
+    expect(mockListNodeRecords).not.toHaveBeenCalled();
+    expect(mockDiscoverOpencodePortsWithMeta).not.toHaveBeenCalled();
+  });
+
+  it('rejects remote Claude restore requests before local override or node execution', async () => {
+    const mockFetch = vi.fn();
+    vi.stubGlobal('fetch', mockFetch);
+
+    const response = await POST(new Request('http://localhost/api/sessions/node-1:claude~550e8400-e29b-41d4-a716-446655440000/restore', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'node-1:claude~550e8400-e29b-41d4-a716-446655440000' }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(403);
+    expect(data).toEqual({
+      error: 'Session action not supported by provider',
+      reason: 'provider_capability_unsupported',
+      provider: 'claude-code',
+      capability: 'archive',
+    });
+    expect(mockClearClaudeSessionArchived).not.toHaveBeenCalled();
+    expect(mockListNodeRecords).not.toHaveBeenCalled();
+    expect(mockDiscoverOpencodePortsWithMeta).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('rejects remote scoped Claude sidechain restore requests before node execution', async () => {
+    const scopedSessionId = '550e8400-e29b-41d4-a716-446655440000__agent-a123';
+    const mockFetch = vi.fn();
+    vi.stubGlobal('fetch', mockFetch);
+
+    const response = await POST(new Request(`http://localhost/api/sessions/node-1:${scopedSessionId}/restore`, { method: 'POST' }), {
+      params: Promise.resolve({ id: `node-1:${scopedSessionId}` }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(403);
+    expect(data).toEqual({
+      error: 'Session action not supported by provider',
+      reason: 'provider_capability_unsupported',
+      provider: 'claude-code',
+      capability: 'archive',
+    });
+    expect(mockClearClaudeSessionArchived).not.toHaveBeenCalled();
+    expect(mockListNodeRecords).not.toHaveBeenCalled();
+    expect(mockDiscoverOpencodePortsWithMeta).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('forwards remote opencode restores to node archive DELETE 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/restore', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'node-1:abc' }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data).toEqual({ success: true });
+    expect(mockFetch).toHaveBeenCalledWith('https://node-1.test/api/node/sessions/abc/archive', expect.objectContaining({ method: 'DELETE' }));
+    expect(mockClearClaudeSessionArchived).not.toHaveBeenCalled();
+    expect(mockDiscoverOpencodePortsWithMeta).not.toHaveBeenCalled();
+  });
+
+  it('clears sticky blocked state when local opencode restore succeeds', async () => {
+    mockDiscoverOpencodePortsWithMeta.mockReturnValue({ ports: [3456], timedOut: false });
+    const mockFetch = vi.fn(async () => new Response(JSON.stringify({ ok: true }), { status: 200 }));
+    vi.stubGlobal('fetch', mockFetch);
+
+    const response = await POST(new Request('http://localhost/api/sessions/local:session-1/restore', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'local:session-1' }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data).toEqual({ success: true });
+    expect(mockFetch).toHaveBeenCalledWith('http://localhost:3456/session/session-1', expect.objectContaining({ method: 'PATCH' }));
+    expect(mockMarkSessionForceUnarchived).toHaveBeenCalledWith('session-1');
+    expect(mockClearSessionStickyStatusBlocked).toHaveBeenCalledWith('session-1');
+  });
+
+  it('returns the latest non-404 upstream failure when restore attempts fail', async () => {
+    mockDiscoverOpencodePortsWithMeta.mockReturnValue({ ports: [3456, 3457], timedOut: false });
+    const mockFetch = vi.fn(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.includes(':3456/')) {
+        return new Response('upstream boom', { status: 503 });
+      }
+      return new Response('not found', { status: 404 });
+    });
+    vi.stubGlobal('fetch', mockFetch);
+
+    const response = await POST(new Request('http://localhost/api/sessions/local:session-2/restore', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'local:session-2' }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(503);
+    expect(data).toEqual(expect.objectContaining({
+      error: 'Failed to restore session',
+      reason: 'restore_request_failed',
+      message: 'upstream boom',
+    }));
+  });
+});

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

@@ -0,0 +1,184 @@
+import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
+import { ActionSessionReference, parseActionSessionReference, resolveLocalActionSessionId } from '@/lib/hostIdentity';
+import { listNodeRecords } from '@/lib/nodeRegistry';
+import { createNodeRequestHeaders } from '@/lib/nodeProtocol';
+import { detectProviderFromRawId, extractProviderRawId, getDefaultProviderContext } from '@/lib/session-providers/providerIds';
+import {
+  clearSessionStickyStatusBlocked,
+  markSessionForceUnarchived,
+} from '@/lib/sessionArchiveOverrides';
+import { clearClaudeSessionArchived } from '@/lib/claudeSessionOverrides';
+
+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 createUnsupportedCapabilityResponse(sessionId: string) {
+  const provider = detectProviderFromRawId(sessionId);
+  return Response.json(
+    {
+      error: 'Session action not supported by provider',
+      reason: 'provider_capability_unsupported',
+      provider,
+      capability: 'archive',
+    },
+    { status: 403 },
+  );
+}
+
+function createRestoreFailureResponse(
+  status: number,
+  message?: string,
+  reason: 'restore_request_failed' | 'upstream_unreachable' = 'restore_request_failed'
+) {
+  return Response.json(
+    {
+      error: 'Failed to restore session',
+      reason,
+      ...(message ? { message } : {}),
+    },
+    { status },
+  );
+}
+
+async function forwardRemoteRestore(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: 'DELETE',
+      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 restore 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;
+  let actionTarget: ActionSessionReference;
+
+  try {
+    actionTarget = parseActionSessionReference(id);
+  } catch {
+    return createInvalidActionSessionIdResponse();
+  }
+
+  const provider = detectProviderFromRawId(actionTarget.sessionId);
+  if (!getDefaultProviderContext(provider).capabilities.archive) {
+    return createUnsupportedCapabilityResponse(actionTarget.sessionId);
+  }
+
+  if (provider === 'claude-code' && actionTarget.isRemote) {
+    return createUnsupportedCapabilityResponse(actionTarget.sessionId);
+  }
+
+  if (provider === 'claude-code') {
+    const localSessionId = resolveLocalActionSessionId(id);
+    if (localSessionId) {
+      markSessionForceUnarchived(localSessionId);
+      clearSessionStickyStatusBlocked(localSessionId);
+    }
+    await clearClaudeSessionArchived(extractProviderRawId(actionTarget.sessionId));
+    return Response.json({ success: true });
+  }
+
+  const sessionId = resolveLocalActionSessionId(id);
+  if (!sessionId && actionTarget.isRemote) {
+    return forwardRemoteRestore(actionTarget.hostId, actionTarget.sessionId);
+  }
+
+  if (!sessionId) {
+    return createInvalidActionSessionIdResponse();
+  }
+
+  const { ports, timedOut } = discoverOpencodePortsWithMeta();
+  if (!ports.length) {
+    return Response.json({ error: timedOut ? 'OpenCode discovery timed out' : 'OpenCode server not found' }, { status: 503 });
+  }
+
+  let sawNotFound = false;
+  let lastFailureStatus: number | null = null;
+  let lastFailureMessage: string | undefined;
+  let lastFailureReason: 'restore_request_failed' | 'upstream_unreachable' = 'restore_request_failed';
+
+  for (const port of ports) {
+    try {
+      const response = await fetch(`http://localhost:${port}/session/${sessionId}`, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ time: { archived: null } }),
+      });
+      if (response.ok) {
+        markSessionForceUnarchived(sessionId);
+        clearSessionStickyStatusBlocked(sessionId);
+        return Response.json({ success: true });
+      }
+
+      if (response.status === 404) {
+        sawNotFound = true;
+        continue;
+      }
+
+      const responseText = await response.text();
+      console.error(`Failed to restore session on port ${port}:`, responseText);
+      lastFailureStatus = response.status;
+      lastFailureMessage = responseText || undefined;
+      lastFailureReason = 'restore_request_failed';
+    } catch (error) {
+      console.error(`Failed to restore session on port ${port}:`, error);
+      lastFailureStatus = 503;
+      lastFailureMessage = error instanceof Error ? error.message : String(error);
+      lastFailureReason = 'upstream_unreachable';
+    }
+  }
+
+  if (lastFailureStatus !== null) {
+    return createRestoreFailureResponse(lastFailureStatus, lastFailureMessage, lastFailureReason);
+  }
+
+  if (sawNotFound) {
+    return createSessionNotFoundResponse();
+  }
+
+  return createRestoreFailureResponse(500);
+}