openship 0.1.0 → 0.1.1

package/apps/dashboard/src/context/deployment/useDeploymentConfig.ts

@@ -0,0 +1,176 @@
+"use client";
+
+import { useState, useCallback, useEffect, useRef } from "react";
+import type { FrameworkId } from "@/components/import-project/types";
+import { deployApi } from "@/lib/api";
+import { settingsApi } from "@/lib/api/settings";
+import type { BuildMode } from "@/lib/api/settings";
+import { STACKS, type StackDefinition } from "@repo/core";
+import type { BuildStrategy, DeploymentConfig } from "./types";
+import { DEFAULT_CONFIG } from "./types";
+
+/**
+ * Owns the deployment configuration state and prepare logic.
+ *
+ * Prepare = resolve project info from a source (GitHub repo or local path),
+ * detect stack, and populate config with defaults.
+ *
+ * The user's global build mode preference (from settings) is fetched once
+ * and used as the initial default for buildStrategy — but the per-deploy
+ * value in config is the sole source of truth sent to the API.
+ */
+export function useDeploymentConfig() {
+  const [config, setConfig] = useState<DeploymentConfig>(DEFAULT_CONFIG);
+  const userBuildPref = useRef<BuildMode>("auto");
+
+  // Fetch user's global build mode preference once
+  useEffect(() => {
+    settingsApi.get().then((res) => {
+      if (res?.buildMode) userBuildPref.current = res.buildMode;
+    }).catch(() => { /* non-critical — fall back to stack default */ });
+  }, []);
+
+  const updateConfig = useCallback((updates: Partial<DeploymentConfig>) => {
+    setConfig((prev) => ({ ...prev, ...updates }));
+  }, []);
+
+  const updateOptions = useCallback((updates: Partial<DeploymentConfig["options"]>) => {
+    setConfig((prev) => ({ ...prev, options: { ...prev.options, ...updates } }));
+  }, []);
+
+  /** Resolve initial buildStrategy: user global pref > stack default > "server" */
+  const resolveInitialStrategy = useCallback((stackDef: StackDefinition | undefined): BuildStrategy => {
+    const pref = userBuildPref.current;
+    if (pref === "server" || pref === "local") return pref;
+    return stackDef?.defaultBuildStrategy ?? "server";
+  }, []);
+
+  // ── Prepare from GitHub repo ───────────────────────────────────────────────
+
+  const initializeFromRepo = useCallback(
+    async (
+      owner: string,
+      repo: string,
+      force?: string,
+    ): Promise<{ success: boolean; error?: string; errorType?: string; buildInProgress?: boolean }> => {
+      try {
+        const response = await deployApi.prepare({ owner, repo, force });
+
+        if (response?.error) {
+          return { success: false, error: response.error, errorType: "api_error" };
+        }
+
+        if (response?.current_status === "running" || response?.exists) {
+          return { success: false, buildInProgress: true };
+        }
+
+        const repoName = response.repository.name || repo;
+        const detectedStack = (response.stack || "nextjs") as FrameworkId;
+        const stackDef = STACKS[detectedStack as keyof typeof STACKS] as StackDefinition | undefined;
+        const hasServer = !!response.startCommand;
+        const hasBuild = !!response.buildCommand;
+
+        setConfig((prev) => ({
+          ...prev,
+          repo: repoName,
+          owner: response.repository.owner?.login || owner,
+          projectName: repoName,
+          projectType: response.projectType || "app",
+          domain: repoName.toLowerCase(),
+          framework: detectedStack,
+          detectedFramework: detectedStack,
+          buildStrategy: resolveInitialStrategy(stackDef),
+          packageManager: response.packageManager || "npm",
+          buildImage: response.buildImage || "node:22",
+          branch: response.repository.default_branch || "main",
+          branches: response.repository.branches?.map((b: any) => b.name) || [],
+          services: response.services || [],
+          options: {
+            buildCommand: response.buildCommand || "",
+            installCommand: response.installCommand || "",
+            outputDirectory: response.outputDirectory || "",
+            productionPaths: Array.isArray(response.productionPaths)
+              ? response.productionPaths.join(", ")
+              : response.productionPaths || "",
+            startCommand: response.startCommand || "",
+            productionPort: String(response.port || 3000),
+            rootDirectory: "./",
+            hasServer,
+            hasBuild,
+          },
+        }));
+
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to fetch repository data";
+        return { success: false, error: errorMessage, errorType: "network_error" };
+      }
+    },
+    [],
+  );
+
+  // ── Prepare from local path ────────────────────────────────────────────────
+
+  const initializeFromLocal = useCallback(
+    async (path: string): Promise<{ success: boolean; error?: string; errorType?: string }> => {
+      try {
+        const response = await deployApi.prepare({ source: "local", path });
+
+        if (response?.error) {
+          return { success: false, error: response.error, errorType: "api_error" };
+        }
+
+        const name = response.repository.name || path.split("/").pop() || "project";
+        const detectedStack = (response.stack || "nextjs") as FrameworkId;
+        const stackDef = STACKS[detectedStack as keyof typeof STACKS] as StackDefinition | undefined;
+        const hasServer = !!response.startCommand;
+        const hasBuild = !!response.buildCommand;
+
+        setConfig((prev) => ({
+          ...prev,
+          repo: name,
+          owner: "local",
+          projectName: name,
+          projectType: response.projectType || "app",
+          domain: name.toLowerCase().replace(/[^a-z0-9-]/g, ""),
+          framework: detectedStack,
+          detectedFramework: detectedStack,
+          buildStrategy: resolveInitialStrategy(stackDef),
+          packageManager: response.packageManager || "npm",
+          buildImage: response.buildImage || "node:22",
+          branch: "main",
+          branches: [],
+          services: response.services || [],
+          options: {
+            buildCommand: response.buildCommand || "",
+            installCommand: response.installCommand || "",
+            outputDirectory: response.outputDirectory || "",
+            productionPaths: Array.isArray(response.productionPaths)
+              ? response.productionPaths.join(", ")
+              : response.productionPaths || "",
+            startCommand: response.startCommand || "",
+            productionPort: String(response.port || 3000),
+            rootDirectory: path,
+            hasServer,
+            hasBuild,
+          },
+        }));
+
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to scan local project";
+        return { success: false, error: errorMessage, errorType: "network_error" };
+      }
+    },
+    [],
+  );
+
+  return {
+    config,
+    setConfig,
+    updateConfig,
+    updateOptions,
+    initializeFromRepo,
+    initializeFromLocal,
+  };
+}

