vibepulse 0.2.2 → 0.3.1-beta

package/.next/standalone/src/lib/session-providers/localAggregator.test.ts

@@ -0,0 +1,322 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('@opencode-ai/sdk', () => ({
+  createOpencodeClient: vi.fn(),
+}));
+
+vi.mock('@/lib/opencodeDiscovery', () => ({
+  discoverOpencodePortsWithMeta: vi.fn(),
+  discoverOpencodeProcessCwdsWithoutPortWithMeta: vi.fn(),
+}));
+
+vi.mock('child_process', async () => {
+  const execSync = vi.fn();
+  return {
+    execSync,
+    default: {
+      execSync,
+    },
+  };
+});
+
+vi.mock('@/lib/sessionArchiveOverrides', () => ({
+  clearSessionForceUnarchived: vi.fn(),
+  markSessionForceUnarchived: vi.fn(),
+  pruneSessionStickyStatusBlocked: vi.fn(),
+  pruneSessionForceUnarchived: vi.fn(),
+  shouldForceSessionUnarchived: vi.fn(() => false),
+  takeSessionStickyStatusBlocked: vi.fn(() => false),
+}));
+
+import { createOpencodeClient } from '@opencode-ai/sdk';
+import { execSync } from 'child_process';
+import {
+  discoverOpencodePortsWithMeta,
+  discoverOpencodeProcessCwdsWithoutPortWithMeta,
+} from '@/lib/opencodeDiscovery';
+import { getLocalSessionsResult } from './localAggregator';
+import { opencodeLocalSessionProvider } from './opencodeProvider';
+import type { LocalSessionProvider } from './types';
+
+const mockSessionList: any = vi.fn();
+const mockSessionStatus: any = vi.fn();
+const mockSessionMessages: any = vi.fn();
+const mockCreateOpencodeClient: any = createOpencodeClient;
+const mockDiscoverPortsWithMeta: any = discoverOpencodePortsWithMeta;
+const mockDiscoverProcessCwdsWithoutPortWithMeta: any = discoverOpencodeProcessCwdsWithoutPortWithMeta;
+const mockExecSync: any = execSync;
+
+function resetDefaultClientMock(): void {
+  mockCreateOpencodeClient.mockImplementation(() => ({
+    session: {
+      list: mockSessionList,
+      status: mockSessionStatus,
+      messages: mockSessionMessages,
+    },
+  }) as never);
+}
+
+function setupHappyPathMocks(): void {
+  resetDefaultClientMock();
+
+  mockDiscoverProcessCwdsWithoutPortWithMeta.mockReturnValue({
+    processes: [{ pid: 321, cwd: '/repo/orphan-project' }],
+    timedOut: false,
+  });
+
+  mockDiscoverPortsWithMeta.mockReturnValue({
+    ports: [7777],
+    timedOut: false,
+  });
+
+  mockSessionList.mockResolvedValue({
+    data: [
+      {
+        id: 'parent-1',
+        slug: 'parent-1',
+        title: 'Parent Session',
+        directory: '/repo/project-one',
+        time: { created: 1_000, updated: Date.now() - 5_000 },
+      },
+      {
+        id: 'child-1',
+        title: 'Child Session',
+        directory: '/repo/project-one',
+        parentID: 'parent-1',
+        time: { created: 1_100, updated: Date.now() - 3_000 },
+      },
+    ],
+  });
+
+  mockSessionStatus.mockResolvedValue({
+    data: {
+      'parent-1': { type: 'busy' },
+    },
+  });
+
+  mockSessionMessages.mockImplementation(({ path }: { path: { id: string } }) => {
+    if (path.id === 'child-1') {
+      return Promise.resolve({
+        data: [
+          {
+            parts: [{ state: { status: 'awaiting-input' } }],
+          },
+        ],
+      });
+    }
+
+    return Promise.resolve({
+      data: [
+        {
+          parts: [{ state: { status: 'running' } }],
+        },
+      ],
+    });
+  });
+
+  mockExecSync.mockImplementation((command: string) => {
+    if (command === 'git rev-parse --is-inside-work-tree') {
+      return 'true\n';
+    }
+
+    if (command === 'git branch --show-current') {
+      return 'main\n';
+    }
+
+    throw new Error(`Unexpected command: ${command}`);
+  });
+}
+
+afterEach(() => {
+  vi.clearAllMocks();
+  resetDefaultClientMock();
+});
+
+describe('localAggregator OpenCode provider boundary', () => {
+  it('returns the same plain local payload semantics through the provider-backed boundary', async () => {
+    setupHappyPathMocks();
+
+    const result = await getLocalSessionsResult({
+      stickyBusyDelayMs: 1000,
+      providers: [opencodeLocalSessionProvider],
+    });
+
+    expect(result.status).toBeUndefined();
+    expect(result.sourceMeta).toEqual({ online: true });
+    expect(result.payload).toMatchObject({
+      sessions: [
+        {
+          id: 'parent-1',
+          slug: 'parent-1',
+          title: 'Parent Session',
+          directory: '/repo/project-one',
+          projectName: 'project-one',
+          branch: 'main',
+          realTimeStatus: 'busy',
+          waitingForUser: false,
+          children: [
+            {
+              id: 'child-1',
+              title: 'Child Session',
+              directory: '/repo/project-one',
+              parentID: 'parent-1',
+              realTimeStatus: 'busy',
+              waitingForUser: true,
+            },
+          ],
+        },
+      ],
+      processHints: [
+        {
+          pid: 321,
+          directory: '/repo/orphan-project',
+          projectName: 'orphan-project',
+          reason: 'process_without_api_port',
+        },
+      ],
+    });
+
+    const payload = result.payload as any;
+    expect(payload.sessions[0].hostId).toBeUndefined();
+    expect(payload.sessions[0].rawSessionId).toBeUndefined();
+    expect(payload.sessions[0].sourceSessionKey).toBeUndefined();
+    expect(payload.sessions[0].children[0].hostId).toBeUndefined();
+    expect(mockCreateOpencodeClient.mock.calls).toEqual([[{ baseUrl: 'http://localhost:7777' }]]);
+  });
+
+  it('preserves offline process-hint semantics through the provider-backed boundary', async () => {
+    mockDiscoverProcessCwdsWithoutPortWithMeta.mockReturnValue({
+      processes: [{ pid: 654, cwd: '/repo/offline-local-project' }],
+      timedOut: false,
+    });
+    mockDiscoverPortsWithMeta.mockReturnValue({
+      ports: [],
+      timedOut: false,
+    });
+
+    const result = await getLocalSessionsResult({
+      stickyBusyDelayMs: 1000,
+      providers: [opencodeLocalSessionProvider],
+    });
+
+    expect(result.status).toBeUndefined();
+    expect(result.sourceMeta).toEqual({
+      online: false,
+      reason: 'OpenCode server not found',
+    });
+    expect(result.payload).toEqual({
+      sessions: [],
+      processHints: [
+        {
+          pid: 654,
+          directory: '/repo/offline-local-project',
+          projectName: 'offline-local-project',
+          reason: 'process_without_api_port',
+        },
+      ],
+    });
+  });
+
+  it('merges local polling sessions across providers while keeping plain local payload semantics', async () => {
+    setupHappyPathMocks();
+
+    const claudeProvider: LocalSessionProvider = {
+      id: 'claude-code',
+      async getSessionsResult() {
+        return {
+          payload: {
+            sessions: [
+              {
+                id: 'claude~550e8400-e29b-41d4-a716-446655440000',
+                slug: 'claude~550e8400-e29b-41d4-a716-446655440000',
+                title: 'Claude Session',
+                directory: '/repo/project-one',
+                projectName: 'project-one',
+                branch: 'main',
+                provider: 'claude-code',
+                providerRawId: '550e8400-e29b-41d4-a716-446655440000',
+                rawSessionId: '550e8400-e29b-41d4-a716-446655440000',
+                realTimeStatus: 'busy',
+                waitingForUser: false,
+                readOnly: true,
+                children: [],
+              },
+            ],
+            processHints: [],
+          },
+          sourceMeta: { online: true },
+        };
+      },
+    };
+
+    const result = await getLocalSessionsResult({
+      stickyBusyDelayMs: 1000,
+      providers: [opencodeLocalSessionProvider, claudeProvider],
+    });
+
+    expect(result.status).toBeUndefined();
+    expect(result.sourceMeta).toEqual({ online: true });
+    expect((result.payload as any).sessions).toHaveLength(2);
+    expect((result.payload as any).sessions).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: 'parent-1' }),
+        expect.objectContaining({
+          id: 'claude~550e8400-e29b-41d4-a716-446655440000',
+          provider: 'claude-code',
+          providerRawId: '550e8400-e29b-41d4-a716-446655440000',
+          rawSessionId: '550e8400-e29b-41d4-a716-446655440000',
+          readOnly: true,
+          children: [],
+        }),
+      ])
+    );
+    const openCodeSession = (result.payload as any).sessions.find((session: any) => session.id === 'parent-1');
+    expect(openCodeSession).not.toHaveProperty('provider');
+    expect(openCodeSession).not.toHaveProperty('hostId');
+    expect(openCodeSession).not.toHaveProperty('rawSessionId');
+    expect(openCodeSession).not.toHaveProperty('readOnly');
+    expect((result.payload as any).processHints).toHaveLength(1);
+  });
+
+  it('keeps OpenCode polling intact when Claude provider contributes no sessions', async () => {
+    setupHappyPathMocks();
+
+    const claudeProvider: LocalSessionProvider = {
+      id: 'claude-code',
+      async getSessionsResult() {
+        return {
+          payload: { sessions: [], processHints: [] },
+          sourceMeta: { online: false },
+        };
+      },
+    };
+
+    const result = await getLocalSessionsResult({
+      stickyBusyDelayMs: 1000,
+      providers: [opencodeLocalSessionProvider, claudeProvider],
+    });
+
+    expect(result.status).toBeUndefined();
+    expect(result.sourceMeta).toEqual({ online: true });
+    expect(result.payload).toMatchObject({
+      sessions: [
+        {
+          id: 'parent-1',
+          children: [
+            {
+              id: 'child-1',
+            },
+          ],
+        },
+      ],
+      processHints: [
+        {
+          pid: 321,
+          directory: '/repo/orphan-project',
+          projectName: 'orphan-project',
+          reason: 'process_without_api_port',
+        },
+      ],
+    });
+  });
+});

