@shepai/cli 1.65.1 → 1.66.1

package/dist/src/presentation/web/hooks/use-deploy-action.js

@@ -0,0 +1,130 @@
+'use client';
+import { useState, useCallback, useRef, useEffect } from 'react';
+import { deployFeature } from '../app/actions/deploy-feature.js';
+import { deployRepository } from '../app/actions/deploy-repository.js';
+import { stopDeployment } from '../app/actions/stop-deployment.js';
+import { getDeploymentStatus } from '../app/actions/get-deployment-status.js';
+const ERROR_CLEAR_DELAY = 5000;
+const POLL_INTERVAL = 3000;
+export function useDeployAction(input) {
+    const [deployLoading, setDeployLoading] = useState(false);
+    const [stopLoading, setStopLoading] = useState(false);
+    const [deployError, setDeployError] = useState(null);
+    const [status, setStatus] = useState(null);
+    const [url, setUrl] = useState(null);
+    const errorTimerRef = useRef(null);
+    const pollIntervalRef = useRef(null);
+    const mountedRef = useRef(true);
+    // Track mounted state
+    useEffect(() => {
+        mountedRef.current = true;
+        return () => {
+            mountedRef.current = false;
+        };
+    }, []);
+    // Cleanup on unmount
+    useEffect(() => {
+        return () => {
+            if (errorTimerRef.current)
+                clearTimeout(errorTimerRef.current);
+            if (pollIntervalRef.current)
+                clearInterval(pollIntervalRef.current);
+        };
+    }, []);
+    const stopPolling = useCallback(() => {
+        if (pollIntervalRef.current) {
+            clearInterval(pollIntervalRef.current);
+            pollIntervalRef.current = null;
+        }
+    }, []);
+    const startPolling = useCallback((targetId) => {
+        stopPolling();
+        pollIntervalRef.current = setInterval(async () => {
+            if (!mountedRef.current) {
+                stopPolling();
+                return;
+            }
+            const result = await getDeploymentStatus(targetId);
+            if (!mountedRef.current)
+                return;
+            if (!result || result.state === 'Stopped') {
+                setStatus(null);
+                setUrl(null);
+                stopPolling();
+            }
+            else {
+                setStatus(result.state);
+                setUrl(result.url);
+            }
+        }, POLL_INTERVAL);
+    }, [stopPolling]);
+    const handleDeploy = useCallback(async () => {
+        if (!input || deployLoading)
+            return;
+        if (errorTimerRef.current)
+            clearTimeout(errorTimerRef.current);
+        setDeployLoading(true);
+        setDeployError(null);
+        try {
+            const result = input.targetType === 'feature'
+                ? await deployFeature(input.targetId)
+                : await deployRepository(input.repositoryPath);
+            if (!mountedRef.current)
+                return;
+            if (!result.success) {
+                const errorMessage = result.error ?? 'An unexpected error occurred';
+                setDeployError(errorMessage);
+                errorTimerRef.current = setTimeout(() => setDeployError(null), ERROR_CLEAR_DELAY);
+            }
+            else {
+                setStatus(result.state ?? null);
+                setUrl(null);
+                startPolling(input.targetId);
+            }
+        }
+        catch (err) {
+            if (!mountedRef.current)
+                return;
+            const errorMessage = err instanceof Error ? err.message : 'An unexpected error occurred';
+            setDeployError(errorMessage);
+            errorTimerRef.current = setTimeout(() => setDeployError(null), ERROR_CLEAR_DELAY);
+        }
+        finally {
+            if (mountedRef.current) {
+                setDeployLoading(false);
+            }
+        }
+    }, [input, deployLoading, startPolling]);
+    const handleStop = useCallback(async () => {
+        if (!input || stopLoading)
+            return;
+        setStopLoading(true);
+        try {
+            const result = await stopDeployment(input.targetId);
+            if (!mountedRef.current)
+                return;
+            if (result.success) {
+                stopPolling();
+                setStatus(null);
+                setUrl(null);
+            }
+        }
+        catch {
+            // Stop errors are non-critical; process may have already exited
+        }
+        finally {
+            if (mountedRef.current) {
+                setStopLoading(false);
+            }
+        }
+    }, [input, stopLoading, stopPolling]);
+    return {
+        deploy: handleDeploy,
+        stop: handleStop,
+        deployLoading,
+        stopLoading,
+        deployError,
+        status,
+        url,
+    };
+}

package/dist/src/presentation/web/lib/feature-flags.d.ts

@@ -6,5 +6,6 @@
  */
 export declare const featureFlags: {
     readonly skills: boolean;
+    readonly envDeploy: boolean;
 };
 //# sourceMappingURL=feature-flags.d.ts.map

package/dist/src/presentation/web/lib/feature-flags.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feature-flags.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/web/lib/feature-flags.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,eAAO,MAAM,YAAY;;CAEf,CAAC"}
+{"version":3,"file":"feature-flags.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/web/lib/feature-flags.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,eAAO,MAAM,YAAY;;;CAGf,CAAC"}

package/dist/src/presentation/web/lib/feature-flags.js

@@ -9,4 +9,5 @@ function isEnabled(envVar) {
 }
 export const featureFlags = {
     skills: isEnabled(process.env.NEXT_PUBLIC_FLAG_SKILLS),
+    envDeploy: isEnabled(process.env.NEXT_PUBLIC_FLAG_ENV_DEPLOY),
 };