@agent-relay/dashboard 2.0.82 → 2.0.84

package/src/adapters/types.ts

@@ -0,0 +1,508 @@
+import type { ComponentType } from 'react';
+
+export interface DashboardFeatures {
+  billing: boolean;
+  teams: boolean;
+  workspaces: boolean;
+  auth: boolean;
+}
+
+export interface CloudSettingsSlots {
+  BillingPanel?: ComponentType;
+  TeamPanel?: ComponentType;
+  WorkspacePanel?: ComponentType;
+}
+
+export type SessionErrorCode = 'SESSION_EXPIRED' | 'USER_NOT_FOUND' | 'SESSION_ERROR';
+
+export interface SessionError {
+  error: string;
+  code: SessionErrorCode;
+  message: string;
+}
+
+export type SessionExpiredCallback = (error: SessionError) => void;
+
+export interface SessionStatus {
+  authenticated: boolean;
+  code?: SessionErrorCode;
+  message?: string;
+  user?: {
+    id: string;
+    githubUsername: string;
+    email?: string;
+    avatarUrl?: string;
+    plan: string;
+  };
+}
+
+export interface CloudUser {
+  id: string;
+  githubUsername: string;
+  email?: string;
+  avatarUrl?: string;
+  plan: string;
+  connectedProviders: Array<{
+    provider: string;
+    email?: string;
+    connectedAt: string;
+  }>;
+  pendingInvites: number;
+  onboardingCompleted: boolean;
+  displayName?: string;
+}
+
+export interface NangoLoginSession {
+  sessionToken: string;
+  tempUserId: string;
+}
+
+export interface NangoLoginStatus {
+  ready: boolean;
+  user?: {
+    id: string;
+    githubUsername: string;
+    email?: string;
+    avatarUrl?: string;
+    plan: string;
+  };
+}
+
+export interface NangoRepoSession {
+  sessionToken: string;
+}
+
+export interface NangoRepoStatus {
+  ready: boolean;
+  pendingApproval?: boolean;
+  message?: string;
+  repos?: Array<{
+    id: string;
+    fullName: string;
+    isPrivate: boolean;
+    defaultBranch: string;
+  }>;
+}
+
+export type CloudApiResult<T> =
+  | { success: true; data: T }
+  | { success: false; error: string; sessionExpired?: boolean };
+
+export type CloudApiResultWithoutSession<T> =
+  | { success: true; data: T }
+  | { success: false; error: string };
+
+export interface WorkspaceSummary {
+  id: string;
+  name: string;
+  status: string;
+  publicUrl?: string;
+  isStopped: boolean;
+  isRunning: boolean;
+  isProvisioning: boolean;
+  hasError: boolean;
+}
+
+export interface CloudApiAdapter {
+  getNangoLoginSession(): Promise<CloudApiResultWithoutSession<NangoLoginSession>>;
+  checkNangoLoginStatus(
+    connectionId: string
+  ): Promise<CloudApiResultWithoutSession<NangoLoginStatus>>;
+  getNangoRepoSession(): Promise<CloudApiResult<NangoRepoSession>>;
+  checkNangoRepoStatus(connectionId: string): Promise<CloudApiResult<NangoRepoStatus>>;
+  checkSession(): Promise<SessionStatus>;
+  getMe(): Promise<CloudApiResult<CloudUser>>;
+  logout(): Promise<{ success: boolean; error?: string }>;
+  getWorkspaces(): Promise<
+    CloudApiResult<{
+      workspaces: Array<{
+        id: string;
+        name: string;
+        slug: string;
+        repositories: number;
+        members: number;
+        plan: string;
+      }>;
+    }>
+  >;
+  getWorkspace(id: string): Promise<
+    CloudApiResult<{
+      id: string;
+      name: string;
+      slug: string;
+      config: Record<string, unknown>;
+      createdAt: string;
+    }>
+  >;
+  createWorkspace(data: { name: string; slug?: string }): Promise<
+    CloudApiResult<{
+      id: string;
+      name: string;
+      slug: string;
+    }>
+  >;
+  getPrimaryWorkspace(): Promise<
+    CloudApiResult<{
+      exists: boolean;
+      message?: string;
+      workspace?: {
+        id: string;
+        name: string;
+        status: string;
+        publicUrl?: string;
+        isStopped: boolean;
+        isRunning: boolean;
+        isProvisioning: boolean;
+        hasError: boolean;
+        config: {
+          providers: string[];
+          repositories: string[];
+        };
+      };
+      statusMessage: string;
+      actionNeeded?: 'wakeup' | 'check_error' | null;
+    }>
+  >;
+  getWorkspaceSummary(): Promise<
+    CloudApiResult<{
+      workspaces: WorkspaceSummary[];
+      summary: {
+        total: number;
+        running: number;
+        stopped: number;
+        provisioning: number;
+        error: number;
+      };
+      overallStatus: 'ready' | 'provisioning' | 'stopped' | 'none' | 'error';
+    }>
+  >;
+  getAccessibleWorkspaces(): Promise<
+    CloudApiResult<{
+      workspaces: Array<{
+        id: string;
+        name: string;
+        status: string;
+        publicUrl?: string;
+        providers?: string[];
+        repositories?: string[];
+        accessType: 'owner' | 'member' | 'contributor';
+        permission: 'admin' | 'write' | 'read';
+        createdAt: string;
+      }>;
+      summary: {
+        owned: number;
+        member: number;
+        contributor: number;
+        total: number;
+      };
+    }>
+  >;
+  getWorkspaceStatus(id: string): Promise<CloudApiResult<{ status: string }>>;
+  wakeupWorkspace(id: string): Promise<
+    CloudApiResult<{
+      status: string;
+      wasRestarted: boolean;
+      message: string;
+      estimatedStartTime?: number;
+      publicUrl?: string;
+    }>
+  >;
+  restartWorkspace(id: string): Promise<
+    CloudApiResult<{
+      success: boolean;
+      action: 'restarted' | 'reprovisioning';
+      message: string;
+    }>
+  >;
+  rebuildWorkspace(id: string): Promise<CloudApiResult<{ success: boolean; message: string }>>;
+  getProviders(workspaceId: string): Promise<
+    CloudApiResult<{
+      providers: Array<{
+        id: string;
+        name: string;
+        displayName: string;
+        description: string;
+        color: string;
+        authStrategy: string;
+        cliCommand?: string;
+        isConnected: boolean;
+        connectedAs?: string;
+        connectedAt?: string;
+      }>;
+    }>
+  >;
+  disconnectProvider(provider: string, workspaceId: string): Promise<CloudApiResult<{ success: boolean }>>;
+  getUserCredentials(): Promise<
+    CloudApiResult<{
+      credentials: Array<{
+        id: string;
+        provider: string;
+        providerAccountEmail?: string;
+        createdAt: string;
+        updatedAt: string;
+        workspaces: Array<{ id: string; name: string }>;
+      }>;
+    }>
+  >;
+  assignCredentialToWorkspace(
+    credentialId: string,
+    workspaceId: string
+  ): Promise<CloudApiResult<{ success: boolean }>>;
+  unassignCredentialFromWorkspace(
+    credentialId: string,
+    workspaceId: string
+  ): Promise<CloudApiResult<{ success: boolean }>>;
+  getWorkspaceMembers(workspaceId: string): Promise<
+    CloudApiResult<{
+      members: Array<{
+        id: string;
+        userId: string;
+        role: string;
+        isPending: boolean;
+        user?: {
+          githubUsername: string;
+          email?: string;
+          avatarUrl?: string;
+        };
+      }>;
+    }>
+  >;
+  getRepoCollaborators(workspaceId: string): Promise<
+    CloudApiResult<{
+      collaborators: Array<{
+        id: number;
+        login: string;
+        avatarUrl: string;
+        permission: 'admin' | 'write' | 'read' | 'none';
+        repos: string[];
+      }>;
+      totalRepos: number;
+      message?: string;
+    }>
+  >;
+  inviteMember(
+    workspaceId: string,
+    githubUsername: string,
+    role?: string
+  ): Promise<CloudApiResult<{ success: boolean; member: unknown }>>;
+  getPendingInvites(): Promise<
+    CloudApiResult<{
+      invites: Array<{
+        id: string;
+        workspaceId: string;
+        workspaceName: string;
+        role: string;
+        invitedAt: string;
+        invitedBy: string;
+      }>;
+    }>
+  >;
+  acceptInvite(inviteId: string): Promise<CloudApiResult<{ success: boolean; workspaceId: string }>>;
+  declineInvite(inviteId: string): Promise<CloudApiResult<{ success: boolean }>>;
+  updateMemberRole(
+    workspaceId: string,
+    memberId: string,
+    role: string
+  ): Promise<CloudApiResult<{ success: boolean; role: string }>>;
+  removeMember(workspaceId: string, memberId: string): Promise<CloudApiResult<{ success: boolean }>>;
+  getBillingPlans(): Promise<
+    CloudApiResult<{
+      plans: Array<{
+        tier: string;
+        name: string;
+        description: string;
+        price: { monthly: number; yearly: number };
+        features: string[];
+        limits: Record<string, number>;
+        recommended?: boolean;
+      }>;
+      publishableKey: string;
+    }>
+  >;
+  getSubscription(): Promise<
+    CloudApiResult<{
+      tier: string;
+      subscription: {
+        id: string;
+        tier: string;
+        status: string;
+        currentPeriodStart: string;
+        currentPeriodEnd: string;
+        cancelAtPeriodEnd: boolean;
+        interval: 'month' | 'year';
+      } | null;
+      customer: {
+        id: string;
+        email: string;
+        name?: string;
+        paymentMethods: Array<{
+          id: string;
+          type: string;
+          last4?: string;
+          brand?: string;
+          isDefault: boolean;
+        }>;
+        invoices: Array<{
+          id: string;
+          number: string;
+          amount: number;
+          status: string;
+          date: string;
+          pdfUrl?: string;
+        }>;
+      } | null;
+    }>
+  >;
+  createCheckoutSession(
+    tier: string,
+    interval?: 'month' | 'year'
+  ): Promise<CloudApiResult<{ sessionId: string; checkoutUrl: string }>>;
+  createBillingPortal(): Promise<CloudApiResult<{ sessionId: string; portalUrl: string }>>;
+  changeSubscription(
+    tier: string,
+    interval?: 'month' | 'year'
+  ): Promise<CloudApiResult<{ subscription: { tier: string; status: string } }>>;
+  cancelSubscription(): Promise<
+    CloudApiResult<{
+      subscription: { cancelAtPeriodEnd: boolean; currentPeriodEnd: string };
+      message: string;
+    }>
+  >;
+  resumeSubscription(): Promise<
+    CloudApiResult<{
+      subscription: { cancelAtPeriodEnd: boolean };
+      message: string;
+    }>
+  >;
+  getInvoices(): Promise<
+    CloudApiResult<{
+      invoices: Array<{
+        id: string;
+        number: string;
+        amount: number;
+        status: string;
+        date: string;
+        pdfUrl?: string;
+      }>;
+    }>
+  >;
+  stopWorkspace(id: string): Promise<CloudApiResult<{ success: boolean; message: string }>>;
+  deleteWorkspace(id: string): Promise<CloudApiResult<{ success: boolean; message: string }>>;
+  addReposToWorkspace(
+    workspaceId: string,
+    repositoryIds: string[]
+  ): Promise<CloudApiResult<{ success: boolean; message: string }>>;
+  setCustomDomain(workspaceId: string, domain: string): Promise<
+    CloudApiResult<{
+      success: boolean;
+      domain: string;
+      status: string;
+      instructions: {
+        type: string;
+        name: string;
+        value: string;
+        ttl: number;
+      };
+      verifyEndpoint: string;
+      message: string;
+    }>
+  >;
+  verifyCustomDomain(workspaceId: string): Promise<
+    CloudApiResult<{
+      success: boolean;
+      status: string;
+      domain?: string;
+      message?: string;
+      error?: string;
+    }>
+  >;
+  removeCustomDomain(workspaceId: string): Promise<CloudApiResult<{ success: boolean; message: string }>>;
+  getWorkspaceDetails(id: string): Promise<
+    CloudApiResult<{
+      id: string;
+      name: string;
+      status: string;
+      publicUrl?: string;
+      computeProvider: string;
+      config: {
+        providers: string[];
+        repositories: string[];
+        supervisorEnabled?: boolean;
+        maxAgents?: number;
+      };
+      customDomain?: string;
+      customDomainStatus?: string;
+      errorMessage?: string;
+      repositories: Array<{
+        id: string;
+        fullName: string;
+        syncStatus: string;
+        lastSyncedAt?: string;
+      }>;
+      createdAt: string;
+      updatedAt: string;
+    }>
+  >;
+  getRepos(): Promise<
+    CloudApiResult<{
+      repositories: Array<{
+        id: string;
+        fullName: string;
+        isPrivate: boolean;
+        defaultBranch: string;
+        syncStatus: string;
+        hasNangoConnection: boolean;
+        lastSyncedAt?: string;
+      }>;
+    }>
+  >;
+  syncRepo(repoId: string): Promise<
+    CloudApiResult<{
+      message: string;
+      syncStatus: string;
+      result?: unknown;
+    }>
+  >;
+  spawnAgent(
+    workspaceId: string,
+    params: {
+      name: string;
+      provider?: string;
+      task?: string;
+      cwd?: string;
+      model?: string;
+    }
+  ): Promise<
+    CloudApiResult<{
+      name: string;
+      sandboxId: string;
+      status: string;
+      cli: string;
+      workspaceId: string;
+      createdAt: string;
+    }>
+  >;
+  getAgents(workspaceId: string): Promise<
+    CloudApiResult<{
+      agents: Array<{
+        name: string;
+        sandboxId: string;
+        status: string;
+        cli: string;
+        workspaceId: string;
+        createdAt: string;
+      }>;
+      workspaceId: string;
+    }>
+  >;
+  stopAgent(workspaceId: string, agentName: string): Promise<CloudApiResult<{ success: boolean }>>;
+  getOnboardingNextStep(): Promise<unknown>;
+}
+
+export interface CloudAuthAdapter {
+  checkSession(): Promise<SessionStatus>;
+  getUser(): Promise<CloudApiResult<CloudUser>>;
+  logout(): Promise<{ success: boolean; error?: string }>;
+  redirectToLogin(): void;
+  onSessionExpired(callback: SessionExpiredCallback): () => void;
+}

