@shepai/cli 1.179.0 → 1.179.1

package/dist/src/presentation/web/hooks/deployment-status-provider.js

@@ -0,0 +1,205 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * DeploymentStatusProvider
+ *
+ * Wraps the dashboard with a shared deployment-status store seeded from
+ * SSR data (ListDeploymentsUseCase via get-graph-data). All components
+ * that call `useDeployAction(targetId)` subscribe to the same store, so
+ * the "click Run on node → tab shows URL instantly" bug and the
+ * "URL lost after refresh" bug are both resolved by construction.
+ *
+ * All business logic lives in use cases on the backend. This provider
+ * owns only UI state transitions: which entries are hydrated, which are
+ * loading, which have errors, and which need polling.
+ */
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, } 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';
+import { createLogger } from '../lib/logger.js';
+import { DeploymentStatusStore, EMPTY_ENTRY, } from './deployment-status-store.js';
+const log = createLogger('[DeploymentStatusProvider]');
+const POLL_INTERVAL_MS = 3000;
+const ACTIVE_STATES = new Set([
+    'Booting',
+    'Ready',
+]);
+const DeploymentStatusContext = createContext(null);
+export function DeploymentStatusProvider({ initialDeployments, children, }) {
+    // One store per provider instance. Stable across renders.
+    const storeRef = useRef(null);
+    if (!storeRef.current) {
+        storeRef.current = new DeploymentStatusStore();
+        storeRef.current.hydrate(initialDeployments);
+    }
+    const store = storeRef.current;
+    // Re-hydrate when SSR data changes (e.g. after graph-data poll).
+    useEffect(() => {
+        store.hydrate(initialDeployments);
+    }, [initialDeployments, store]);
+    // ── Polling ──────────────────────────────────────────────────────────
+    // One interval per targetId. Started when an entry becomes active
+    // (Booting/Ready) and stopped when it is no longer active.
+    const pollIntervalsRef = useRef(new Map());
+    const stopPolling = useCallback((targetId) => {
+        const existing = pollIntervalsRef.current.get(targetId);
+        if (existing) {
+            clearInterval(existing);
+            pollIntervalsRef.current.delete(targetId);
+        }
+    }, []);
+    const startPolling = useCallback((targetId) => {
+        if (pollIntervalsRef.current.has(targetId))
+            return;
+        const interval = setInterval(async () => {
+            let result;
+            try {
+                result = await getDeploymentStatus(targetId);
+            }
+            catch (err) {
+                log.warn(`poll failed for "${targetId}"`, err);
+                store.setStatus(targetId, null);
+                stopPolling(targetId);
+                return;
+            }
+            if (!result || result.state === 'Stopped') {
+                store.setStatus(targetId, null);
+                stopPolling(targetId);
+                return;
+            }
+            store.setStatus(targetId, result);
+        }, POLL_INTERVAL_MS);
+        pollIntervalsRef.current.set(targetId, interval);
+    }, [store, stopPolling]);
+    // Reconcile polling with store state on every change.
+    useEffect(() => {
+        const intervals = pollIntervalsRef.current;
+        const reconcile = () => {
+            // Stop polls for entries that are no longer active.
+            for (const [targetId] of intervals) {
+                const entry = store.getEntry(targetId);
+                if (!entry.status || !ACTIVE_STATES.has(entry.status)) {
+                    stopPolling(targetId);
+                }
+            }
+        };
+        const unsubscribe = store.subscribeAll(reconcile);
+        return () => {
+            unsubscribe();
+            for (const [, interval] of intervals)
+                clearInterval(interval);
+            intervals.clear();
+        };
+    }, [store, stopPolling]);
+    // ── Mount hydration per targetId ─────────────────────────────────────
+    // When a hook subscribes to a targetId that was not in the SSR hydration
+    // (e.g. a stale page with deployments started in another tab), fetch its
+    // status once from the backend via getDeploymentStatus → use case.
+    const ensureHydrated = useCallback((targetId) => {
+        if (!targetId)
+            return;
+        const entry = store.getEntry(targetId);
+        if (entry.hydrated)
+            return;
+        // Mark hydrated immediately to dedupe concurrent callers.
+        store.update(targetId, { hydrated: true });
+        void (async () => {
+            try {
+                const result = await getDeploymentStatus(targetId);
+                store.setStatus(targetId, result);
+                if (result && ACTIVE_STATES.has(result.state))
+                    startPolling(targetId);
+            }
+            catch (err) {
+                log.warn(`ensureHydrated failed for "${targetId}"`, err);
+            }
+        })();
+    }, [store, startPolling]);
+    // ── Actions ──────────────────────────────────────────────────────────
+    const deploy = useCallback(async (input) => {
+        store.update(input.targetId, { deployLoading: true, deployError: null });
+        try {
+            const result = input.targetType === 'feature'
+                ? await deployFeature(input.targetId)
+                : await deployRepository(input.repositoryPath);
+            if (!result.success) {
+                store.update(input.targetId, {
+                    deployLoading: false,
+                    deployError: result.error ?? 'An unexpected error occurred',
+                });
+                return;
+            }
+            store.update(input.targetId, {
+                deployLoading: false,
+                status: result.state ?? null,
+                url: null,
+                hydrated: true,
+                targetType: input.targetType,
+            });
+            startPolling(input.targetId);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'An unexpected error occurred';
+            store.update(input.targetId, { deployLoading: false, deployError: message });
+        }
+    }, [store, startPolling]);
+    const stop = useCallback(async (targetId) => {
+        if (!targetId)
+            return;
+        store.update(targetId, { stopLoading: true });
+        try {
+            const result = await stopDeployment(targetId);
+            if (result.success) {
+                stopPolling(targetId);
+                store.update(targetId, {
+                    stopLoading: false,
+                    status: null,
+                    url: null,
+                });
+            }
+            else {
+                store.update(targetId, { stopLoading: false });
+            }
+        }
+        catch (err) {
+            log.warn('stop error (non-critical)', err);
+            store.update(targetId, { stopLoading: false });
+        }
+    }, [store, stopPolling]);
+    const value = useMemo(() => ({ store, deploy, stop, ensureHydrated }), [store, deploy, stop, ensureHydrated]);
+    return (_jsx(DeploymentStatusContext.Provider, { value: value, children: children }));
+}
+export function useDeploymentStatusContext() {
+    const ctx = useContext(DeploymentStatusContext);
+    if (!ctx) {
+        throw new Error('useDeploymentStatusContext must be used within a <DeploymentStatusProvider>');
+    }
+    return ctx;
+}
+/**
+ * Non-throwing variant used by presentational hooks (e.g. useDeployAction)
+ * that may render inside Storybook or other isolated contexts without
+ * a provider. Returns a stub store/actions that do nothing.
+ */
+export function useDeploymentStatusContextOptional() {
+    const ctx = useContext(DeploymentStatusContext);
+    if (ctx)
+        return ctx;
+    return FALLBACK_CONTEXT;
+}
+const FALLBACK_STORE = new DeploymentStatusStore();
+const FALLBACK_CONTEXT = {
+    store: FALLBACK_STORE,
+    deploy: async () => {
+        /* no-op */
+    },
+    stop: async () => {
+        /* no-op */
+    },
+    ensureHydrated: () => {
+        /* no-op */
+    },
+};
+export { EMPTY_ENTRY };