package/apps/dashboard/src/hooks/useBuildConnection.ts

@@ -0,0 +1,334 @@
+import { useCallback, useRef, useState } from 'react';
+import { connectToBuildStream, reconnectToBuildStream, NoRetryError } from '@/lib/sseClient';
+import { useToast } from '@/context/ToastContext';
+
+interface UseBuildConnectionOptions {
+  onMessage: (chunk: string) => void;
+  onConnect?: () => void;
+  onDisconnect?: () => void;
+  onError?: (error: Error) => void;
+  onSuccess?: () => void;
+  onFailure?: () => void;
+}
+
+interface BuildConnectionState {
+  isConnecting: boolean;
+  isReconnecting: boolean;
+  reconnectAttempts: number;
+}
+
+const MAX_RECONNECT_ATTEMPTS = 5;
+
+export const useBuildConnection = (options: UseBuildConnectionOptions) => {
+  const { showToast } = useToast();
+  const [state, setState] = useState<BuildConnectionState>({
+    isConnecting: false,
+    isReconnecting: false,
+    reconnectAttempts: 0,
+  });
+
+  const buildTokenRef = useRef<string | null>(null);
+  const buildOptionsRef = useRef<any>(null);
+  const lastEventIdRef = useRef<number | undefined>(undefined);
+  const isActiveRef = useRef<boolean>(false);
+  const reconnectAttemptsRef = useRef<number>(0);
+
+  /**
+   * Connect to a new build or attach to existing one
+   */
+  const connect = useCallback(async (
+    buildToken: string,
+    buildOptions?: any,
+    lastEventId?: number
+  ) => {
+    buildTokenRef.current = buildToken;
+    buildOptionsRef.current = buildOptions;
+    lastEventIdRef.current = lastEventId;
+    isActiveRef.current = true;
+
+    setState(prev => ({ ...prev, isConnecting: true, reconnectAttempts: 0 }));
+    reconnectAttemptsRef.current = 0;
+
+    try {
+      console.log('[BuildConnection] Connecting to build stream...');
+      
+      // If we have buildOptions, it's a new build, otherwise attach to existing
+      if (buildOptions) {
+        await connectToBuildStream(buildToken, {
+          onMessage: options.onMessage,
+          onConnect: () => {
+            console.log('[BuildConnection] Connected to new build');
+            setState(prev => ({ ...prev, isConnecting: false }));
+            options.onConnect?.();
+          },
+          onDisconnect: () => {
+            console.log('[BuildConnection] Build stream disconnected');
+            options.onDisconnect?.();
+            // Auto-reconnect if still active and haven't exceeded attempts
+            if (isActiveRef.current && reconnectAttemptsRef.current < MAX_RECONNECT_ATTEMPTS) {
+              reconnect();
+            }
+          },
+          onError: (error) => {
+            console.error('[BuildConnection] Build stream error:', error);
+            
+            // Check if this is a NoRetryError - if so, stop immediately
+            if (error instanceof NoRetryError || error.name === 'NoRetryError') {
+              console.log('[BuildConnection] Terminal error - stopping:', error.message);
+              isActiveRef.current = false;
+              setState(prev => ({ ...prev, isConnecting: false }));
+              showToast(error.message, 'error', 'Build Failed');
+              options.onError?.(error);
+              return;
+            }
+            
+            // If token already in use, switch to attach mode
+            if (error.message?.includes('Token already in use')) {
+              console.log('[BuildConnection] Token in use, switching to attach mode');
+              showToast('Build already in progress, attaching...', 'success', 'Reconnecting');
+              setTimeout(() => reconnect(), 1000);
+            } else {
+              options.onError?.(error);
+              if (isActiveRef.current && reconnectAttemptsRef.current < MAX_RECONNECT_ATTEMPTS) {
+                setTimeout(() => reconnect(), 2000);
+              }
+            }
+          },
+        });
+      } else {
+        // Attach to existing build
+        await reconnectToBuildStream(buildToken, lastEventId, {
+          onMessage: options.onMessage,
+          onConnect: () => {
+            console.log('[BuildConnection] Attached to existing build');
+            setState(prev => ({ ...prev, isConnecting: false, reconnectAttempts: 0 }));
+            reconnectAttemptsRef.current = 0;
+            options.onConnect?.();
+          },
+          onDisconnect: () => {
+            console.log('[BuildConnection] Attached stream disconnected');
+            options.onDisconnect?.();
+            // Auto-reconnect if still active and haven't exceeded attempts
+            if (isActiveRef.current && reconnectAttemptsRef.current < MAX_RECONNECT_ATTEMPTS) {
+              reconnect();
+            }
+          },
+          onError: (error) => {
+            console.error('[BuildConnection] Attach error:', error);
+            
+            // Check if this is a NoRetryError - if so, stop immediately
+            if (error instanceof NoRetryError || error.name === 'NoRetryError') {
+              console.log('[BuildConnection] Terminal error during attach - stopping:', error.message);
+              isActiveRef.current = false;
+              setState(prev => ({ ...prev, isConnecting: false }));
+              showToast(error.message, 'error', 'Build Failed');
+              options.onError?.(error);
+              return;
+            }
+            
+            options.onError?.(error);
+            if (isActiveRef.current && reconnectAttemptsRef.current < MAX_RECONNECT_ATTEMPTS) {
+              setTimeout(() => reconnect(), 2000);
+            }
+          },
+        });
+      }
+    } catch (err: any) {
+      console.error('[BuildConnection] Failed to connect:', err);
+      setState(prev => ({ ...prev, isConnecting: false }));
+      
+      // Check if this is a NoRetryError - if so, stop immediately
+      if (err instanceof NoRetryError || err.name === 'NoRetryError') {
+        console.log('[BuildConnection] Terminal error during connect - stopping:', err.message);
+        isActiveRef.current = false;
+        showToast(err.message, 'error', 'Build Failed');
+        options.onError?.(err);
+        return;
+      }
+      
+      // If token already in use, switch to attach mode
+      if (err.message?.includes('Token already in use')) {
+        console.log('[BuildConnection] Token in use, switching to attach mode');
+        showToast('Build already in progress, attaching...', 'success', 'Reconnecting');
+        if (reconnectAttemptsRef.current < MAX_RECONNECT_ATTEMPTS) {
+          setTimeout(() => reconnect(), 1000);
+        }
+      } else {
+        options.onError?.(err);
+      }
+    }
+  }, [options, showToast]);
+
+  /**
+   * Reconnect to existing build session
+   */
+  const reconnect = useCallback(async () => {
+    if (!buildTokenRef.current || !isActiveRef.current) {
+      console.log('[BuildConnection] Reconnection skipped - no token or inactive');
+      return;
+    }
+
+    // Get current attempts before updating
+    const currentAttempts = reconnectAttemptsRef.current;
+    const newAttempts = currentAttempts + 1;
+    
+    if (newAttempts > MAX_RECONNECT_ATTEMPTS) {
+      console.error('[BuildConnection] Max reconnection attempts reached');
+      showToast('Unable to reconnect after multiple attempts', 'error', 'Connection Error');
+      isActiveRef.current = false;
+      options.onError?.(new Error('Max reconnection attempts reached'));
+      setState(prev => ({ ...prev, isReconnecting: false }));
+      return;
+    }
+
+    // Update both ref and state
+    reconnectAttemptsRef.current = newAttempts;
+    setState(prev => {
+      console.log(`[BuildConnection] Reconnecting... (Attempt ${newAttempts}/${MAX_RECONNECT_ATTEMPTS})`);
+      showToast(
+        `Reconnecting... (Attempt ${newAttempts}/${MAX_RECONNECT_ATTEMPTS})`,
+        'success',
+        'Reconnecting'
+      );
+
+      return { ...prev, isReconnecting: true, reconnectAttempts: newAttempts };
+    });
+
+    // Exponential backoff using current attempts
+    const delay = Math.min(Math.pow(2, currentAttempts) * 1000, 10000);
+    await new Promise(resolve => setTimeout(resolve, delay));
+
+    // Check if still active after delay
+    if (!isActiveRef.current) {
+      console.log('[BuildConnection] Connection became inactive during delay');
+      setState(prev => ({ ...prev, isReconnecting: false }));
+      return;
+    }
+
+    try {
+      await reconnectToBuildStream(
+        buildTokenRef.current,
+        lastEventIdRef.current,
+        {
+          onMessage: options.onMessage,
+          onConnect: () => {
+            console.log('[BuildConnection] Reconnected successfully');
+            reconnectAttemptsRef.current = 0;
+            setState(prev => ({ ...prev, isReconnecting: false, reconnectAttempts: 0 }));
+            showToast('Reconnected successfully', 'success', 'Connected');
+            options.onConnect?.();
+          },
+          onDisconnect: () => {
+            console.log('[BuildConnection] Reconnected stream disconnected');
+            setState(prev => ({ ...prev, isReconnecting: false }));
+            options.onDisconnect?.();
+            // Only try again if still active and haven't exceeded attempts
+            if (isActiveRef.current && reconnectAttemptsRef.current < MAX_RECONNECT_ATTEMPTS) {
+              setTimeout(() => reconnect(), 1000);
+            } else if (reconnectAttemptsRef.current >= MAX_RECONNECT_ATTEMPTS) {
+              console.error('[BuildConnection] Max reconnection attempts reached after disconnect');
+              isActiveRef.current = false;
+              showToast('Unable to reconnect after multiple attempts', 'error', 'Connection Error');
+            }
+          },
+          onError: (error) => {
+            console.error('[BuildConnection] Reconnection error:', error);
+            setState(prev => ({ ...prev, isReconnecting: false }));
+            
+            // Check if this is a NoRetryError - if so, stop immediately
+            if (error instanceof NoRetryError || error.name === 'NoRetryError') {
+              console.log('[BuildConnection] Terminal error - stopping reconnection:', error.message);
+              isActiveRef.current = false;
+              showToast(error.message, 'error', 'Connection Stopped');
+              options.onError?.(error);
+              return;
+            }
+            
+            options.onError?.(error);
+            // Only try again if still active and haven't exceeded attempts
+            if (isActiveRef.current && reconnectAttemptsRef.current < MAX_RECONNECT_ATTEMPTS) {
+              setTimeout(() => reconnect(), 2000);
+            } else if (reconnectAttemptsRef.current >= MAX_RECONNECT_ATTEMPTS) {
+              console.error('[BuildConnection] Max reconnection attempts reached after error');
+              isActiveRef.current = false;
+              showToast('Unable to reconnect after multiple attempts', 'error', 'Connection Error');
+            }
+          },
+        }
+      );
+    } catch (err: any) {
+      console.error('[BuildConnection] Reconnection failed:', err);
+      setState(prev => ({ ...prev, isReconnecting: false }));
+      
+      // Check if this is a NoRetryError - if so, stop immediately
+      if (err instanceof NoRetryError || err.name === 'NoRetryError') {
+        console.log('[BuildConnection] Terminal error - stopping reconnection:', err.message);
+        isActiveRef.current = false;
+        showToast(err.message, 'error', 'Connection Stopped');
+        options.onError?.(err);
+        return;
+      }
+      
+      // Check if session no longer exists
+      if (err.message?.includes('not found') || err.message?.includes('Invalid token')) {
+        console.log('[BuildConnection] Session no longer exists');
+        isActiveRef.current = false;
+        showToast('Build session no longer exists', 'error', 'Connection Error');
+        options.onError?.(err);
+        return;
+      }
+      
+      // Only retry if still active and haven't exceeded attempts
+      if (isActiveRef.current && reconnectAttemptsRef.current < MAX_RECONNECT_ATTEMPTS) {
+        setTimeout(() => reconnect(), 2000);
+      } else if (reconnectAttemptsRef.current >= MAX_RECONNECT_ATTEMPTS) {
+        console.error('[BuildConnection] Max reconnection attempts reached');
+        isActiveRef.current = false;
+        showToast('Unable to reconnect after multiple attempts', 'error', 'Connection Error');
+      }
+    }
+  }, [options, showToast]);
+
+  /**
+   * Update last event ID (for reconnection)
+   */
+  const updateLastEventId = useCallback((eventId: number) => {
+    lastEventIdRef.current = eventId;
+  }, []);
+
+  /**
+   * Update build options (to keep in sync with context config)
+   */
+  const updateBuildOptions = useCallback((buildOptions: any) => {
+    buildOptionsRef.current = buildOptions;
+  }, []);
+
+  /**
+   * Disconnect from build
+   */
+  const disconnect = useCallback(() => {
+    console.log('[BuildConnection] Disconnecting...');
+    isActiveRef.current = false;
+    buildTokenRef.current = null;
+    buildOptionsRef.current = null;
+    lastEventIdRef.current = undefined;
+    reconnectAttemptsRef.current = 0;
+    setState({
+      isConnecting: false,
+      isReconnecting: false,
+      reconnectAttempts: 0,
+    });
+  }, []);
+
+  return {
+    connect,
+    reconnect,
+    disconnect,
+    updateLastEventId,
+    updateBuildOptions,
+    isConnecting: state.isConnecting,
+    isReconnecting: state.isReconnecting,
+    reconnectAttempts: state.reconnectAttempts,
+  };
+};
+

