vibepulse 0.2.1 → 0.3.0-beta.0

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

@@ -13,13 +13,19 @@ vi.mock('@/lib/sessionArchiveOverrides', () => ({
   markSessionStickyStatusBlocked: vi.fn(),
 }));
 
+vi.mock('@/lib/claudeSessionOverrides', () => ({
+  markClaudeSessionArchived: vi.fn(),
+}));
+
 import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
 import { listNodeRecords } from '@/lib/nodeRegistry';
+import { markClaudeSessionArchived } from '@/lib/claudeSessionOverrides';
 
 import { POST } from './route';
 
 const mockDiscoverPortsWithMeta: any = discoverOpencodePortsWithMeta;
 const mockListNodeRecords: any = listNodeRecords;
+const mockMarkClaudeSessionArchived: any = markClaudeSessionArchived;
 
 describe('/api/sessions/[id]/archive', () => {
   beforeEach(() => {
@@ -40,6 +46,23 @@ describe('/api/sessions/[id]/archive', () => {
     expect(mockFetch).toHaveBeenCalledWith('http://localhost:7777/session/abc', expect.objectContaining({ method: 'PATCH' }));
   });
 
+  it('treats UUID-like local ids without claude namespace as opencode sessions', async () => {
+    const opencodeUuid = '550e8400-e29b-41d4-a716-446655440000';
+    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:${opencodeUuid}/archive`, { method: 'POST' }), {
+      params: Promise.resolve({ id: `local:${opencodeUuid}` }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(404);
+    expect(data).toEqual({ error: 'Session not found', reason: 'session_not_found' });
+    expect(mockMarkClaudeSessionArchived).not.toHaveBeenCalled();
+    expect(mockDiscoverPortsWithMeta).toHaveBeenCalled();
+    expect(mockFetch).toHaveBeenCalledWith(`http://localhost:7777/session/${opencodeUuid}`, expect.objectContaining({ method: 'PATCH' }));
+  });
+
   it('forwards remote archive ids to the matching node endpoint', async () => {
     mockListNodeRecords.mockResolvedValue([
       {
@@ -98,6 +121,84 @@ describe('/api/sessions/[id]/archive', () => {
     expect(data).toEqual({ error: 'Session not found', reason: 'session_not_found' });
   });
 
+  it('archives Claude sessions through local override storage before any OpenCode execution', async () => {
+    const mockFetch = vi.fn();
+    vi.stubGlobal('fetch', mockFetch);
+
+    const response = await POST(new Request('http://localhost/api/sessions/local:claude~550e8400-e29b-41d4-a716-446655440000/archive', { 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(mockMarkClaudeSessionArchived).toHaveBeenCalledWith('550e8400-e29b-41d4-a716-446655440000');
+    expect(mockDiscoverPortsWithMeta).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('archives scoped Claude sidechain sessions through local override storage', 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/local:${scopedSessionId}/archive`, { method: 'POST' }), {
+      params: Promise.resolve({ id: `local:${scopedSessionId}` }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data).toEqual({ success: true });
+    expect(mockMarkClaudeSessionArchived).toHaveBeenCalledWith(scopedSessionId);
+    expect(mockDiscoverPortsWithMeta).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('rejects remote Claude archive 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/archive', { 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(mockMarkClaudeSessionArchived).not.toHaveBeenCalled();
+    expect(mockListNodeRecords).not.toHaveBeenCalled();
+    expect(mockDiscoverPortsWithMeta).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('rejects remote scoped Claude sidechain archive 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}/archive`, { 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(mockMarkClaudeSessionArchived).not.toHaveBeenCalled();
+    expect(mockListNodeRecords).not.toHaveBeenCalled();
+    expect(mockDiscoverPortsWithMeta).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
   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);

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

@@ -1,11 +1,13 @@
 import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
-import { parseActionSessionReference, resolveLocalActionSessionId } from '@/lib/hostIdentity';
+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 {
-    clearSessionForceUnarchived,
-    markSessionStickyStatusBlocked,
+  clearSessionForceUnarchived,
+  markSessionStickyStatusBlocked,
 } from '@/lib/sessionArchiveOverrides';
+import { markClaudeSessionArchived } from '@/lib/claudeSessionOverrides';
 
 const REMOTE_NODE_ACTION_TIMEOUT_MS = 5_000;
 
@@ -23,6 +25,20 @@ function createSessionNotFoundResponse() {
     );
 }
 
+function createUnsupportedCapabilityResponse(capability: 'archive', sessionId: string) {
+    const provider = detectProviderFromRawId(sessionId);
+
+    return Response.json(
+        {
+            error: 'Session action not supported by provider',
+            reason: 'provider_capability_unsupported',
+            provider,
+            capability,
+        },
+        { status: 403 }
+    );
+}
+
 function createArchiveFailureResponse(
     status: number,
     message?: string,
@@ -87,17 +103,36 @@ async function forwardRemoteArchive(hostId: string, sessionId: string): Promise<
 
 export async function POST(_: Request, { params }: { params: Promise<{ id: string }> }) {
     const { id } = await params;
-    const sessionId = resolveLocalActionSessionId(id);
+    let actionTarget: ActionSessionReference;
 
-    if (!sessionId) {
-        try {
-            const actionTarget = parseActionSessionReference(id);
-            if (actionTarget.isRemote) {
-                return forwardRemoteArchive(actionTarget.hostId, actionTarget.sessionId);
-            }
-        } catch {
-            return createInvalidActionSessionIdResponse();
+    try {
+        actionTarget = parseActionSessionReference(id);
+    } catch {
+        return createInvalidActionSessionIdResponse();
+    }
+
+    const provider = detectProviderFromRawId(actionTarget.sessionId);
+    if (!getDefaultProviderContext(provider).capabilities.archive) {
+        return createUnsupportedCapabilityResponse('archive', actionTarget.sessionId);
+    }
+
+    if (provider === 'claude-code' && actionTarget.isRemote) {
+        return createUnsupportedCapabilityResponse('archive', actionTarget.sessionId);
+    }
+
+    if (provider === 'claude-code') {
+        await markClaudeSessionArchived(extractProviderRawId(actionTarget.sessionId));
+        const localSessionId = resolveLocalActionSessionId(id);
+        if (localSessionId) {
+            clearSessionForceUnarchived(localSessionId);
+            markSessionStickyStatusBlocked(localSessionId);
         }
+        return Response.json({ success: true });
+    }
+
+    const sessionId = resolveLocalActionSessionId(id);
+    if (!sessionId && actionTarget.isRemote) {
+        return forwardRemoteArchive(actionTarget.hostId, actionTarget.sessionId);
     }
 
     if (!sessionId) {

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

@@ -17,15 +17,21 @@ vi.mock('@/lib/sessionArchiveOverrides', () => ({
   clearSessionStickyStatusBlocked: vi.fn(),
 }));
 
+vi.mock('@/lib/claudeSessionOverrides', () => ({
+  markClaudeSessionDeleted: vi.fn(),
+}));
+
 import { createOpencodeClient } from '@opencode-ai/sdk';
 import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
 import { listNodeRecords } from '@/lib/nodeRegistry';
+import { markClaudeSessionDeleted } from '@/lib/claudeSessionOverrides';
 
 import { POST } from './route';
 
 const mockCreateOpencodeClient: any = createOpencodeClient;
 const mockDiscoverPortsWithMeta: any = discoverOpencodePortsWithMeta;
 const mockListNodeRecords: any = listNodeRecords;
+const mockMarkClaudeSessionDeleted: any = markClaudeSessionDeleted;
 const mockSessionDelete = vi.fn();
 
 describe('/api/sessions/[id]/delete', () => {
@@ -110,4 +116,90 @@ describe('/api/sessions/[id]/delete', () => {
       message: '404 not found',
     });
   });
+
+  it('deletes Claude sessions through local override storage before any OpenCode execution', async () => {
+    const mockFetch = vi.fn();
+    vi.stubGlobal('fetch', mockFetch);
+
+    const response = await POST(new Request('http://localhost/api/sessions/local:claude~550e8400-e29b-41d4-a716-446655440000/delete', { 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(mockMarkClaudeSessionDeleted).toHaveBeenCalledWith('550e8400-e29b-41d4-a716-446655440000');
+    expect(mockDiscoverPortsWithMeta).not.toHaveBeenCalled();
+    expect(mockCreateOpencodeClient).not.toHaveBeenCalled();
+    expect(mockSessionDelete).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('deletes scoped Claude sidechain sessions through local override storage', 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/local:${scopedSessionId}/delete`, { method: 'POST' }), {
+      params: Promise.resolve({ id: `local:${scopedSessionId}` }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data).toEqual({ success: true });
+    expect(mockMarkClaudeSessionDeleted).toHaveBeenCalledWith(scopedSessionId);
+    expect(mockDiscoverPortsWithMeta).not.toHaveBeenCalled();
+    expect(mockCreateOpencodeClient).not.toHaveBeenCalled();
+    expect(mockSessionDelete).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('rejects remote Claude delete 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/delete', { 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: 'delete',
+    });
+    expect(mockMarkClaudeSessionDeleted).not.toHaveBeenCalled();
+    expect(mockListNodeRecords).not.toHaveBeenCalled();
+    expect(mockDiscoverPortsWithMeta).not.toHaveBeenCalled();
+    expect(mockCreateOpencodeClient).not.toHaveBeenCalled();
+    expect(mockSessionDelete).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('rejects remote scoped Claude sidechain deletes 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}/delete`, { 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: 'delete',
+    });
+    expect(mockMarkClaudeSessionDeleted).not.toHaveBeenCalled();
+    expect(mockListNodeRecords).not.toHaveBeenCalled();
+    expect(mockDiscoverPortsWithMeta).not.toHaveBeenCalled();
+    expect(mockCreateOpencodeClient).not.toHaveBeenCalled();
+    expect(mockSessionDelete).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
 });

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

@@ -1,12 +1,14 @@
 import { createOpencodeClient } from '@opencode-ai/sdk';
 import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
-import { parseActionSessionReference, resolveLocalActionSessionId } from '@/lib/hostIdentity';
+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 {
     clearSessionForceUnarchived,
     clearSessionStickyStatusBlocked,
 } from '@/lib/sessionArchiveOverrides';
+import { markClaudeSessionDeleted } from '@/lib/claudeSessionOverrides';
 
 const REMOTE_NODE_ACTION_TIMEOUT_MS = 5_000;
 
@@ -28,6 +30,20 @@ function createSessionNotFoundResponse(message?: string) {
     );
 }
 
+function createUnsupportedCapabilityResponse(capability: 'delete', sessionId: string) {
+    const provider = detectProviderFromRawId(sessionId);
+
+    return Response.json(
+        {
+            error: 'Session action not supported by provider',
+            reason: 'provider_capability_unsupported',
+            provider,
+            capability,
+        },
+        { status: 403 }
+    );
+}
+
 async function forwardRemoteDelete(hostId: string, sessionId: string): Promise<Response> {
     const nodeRecords = await listNodeRecords();
     const nodeRecord = nodeRecords.find((node) => node.nodeId === hostId);
@@ -77,17 +93,36 @@ async function forwardRemoteDelete(hostId: string, sessionId: string): Promise<R
 
 export async function POST(_: Request, { params }: { params: Promise<{ id: string }> }) {
     const { id } = await params;
-    const sessionId = resolveLocalActionSessionId(id);
+    let actionTarget: ActionSessionReference;
 
-    if (!sessionId) {
-        try {
-            const actionTarget = parseActionSessionReference(id);
-            if (actionTarget.isRemote) {
-                return forwardRemoteDelete(actionTarget.hostId, actionTarget.sessionId);
-            }
-        } catch {
-            return createInvalidActionSessionIdResponse();
+    try {
+        actionTarget = parseActionSessionReference(id);
+    } catch {
+        return createInvalidActionSessionIdResponse();
+    }
+
+    const provider = detectProviderFromRawId(actionTarget.sessionId);
+    if (!getDefaultProviderContext(provider).capabilities.delete) {
+        return createUnsupportedCapabilityResponse('delete', actionTarget.sessionId);
+    }
+
+    if (provider === 'claude-code' && actionTarget.isRemote) {
+        return createUnsupportedCapabilityResponse('delete', actionTarget.sessionId);
+    }
+
+    if (provider === 'claude-code') {
+        await markClaudeSessionDeleted(extractProviderRawId(actionTarget.sessionId));
+        const localSessionId = resolveLocalActionSessionId(id);
+        if (localSessionId) {
+            clearSessionForceUnarchived(localSessionId);
+            clearSessionStickyStatusBlocked(localSessionId);
         }
+        return Response.json({ success: true });
+    }
+
+    const sessionId = resolveLocalActionSessionId(id);
+    if (!sessionId && actionTarget.isRemote) {
+        return forwardRemoteDelete(actionTarget.hostId, actionTarget.sessionId);
     }
 
     if (!sessionId) {

package/.next/standalone/src/app/api/sessions/[id]/open-editor/route.test.ts

@@ -215,4 +215,78 @@ describe('/api/sessions/[id]/open-editor', () => {
     expect(response.status).toBe(400);
     expect(data).toEqual({ error: 'Invalid action session id', reason: 'invalid_action_session_id' });
   });
+
+  it('rejects unsupported Claude open-editor requests before remote 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/open-editor', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ tool: 'vscode' }),
+      }),
+      { 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: 'openEditor',
+    });
+    expect(mockListNodeRecords).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('rejects unsupported scoped Claude sidechain open-editor requests before remote 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}/open-editor`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ tool: 'vscode' }),
+      }),
+      { 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: 'openEditor',
+    });
+    expect(mockListNodeRecords).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('rejects local scoped Claude sidechain open-editor requests as unsupported capability', async () => {
+    const scopedSessionId = '550e8400-e29b-41d4-a716-446655440000__agent-a123';
+
+    const response = await POST(
+      new Request(`http://localhost/api/sessions/local:${scopedSessionId}/open-editor`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ tool: 'vscode' }),
+      }),
+      { params: Promise.resolve({ id: `local:${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: 'openEditor',
+    });
+    expect(mockListNodeRecords).not.toHaveBeenCalled();
+  });
 });

package/.next/standalone/src/app/api/sessions/[id]/open-editor/route.ts

@@ -1,6 +1,7 @@
-import { parseActionSessionReference } from '@/lib/hostIdentity';
+import { ActionSessionReference, parseActionSessionReference } from '@/lib/hostIdentity';
 import { listNodeRecords } from '@/lib/nodeRegistry';
 import { createNodeRequestHeaders } from '@/lib/nodeProtocol';
+import { detectProviderFromRawId, extractProviderRawId, getDefaultProviderContext } from '@/lib/session-providers/providerIds';
 
 const REMOTE_NODE_ACTION_TIMEOUT_MS = 5_000;
 
@@ -18,16 +19,35 @@ function createSessionNotFoundResponse() {
   );
 }
 
+function createUnsupportedCapabilityResponse(capability: 'openEditor', sessionId: string) {
+  const provider = detectProviderFromRawId(sessionId);
+
+  return Response.json(
+    {
+      error: 'Session action not supported by provider',
+      reason: 'provider_capability_unsupported',
+      provider,
+      capability,
+    },
+    { status: 403 }
+  );
+}
+
 export async function POST(request: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params;
 
-  let actionTarget;
+  let actionTarget: ActionSessionReference;
   try {
     actionTarget = parseActionSessionReference(id);
   } catch {
     return createInvalidActionSessionIdResponse();
   }
 
+  const provider = detectProviderFromRawId(actionTarget.sessionId);
+  if (!getDefaultProviderContext(provider).capabilities.openEditor) {
+    return createUnsupportedCapabilityResponse('openEditor', actionTarget.sessionId);
+  }
+
   if (!actionTarget.isRemote) {
     return createInvalidActionSessionIdResponse();
   }