package/dist/src/presentation/web/hooks/deployment-status-store.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Deployment Status Store
+ *
+ * External store (useSyncExternalStore-compatible) that holds the shared
+ * deployment state keyed by targetId. Multiple components subscribed to
+ * the same targetId see the same state — fixes the node/drawer-out-of-sync
+ * bug and makes page-refresh hydration trivial.
+ *
+ * Mutation paths (deploy/stop/poll) go through server actions that wrap
+ * use cases — this module stores state only and never contains business
+ * logic.
+ */
+import type { DeploymentState } from '../../../../packages/core/src/domain/generated/output.js';
+import type { DeploymentStatus, DeploymentStatusEntry } from '../../../../packages/core/src/application/ports/output/services/deployment-service.interface.js';
+export interface DeploymentEntryState {
+    status: DeploymentState | null;
+    url: string | null;
+    targetType: string | null;
+    /** Whether mount-hydration (listDeployments / getDeploymentStatus) has completed for this targetId. */
+    hydrated: boolean;
+    deployLoading: boolean;
+    stopLoading: boolean;
+    deployError: string | null;
+}
+export declare const EMPTY_ENTRY: DeploymentEntryState;
+type Listener = () => void;
+export declare class DeploymentStatusStore {
+    private entries;
+    private listeners;
+    private globalListeners;
+    /** Seed the store from SSR data (ListDeploymentsUseCase output). */
+    hydrate(entries: DeploymentStatusEntry[]): void;
+    getEntry(targetId: string): DeploymentEntryState;
+    update(targetId: string, patch: Partial<DeploymentEntryState>): void;
+    /** Apply a status snapshot (from a server action result) to a targetId. */
+    setStatus(targetId: string, status: DeploymentStatus | null): void;
+    subscribe(targetId: string, listener: Listener): () => void;
+    subscribeAll(listener: Listener): () => void;
+    private notify;
+}
+export {};
+//# sourceMappingURL=deployment-status-store.d.ts.map