package/apps/dashboard/src/hooks/useMonitorStream.ts

@@ -0,0 +1,146 @@
+/**
+ * Hook for streaming live server stats via SSE.
+ *
+ * Connects to GET /system/monitor/stream and receives real-time
+ * CPU, memory, disk, uptime, and load average updates every ~3s.
+ */
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import { getApiBaseUrl } from "@/lib/api";
+import { endpoints } from "@/lib/api/endpoints";
+import type { ServerStats } from "@/lib/api/system";
+
+export interface UseMonitorStreamReturn {
+  /** Current stats (null until first data received) */
+  stats: ServerStats | null;
+  /** Connection state */
+  isConnected: boolean;
+  /** Error (if any) */
+  error: string | null;
+  /** Manually reconnect */
+  reconnect: () => void;
+  /** Disconnect */
+  disconnect: () => void;
+}
+
+export function useMonitorStream(
+  /** Set to false to disable streaming (e.g. when tab is not visible) */
+  enabled = true,
+): UseMonitorStreamReturn {
+  const [stats, setStats] = useState<ServerStats | null>(null);
+  const [isConnected, setIsConnected] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const abortRef = useRef<AbortController | null>(null);
+  const bufferRef = useRef("");
+  const enabledRef = useRef(enabled);
+  enabledRef.current = enabled;
+
+  const disconnect = useCallback(() => {
+    if (abortRef.current) {
+      abortRef.current.abort();
+      abortRef.current = null;
+    }
+    setIsConnected(false);
+  }, []);
+
+  const connect = useCallback(async () => {
+    disconnect();
+
+    const abort = new AbortController();
+    abortRef.current = abort;
+    bufferRef.current = "";
+
+    const baseUrl = getApiBaseUrl();
+    const url = `${baseUrl}${endpoints.system.monitorStream}`;
+
+    try {
+      const res = await fetch(url, {
+        method: "GET",
+        credentials: "include",
+        headers: { Accept: "text/event-stream" },
+        signal: abort.signal,
+      });
+
+      if (!res.ok || !res.body) {
+        setError(`Connection failed (${res.status})`);
+        return;
+      }
+
+      setIsConnected(true);
+      setError(null);
+
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+
+      // eslint-disable-next-line no-constant-condition
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        const chunk = decoder.decode(value, { stream: true });
+        const buffer = bufferRef.current + chunk;
+        const parts = buffer.split("\n\n");
+        bufferRef.current = parts.pop() || "";
+
+        for (const part of parts) {
+          if (!part.trim()) continue;
+
+          let eventType = "";
+          let dataStr = "";
+
+          for (const line of part.split("\n")) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith("event:")) {
+              eventType = trimmed.substring(6).trim();
+            } else if (trimmed.startsWith("data:")) {
+              dataStr = trimmed.substring(5).trim();
+            }
+          }
+
+          if (!dataStr) continue;
+
+          try {
+            if (eventType === "stats") {
+              const parsed = JSON.parse(dataStr) as ServerStats;
+              setStats(parsed);
+              setError(null);
+            } else if (eventType === "error") {
+              const parsed = JSON.parse(dataStr);
+              setError(parsed.error || "Unknown error");
+            }
+          } catch {
+            // Skip malformed events
+          }
+        }
+      }
+    } catch (err) {
+      if (abort.signal.aborted) return;
+      const msg = err instanceof Error ? err.message : String(err);
+      setError(msg);
+    } finally {
+      if (!abort.signal.aborted) {
+        setIsConnected(false);
+      }
+    }
+  }, [disconnect]);
+
+  const reconnect = useCallback(() => {
+    if (enabledRef.current) void connect();
+  }, [connect]);
+
+  useEffect(() => {
+    if (!enabled) {
+      disconnect();
+      return;
+    }
+
+    // Small delay avoids double-connect from React StrictMode remount
+    const id = setTimeout(() => void connect(), 50);
+    return () => {
+      clearTimeout(id);
+      disconnect();
+    };
+  }, [enabled]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  return { stats, isConnected, error, reconnect, disconnect };
+}