openship 0.1.1 → 0.1.7

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

@@ -1,176 +0,0 @@
-"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

@@ -1,334 +0,0 @@
-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

@@ -1,146 +0,0 @@
-/**
- * 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 };
-}