package/dist/src/presentation/web/hooks/deployment-status-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployment-status-store.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/web/hooks/deployment-status-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAC;AAC5E,OAAO,KAAK,EACV,gBAAgB,EAChB,qBAAqB,EACtB,MAAM,6EAA6E,CAAC;AAErF,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,eAAe,GAAG,IAAI,CAAC;IAC/B,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,uGAAuG;IACvG,QAAQ,EAAE,OAAO,CAAC;IAClB,aAAa,EAAE,OAAO,CAAC;IACvB,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED,eAAO,MAAM,WAAW,EAAE,oBAQzB,CAAC;AAEF,KAAK,QAAQ,GAAG,MAAM,IAAI,CAAC;AAE3B,qBAAa,qBAAqB;IAChC,OAAO,CAAC,OAAO,CAA2C;IAC1D,OAAO,CAAC,SAAS,CAAoC;IACrD,OAAO,CAAC,eAAe,CAAuB;IAE9C,oEAAoE;IACpE,OAAO,CAAC,OAAO,EAAE,qBAAqB,EAAE,GAAG,IAAI;IAwB/C,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,oBAAoB;IAIhD,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,oBAAoB,CAAC,GAAG,IAAI;IAOpE,2EAA2E;IAC3E,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,GAAG,IAAI,GAAG,IAAI;IAYlE,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,MAAM,IAAI;IAa3D,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,IAAI;IAO5C,OAAO,CAAC,MAAM;CAKf"}

package/dist/src/presentation/web/hooks/deployment-status-store.js

@@ -0,0 +1,99 @@
+/**
+ * Deployment Status Store
+ *
+ * External store (useSyncExternalStore-compatible) that holds the shared
+ * deployment state keyed by targetId. Multiple components subscribed to
+ * the same targetId see the same state — fixes the node/drawer-out-of-sync
+ * bug and makes page-refresh hydration trivial.
+ *
+ * Mutation paths (deploy/stop/poll) go through server actions that wrap
+ * use cases — this module stores state only and never contains business
+ * logic.
+ */
+export const EMPTY_ENTRY = {
+    status: null,
+    url: null,
+    targetType: null,
+    hydrated: false,
+    deployLoading: false,
+    stopLoading: false,
+    deployError: null,
+};
+export class DeploymentStatusStore {
+    entries = new Map();
+    listeners = new Map();
+    globalListeners = new Set();
+    /** Seed the store from SSR data (ListDeploymentsUseCase output). */
+    hydrate(entries) {
+        // Mark every SSR entry as hydrated and merge into the map.
+        const seen = new Set();
+        for (const entry of entries) {
+            seen.add(entry.targetId);
+            this.update(entry.targetId, {
+                status: entry.state,
+                url: entry.url,
+                targetType: entry.targetType,
+                hydrated: true,
+            });
+        }
+        // Any previously tracked entries missing from the SSR list are stale —
+        // mark them hydrated with null state so subscribers learn their
+        // deployment is gone.
+        for (const [targetId, existing] of this.entries) {
+            if (!seen.has(targetId) && existing.hydrated && existing.status !== null) {
+                this.update(targetId, { status: null, url: null });
+            }
+            else if (!seen.has(targetId) && !existing.hydrated) {
+                this.update(targetId, { hydrated: true });
+            }
+        }
+    }
+    getEntry(targetId) {
+        return this.entries.get(targetId) ?? EMPTY_ENTRY;
+    }
+    update(targetId, patch) {
+        const current = this.entries.get(targetId) ?? EMPTY_ENTRY;
+        const next = { ...current, ...patch };
+        this.entries.set(targetId, next);
+        this.notify(targetId);
+    }
+    /** Apply a status snapshot (from a server action result) to a targetId. */
+    setStatus(targetId, status) {
+        if (status === null) {
+            this.update(targetId, { status: null, url: null, hydrated: true });
+            return;
+        }
+        this.update(targetId, {
+            status: status.state,
+            url: status.url,
+            hydrated: true,
+        });
+    }
+    subscribe(targetId, listener) {
+        let set = this.listeners.get(targetId);
+        if (!set) {
+            set = new Set();
+            this.listeners.set(targetId, set);
+        }
+        set.add(listener);
+        return () => {
+            set?.delete(listener);
+            if (set?.size === 0)
+                this.listeners.delete(targetId);
+        };
+    }
+    subscribeAll(listener) {
+        this.globalListeners.add(listener);
+        return () => {
+            this.globalListeners.delete(listener);
+        };
+    }
+    notify(targetId) {
+        const set = this.listeners.get(targetId);
+        if (set)
+            for (const l of set)
+                l();
+        for (const l of this.globalListeners)
+            l();
+    }
+}

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