package/src/app/app/[[...slug]]/DashboardPageClient.tsx

@@ -2,18 +2,18 @@
  * Dashboard V2 - Main App Page (Client Component)
  *
  * In cloud mode: Shows workspace selection and connects to selected workspace's dashboard.
- * In local mode: Connects to local daemon WebSocket.
+ * In local mode: Connects to local broker WebSocket.
  */
 
 'use client';
 
-import React, { useState, useEffect, useCallback } from 'react';
+import React, { useState, useEffect, useCallback, useMemo } from 'react';
 import { App } from '../../../components/App';
-import { CloudSessionProvider } from '../../../components/CloudSessionProvider';
 import { LogoIcon } from '../../../components/Logo';
 import { setActiveWorkspaceId } from '../../../lib/api';
 import { ProvisioningProgress } from '../../../components/ProvisioningProgress';
 import { ProviderConnectionList, type ProviderInfo } from '../../../components/ProviderConnectionList';
+import { DashboardConfigProvider, createCloudApiAdapter, createCloudAuthAdapter, setCloudCsrfToken } from '../../../adapters';
 
 interface Workspace {
   id: string;
@@ -56,6 +56,16 @@ const AI_PROVIDERS: ProviderInfo[] = [
 // Force cloud mode via env var - prevents silent fallback to local mode
 const FORCE_CLOUD_MODE = process.env.NEXT_PUBLIC_FORCE_CLOUD_MODE === 'true';
 
+// Detect cloud mode from server-injected config (relay-cloud injects this in app.html)
+function detectCloudConfig(): { isCloud: boolean; features?: Record<string, boolean> } {
+  if (typeof window !== 'undefined') {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const config = (window as any).__RELAY_CLOUD_CONFIG__;
+    if (config) return config as { isCloud: boolean; features?: Record<string, boolean> };
+  }
+  return { isCloud: false };
+}
+
 export default function DashboardPageClient() {
   const [state, setState] = useState<PageState>('loading');
   const [workspaces, setWorkspaces] = useState<Workspace[]>([]);
@@ -63,8 +73,7 @@ export default function DashboardPageClient() {
   const [selectedWorkspace, setSelectedWorkspace] = useState<Workspace | null>(null);
   const [wsUrl, setWsUrl] = useState<string | undefined>(undefined);
   const [error, setError] = useState<string | null>(null);
-  // Track cloud mode for potential future use
-  const [_isCloudMode, setIsCloudMode] = useState(FORCE_CLOUD_MODE);
+  const [isCloudMode, setIsCloudMode] = useState(() => FORCE_CLOUD_MODE || detectCloudConfig().isCloud);
   const [csrfToken, setCsrfToken] = useState<string | null>(null);
   const [provisioningInfo, setProvisioningInfo] = useState<ProvisioningInfo | null>(null);
   const [connectedProviders, setConnectedProviders] = useState<string[]>([]);
@@ -81,6 +90,16 @@ export default function DashboardPageClient() {
           if (FORCE_CLOUD_MODE) {
             throw new Error('Cloud mode enforced but session endpoint returned 404. Is the cloud server running?');
           }
+          // Always sync username from the health endpoint so it reflects the current project
+          try {
+            const healthRes = await fetch('/api/health');
+            if (healthRes.ok) {
+              const health = await healthRes.json();
+              if (health.projectName) {
+                localStorage.setItem('relay_username', health.projectName);
+              }
+            }
+          } catch { /* ignore */ }
           setIsCloudMode(false);
           setState('local');
           return;
@@ -90,6 +109,7 @@ export default function DashboardPageClient() {
         const token = sessionRes.headers.get('X-CSRF-Token');
         if (token) {
           setCsrfToken(token);
+          setCloudCsrfToken(token);
         }
 
         const session = await sessionRes.json();
@@ -162,9 +182,12 @@ export default function DashboardPageClient() {
 
         // Check for previously connected workspace (stored in localStorage)
         // This enables seamless reconnection on page reload
-        const savedWorkspaceId = typeof window !== 'undefined'
+        const rawSavedId = typeof window !== 'undefined'
           ? localStorage.getItem('agentrelay_workspace_id')
           : null;
+        // Reject placeholder values like "default" that aren't real UUIDs
+        const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+        const savedWorkspaceId = rawSavedId && UUID_RE.test(rawSavedId) ? rawSavedId : null;
 
         if (savedWorkspaceId) {
           const savedWorkspace = runningWorkspaces.find((w: Workspace) => w.id === savedWorkspaceId);
@@ -180,12 +203,11 @@ export default function DashboardPageClient() {
           connectToWorkspace(runningWorkspaces[0]);
         } else if (runningWorkspaces.length > 1) {
           setState('select-workspace');
-        } else if ((workspacesData.workspaces || []).length > 0) {
-          // Has workspaces but none running
-          setState('select-workspace');
         } else if ((reposData.repositories || []).length > 0) {
-          // Has repos but no workspaces - show create workspace
-          setState('no-workspaces');
+          // No running workspaces but has repos — onboarding handles
+          // both "no workspace" and "workspace exists but not running" cases
+          window.location.href = '/app/onboarding';
+          return;
         } else {
           // No repos, no workspaces - redirect to connect repos
           window.location.href = '/connect-repos';
@@ -393,6 +415,38 @@ export default function DashboardPageClient() {
     }
   }, [connectToWorkspace, csrfToken]);
 
+  // Create cloud config for wrapping App when in cloud mode.
+  // Memoized to avoid recreating adapters on every render.
+  // IMPORTANT: All hooks must be called before any early returns (React rules of hooks).
+  const cloudConfig = useMemo(() => {
+    if (!isCloudMode) return null;
+    const serverConfig = detectCloudConfig();
+    return {
+      features: {
+        workspaces: true,
+        auth: true,
+        billing: serverConfig.features?.billing ?? true,
+        teams: serverConfig.features?.teams ?? true,
+      },
+      api: createCloudApiAdapter(),
+      auth: createCloudAuthAdapter(),
+      isCloudMode: true,
+    };
+  }, [isCloudMode]);
+
+  // Helper: wraps App with cloud config provider when in cloud mode
+  const renderApp = (props?: { wsUrl?: string }) => {
+    const app = <App wsUrl={props?.wsUrl} enableReactions />;
+    if (cloudConfig) {
+      return (
+        <DashboardConfigProvider config={cloudConfig}>
+          {app}
+        </DashboardConfigProvider>
+      );
+    }
+    return app;
+  };
+
   // Loading state
   if (state === 'loading') {
     return (
@@ -410,17 +464,12 @@ export default function DashboardPageClient() {
 
   // Local mode - just render the App component
   if (state === 'local') {
-    return <App />;
+    return renderApp();
   }
 
   // Connected to workspace - render App with workspace's WebSocket
-  // Wrap in CloudSessionProvider so App has access to cloud session context
   if (state === 'connected' && wsUrl) {
-    return (
-      <CloudSessionProvider cloudMode={true}>
-        <App wsUrl={wsUrl} />
-      </CloudSessionProvider>
-    );
+    return renderApp({ wsUrl });
   }
 
   // Connecting state