package/.next/standalone/src/lib/session-providers/localAggregator.ts

@@ -0,0 +1,302 @@
+import {
+  clearSessionForceUnarchived,
+  markSessionForceUnarchived,
+  takeSessionStickyStatusBlocked,
+} from '@/lib/sessionArchiveOverrides';
+import type {
+  EnrichedSession,
+  LocalSessionProvider,
+  ProcessHint,
+  SessionStatusStabilizationTarget,
+  SessionsRouteResult,
+  SessionsSuccessPayload,
+  SourceResultMeta,
+  StableRealtimeStatus,
+} from './types';
+
+type StatusStickyState = {
+  lastBusyAt: number;
+  lastSeenAt: number;
+};
+
+const STATUS_STICKY_RETENTION_MS = 24 * 60 * 60 * 1000;
+const STATUS_STICKY_ABSENT_RETENTION_MS = 30 * 60 * 1000;
+const DEFAULT_STATUS_STICKY_MAX_ENTRIES = 5000;
+
+const statusStickyState = new Map<string, StatusStickyState>();
+
+function clearStickyStatusState(sessionId: string): void {
+  statusStickyState.delete(sessionId);
+  statusStickyState.delete(`child:${sessionId}`);
+}
+
+export async function getLocalSessionsResult({
+  stickyBusyDelayMs,
+  providers,
+}: {
+  stickyBusyDelayMs: number;
+  providers: LocalSessionProvider[];
+}): Promise<SessionsRouteResult> {
+  if (providers.length === 0) {
+    return {
+      payload: { sessions: [], processHints: [] },
+      sourceMeta: {
+        online: false,
+        degraded: true,
+        reason: 'No local session provider configured',
+      },
+    };
+  }
+
+  const results = await Promise.allSettled(
+    providers.map((provider) => provider.getSessionsResult({ stickyBusyDelayMs }))
+  );
+
+  const aggregateSessions: EnrichedSession[] = [];
+  const aggregateProcessHints: ProcessHint[] = [];
+  const aggregateFailedPorts: Array<{ port: number; reason: string }> = [];
+  let fallbackResult: SessionsRouteResult | null = null;
+  let anyOnline = false;
+  let degraded = false;
+  let offlineReason: string | undefined;
+
+  for (const result of results) {
+    if (result.status !== 'fulfilled') {
+      degraded = true;
+      if (!offlineReason) {
+        offlineReason = result.reason instanceof Error ? result.reason.message : String(result.reason);
+      }
+      continue;
+    }
+
+    const providerResult = result.value;
+    const payload = readSuccessPayload(providerResult.payload);
+    const meta = providerResult.sourceMeta ?? {
+      online: payload.sessions.length > 0,
+      ...(providerResult.status ? { degraded: true } : {}),
+    };
+
+    if (!fallbackResult && providerResult.status && payload.sessions.length === 0 && payload.processHints.length === 0) {
+      fallbackResult = providerResult;
+    }
+
+    if (payload.sessions.length > 0 || payload.processHints.length > 0 || (payload.failedPorts?.length ?? 0) > 0) {
+      aggregateSessions.push(...payload.sessions);
+      aggregateProcessHints.push(...payload.processHints);
+      if (payload.failedPorts) {
+        aggregateFailedPorts.push(...payload.failedPorts);
+      }
+    }
+
+    if (meta.online || payload.sessions.length > 0) {
+      anyOnline = true;
+    }
+
+    if (!anyOnline && !offlineReason && meta.reason) {
+      offlineReason = meta.reason;
+    }
+
+    if (meta.degraded || payload.degraded) {
+      degraded = true;
+    }
+  }
+
+  if (aggregateSessions.length === 0 && aggregateProcessHints.length === 0 && fallbackResult) {
+    return fallbackResult;
+  }
+
+  const sourceMeta: SourceResultMeta = anyOnline
+    ? {
+        online: true,
+        ...(degraded ? { degraded: true } : {}),
+      }
+    : {
+        online: false,
+        ...(degraded ? { degraded: true } : {}),
+        ...(offlineReason ? { reason: offlineReason } : {}),
+      };
+
+  return {
+    payload: {
+      sessions: aggregateSessions,
+      processHints: aggregateProcessHints,
+      ...(aggregateFailedPorts.length > 0 ? { failedPorts: aggregateFailedPorts } : {}),
+      ...(degraded ? { degraded: true } : {}),
+    },
+    sourceMeta,
+  };
+}
+
+function readSuccessPayload(payload: SessionsRouteResult['payload']): SessionsSuccessPayload {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    return { sessions: [], processHints: [] };
+  }
+
+  const sessions = Array.isArray(payload['sessions']) ? (payload['sessions'] as EnrichedSession[]) : [];
+  const processHints = Array.isArray(payload['processHints']) ? (payload['processHints'] as ProcessHint[]) : [];
+  const failedPorts = Array.isArray(payload['failedPorts'])
+    ? (payload['failedPorts'] as Array<{ port: number; reason: string }>)
+    : undefined;
+  const degraded = payload['degraded'] === true;
+
+  return {
+    sessions,
+    processHints,
+    ...(failedPorts ? { failedPorts } : {}),
+    ...(degraded ? { degraded: true } : {}),
+  };
+}
+
+export function applyStickyBusyStatus(
+  id: string,
+  status: StableRealtimeStatus,
+  now: number,
+  stickyBusyWindowMs: number
+): StableRealtimeStatus {
+  const existing = statusStickyState.get(id) ?? { lastBusyAt: 0, lastSeenAt: now };
+
+  if (status === 'busy') {
+    existing.lastBusyAt = now;
+    existing.lastSeenAt = now;
+    statusStickyState.set(id, existing);
+    return status;
+  }
+
+  if (status === 'retry') {
+    existing.lastSeenAt = now;
+    statusStickyState.set(id, existing);
+    return status;
+  }
+
+  const shouldKeepBusy = existing.lastBusyAt > 0 && now - existing.lastBusyAt <= stickyBusyWindowMs;
+  existing.lastSeenAt = now;
+  statusStickyState.set(id, existing);
+  return shouldKeepBusy ? 'busy' : 'idle';
+}
+
+function getStickyStateMaxEntries(): number {
+  const raw = Number(process.env.OPENCODE_STATUS_STICKY_MAX_ENTRIES);
+  if (Number.isFinite(raw) && raw > 0) {
+    return Math.floor(raw);
+  }
+  return DEFAULT_STATUS_STICKY_MAX_ENTRIES;
+}
+
+export function pruneStickyState(now: number, activeIds: Set<string>): void {
+  for (const [id, state] of statusStickyState) {
+    const ageMs = now - state.lastSeenAt;
+    const isActive = activeIds.has(id);
+    if (ageMs > STATUS_STICKY_RETENTION_MS || (!isActive && ageMs > STATUS_STICKY_ABSENT_RETENTION_MS)) {
+      statusStickyState.delete(id);
+    }
+  }
+
+  const maxEntries = getStickyStateMaxEntries();
+  if (statusStickyState.size <= maxEntries) {
+    return;
+  }
+
+  const overflow = statusStickyState.size - maxEntries;
+  const sortedByLastSeen = Array.from(statusStickyState.entries()).sort((a, b) => a[1].lastSeenAt - b[1].lastSeenAt);
+
+  let removed = 0;
+  for (const [id] of sortedByLastSeen) {
+    if (removed >= overflow) break;
+    if (activeIds.has(id)) continue;
+    statusStickyState.delete(id);
+    removed++;
+  }
+
+  if (removed >= overflow) {
+    return;
+  }
+
+  for (const [id] of sortedByLastSeen) {
+    if (removed >= overflow) break;
+    if (!statusStickyState.has(id)) continue;
+    statusStickyState.delete(id);
+    removed++;
+  }
+}
+
+function clearSessionStabilizationState(session: SessionStatusStabilizationTarget): void {
+  clearStickyStatusState(session.id);
+  clearSessionForceUnarchived(session.id);
+  for (const child of session.children) {
+    clearStickyStatusState(`child:${child.id}`);
+    clearSessionForceUnarchived(child.id);
+  }
+}
+
+function normalizeRealtimeStatus(value: string | undefined): StableRealtimeStatus {
+  if (value === 'busy' || value === 'retry') return value;
+  return 'idle';
+}
+
+export function shouldSkipSessionStatusStabilization(
+  session: SessionStatusStabilizationTarget,
+  now: number
+): boolean {
+  if (takeSessionStickyStatusBlocked(session.id, now)) {
+    clearSessionStabilizationState(session);
+    return true;
+  }
+
+  if (session.time?.archived) {
+    clearSessionStabilizationState(session);
+    return true;
+  }
+
+  return false;
+}
+
+export function applyStickyStatusStabilization(
+  session: SessionStatusStabilizationTarget,
+  stickyNow: number,
+  stickyBusyDelayMs: number
+): void {
+  for (const child of session.children) {
+    if (child.time?.archived) {
+      clearStickyStatusState(`child:${child.id}`);
+      clearSessionForceUnarchived(child.id);
+      continue;
+    }
+
+    const normalizedChildStatus = normalizeRealtimeStatus(child.realTimeStatus);
+    const childStatusForStabilization =
+      child.waitingForUser && normalizedChildStatus === 'idle' ? 'retry' : normalizedChildStatus;
+    child.realTimeStatus = applyStickyBusyStatus(
+      `child:${child.id}`,
+      childStatusForStabilization,
+      stickyNow,
+      stickyBusyDelayMs
+    );
+
+    if (child.realTimeStatus === 'busy' || child.realTimeStatus === 'retry' || child.waitingForUser) {
+      markSessionForceUnarchived(child.id, stickyNow);
+    }
+  }
+
+  const normalizedSessionStatus = normalizeRealtimeStatus(session.realTimeStatus);
+  const sessionStatusForStabilization =
+    session.waitingForUser && normalizedSessionStatus === 'idle' ? 'retry' : normalizedSessionStatus;
+  session.realTimeStatus = applyStickyBusyStatus(
+    session.id,
+    sessionStatusForStabilization,
+    stickyNow,
+    stickyBusyDelayMs
+  );
+
+  const hasActiveChildren = session.children.some(
+    (child) => child.realTimeStatus === 'busy' || child.realTimeStatus === 'retry' || child.waitingForUser
+  );
+  const shouldAutoUnarchive =
+    session.realTimeStatus === 'busy' ||
+    session.realTimeStatus === 'retry' ||
+    session.waitingForUser ||
+    hasActiveChildren;
+
+  if (shouldAutoUnarchive) {
+    markSessionForceUnarchived(session.id, stickyNow);
+  }
+}