@@ -1,10 +1,6 @@
 import type { DeploymentState } from '../../../../packages/core/src/domain/generated/output.js';
-export interface DeployActionInput {
-    targetId: string;
-    targetType: 'feature' | 'repository';
-    repositoryPath: string;
-    branch?: string;
-}
+import { type DeployActionInput } from './deployment-status-provider.js';
+export type { DeployActionInput };
 export interface DeployActionState {
     deploy: () => Promise<void>;
     stop: () => Promise<void>;

package/dist/src/presentation/web/hooks/use-deploy-action.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-deploy-action.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/web/hooks/use-deploy-action.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAC;AAM5E,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,SAAS,GAAG,YAAY,CAAC;IACrC,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,aAAa,EAAE,OAAO,CAAC;IACvB,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,MAAM,EAAE,eAAe,GAAG,IAAI,CAAC;IAC/B,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CACpB;AAMD,wBAAgB,eAAe,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI,GAAG,iBAAiB,CAwLlF"}
+{"version":3,"file":"use-deploy-action.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/web/hooks/use-deploy-action.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAC;AAC5E,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,8BAA8B,CAAC;AAEtC,YAAY,EAAE,iBAAiB,EAAE,CAAC;AAOlC,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,aAAa,EAAE,OAAO,CAAC;IACvB,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,MAAM,EAAE,eAAe,GAAG,IAAI,CAAC;IAC/B,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CACpB;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI,GAAG,iBAAiB,CA0ClF"}

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

@@ -1,171 +1,54 @@
 'use client';
-import { useState, useCallback, useRef, useEffect } from 'react';
-import { createLogger } from '../lib/logger.js';
-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 log = createLogger('[useDeployAction]');
-const POLL_INTERVAL = 3000;
+/**
+ * useDeployAction
+ *
+ * Thin subscriber to the shared DeploymentStatusProvider, scoped to one
+ * targetId. All components that call this hook with the same targetId
+ * see the same state — a click on a node updates the drawer instantly,
+ * and state survives page refresh via SSR hydration.
+ *
+ * Business logic (start/stop/status) lives in backend use cases — this
+ * hook contains zero decision-making code.
+ */
+import { useEffect, useSyncExternalStore, useCallback } from 'react';
+import { useDeploymentStatusContextOptional, } from './deployment-status-provider.js';
+/** Stable no-op unsubscribe for hooks called with a null input. */
+function noop() {
+    /* no-op */
+}
 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 pollIntervalRef = useRef(null);
-    const mountedRef = useRef(true);
-    const statusRef = useRef(status);
-    // Keep statusRef in sync with latest status
-    useEffect(() => {
-        statusRef.current = status;
-    }, [status]);
-    // Track mounted state
+    const { store, deploy, stop, ensureHydrated } = useDeploymentStatusContextOptional();
+    const targetId = input?.targetId ?? '';
+    // Subscribe to the store entry for this targetId.
+    const subscribe = useCallback((listener) => {
+        if (!targetId)
+            return noop;
+        return store.subscribe(targetId, listener);
+    }, [store, targetId]);
+    const getSnapshot = useCallback(() => (targetId ? store.getEntry(targetId) : store.getEntry('')), [store, targetId]);
+    const entry = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+    // On mount (or when targetId changes), ensure the entry is hydrated.
     useEffect(() => {
-        mountedRef.current = true;
-        return () => {
-            mountedRef.current = false;
-        };
-    }, []);
-    // Mount recovery removed — getGraphData() already enriches nodes with
-    // deployment status (get-graph-data.ts lines 180-200). No need to call
-    // a server action per node on every mount.
-    // Cleanup on unmount
-    useEffect(() => {
-        return () => {
-            if (pollIntervalRef.current)
-                clearInterval(pollIntervalRef.current);
-        };
-    }, []);
-    const stopPolling = useCallback(() => {
-        if (pollIntervalRef.current) {
-            log.debug('stopping polling');
-            clearInterval(pollIntervalRef.current);
-            pollIntervalRef.current = null;
-        }
-    }, []);
-    const startPolling = useCallback((targetId) => {
-        stopPolling();
-        log.debug(`starting polling for "${targetId}" every ${POLL_INTERVAL}ms`);
-        pollIntervalRef.current = setInterval(async () => {
-            if (!mountedRef.current) {
-                stopPolling();
-                return;
-            }
-            let result;
-            try {
-                result = await getDeploymentStatus(targetId);
-            }
-            catch (err) {
-                log.warn(`poll fetch failed for "${targetId}":`, err);
-                // Treat fetch failure as deployment gone — clear UI
-                if (mountedRef.current) {
-                    setStatus(null);
-                    setUrl(null);
-                    stopPolling();
-                }
-                return;
-            }
-            if (!mountedRef.current)
-                return;
-            if (!result || result.state === 'Stopped') {
-                log.info(`poll result: ${result ? `state=${result.state}` : 'null (deployment gone)'} — stopping poll`);
-                setStatus(null);
-                setUrl(null);
-                stopPolling();
-            }
-            else {
-                if (result.state !== statusRef.current) {
-                    log.info(`poll state changed: ${statusRef.current} → ${result.state}, url=${result.url}`);
-                }
-                setStatus(result.state);
-                setUrl(result.url);
-            }
-        }, POLL_INTERVAL);
-    }, [stopPolling]);
-    // Idle poll removed — it was calling getDeploymentStatus every 5s for EVERY
-    // node on the canvas (~25 nodes = ~5 server action calls/sec). The mount
-    // recovery effect above (line 57) already checks on mount. Deployments
-    // started externally (e.g., from the drawer) should update the node via
-    // reconcile from the graph-data poll instead.
+        if (targetId)
+            ensureHydrated(targetId);
+    }, [targetId, ensureHydrated]);
     const handleDeploy = useCallback(async () => {
-        if (!input) {
-            log.warn('deploy() called but input is null — no-op');
-            return;
-        }
-        if (deployLoading) {
-            log.warn('deploy() called but already loading — no-op');
+        if (!input)
             return;
-        }
-        log.info(`deploy() — targetType="${input.targetType}", targetId="${input.targetId}", repositoryPath="${input.repositoryPath}"`);
-        setDeployLoading(true);
-        setDeployError(null);
-        try {
-            const result = input.targetType === 'feature'
-                ? await deployFeature(input.targetId)
-                : await deployRepository(input.repositoryPath);
-            log.info('server action result:', result);
-            if (!mountedRef.current) {
-                log.warn('component unmounted after deploy — discarding result');
-                return;
-            }
-            if (!result.success) {
-                const errorMessage = result.error ?? 'An unexpected error occurred';
-                log.warn(`deploy failed: ${errorMessage}`);
-                setDeployError(errorMessage);
-            }
-            else {
-                log.info(`deploy succeeded — initial state=${result.state}, starting polling`);
-                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';
-            log.error(`deploy threw exception: ${errorMessage}`, err);
-            setDeployError(errorMessage);
-        }
-        finally {
-            if (mountedRef.current) {
-                setDeployLoading(false);
-            }
-        }
-    }, [input, deployLoading, startPolling]);
+        await deploy(input);
+    }, [deploy, input]);
     const handleStop = useCallback(async () => {
-        if (!input || stopLoading)
+        if (!targetId)
             return;
-        log.info(`stop() — targetId="${input.targetId}"`);
-        setStopLoading(true);
-        try {
-            const result = await stopDeployment(input.targetId);
-            log.info('stop result:', result);
-            if (!mountedRef.current)
-                return;
-            if (result.success) {
-                stopPolling();
-                setStatus(null);
-                setUrl(null);
-            }
-        }
-        catch (err) {
-            log.warn('stop error (non-critical):', err);
-        }
-        finally {
-            if (mountedRef.current) {
-                setStopLoading(false);
-            }
-        }
-    }, [input, stopLoading, stopPolling]);
+        await stop(targetId);
+    }, [stop, targetId]);
     return {
         deploy: handleDeploy,
         stop: handleStop,
-        deployLoading,
-        stopLoading,
-        deployError,
-        status,
-        url,
+        deployLoading: entry.deployLoading,
+        stopLoading: entry.stopLoading,
+        deployError: entry.deployError,
+        status: entry.status,
+        url: entry.url,
     };
 }