@godscene/playground-electron 1.7.11

package/dist/es/controller/usePlaygroundController.mjs

@@ -0,0 +1,400 @@
+import { PlaygroundSDK } from "@godscene/playground";
+import { useEnvConfig } from "@godscene/visualizer";
+import { Form, message } from "antd";
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { resolveAutoCreateSessionInput } from "../session-setup.mjs";
+import { buildSessionInitialValues, resolveSessionViewState } from "../session-state.mjs";
+import { useServerStatus } from "../useServerStatus.mjs";
+import { applyPlaygroundAiConfig, hasPlaygroundAiConfig, serializePlaygroundAiConfig } from "./ai-config.mjs";
+import { resolveAutoCreateDecision, serializeAutoCreateInput, shouldResetAutoCreateBlock } from "./auto-create.mjs";
+import { runSingleFlight } from "./single-flight.mjs";
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(void 0);
+        });
+    };
+}
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = null != arguments[i] ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if ("function" == typeof Object.getOwnPropertySymbols) ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+        }));
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function usePlaygroundController_ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) symbols = symbols.filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        });
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = null != source ? source : {};
+    if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    else usePlaygroundController_ownKeys(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+    return target;
+}
+function getPlatformSelectorFieldKey(setup) {
+    var _setup_platformSelector;
+    return null == setup ? void 0 : null == (_setup_platformSelector = setup.platformSelector) ? void 0 : _setup_platformSelector.fieldKey;
+}
+function usePlaygroundController({ serverUrl, defaultDeviceType = 'web', pollIntervalMs = 5000, countdownSeconds = 3, initialFormValues }) {
+    var _Form_useWatch;
+    const [form] = Form.useForm();
+    const initialFormValuesRef = useRef(initialFormValues);
+    useLayoutEffect(()=>{
+        const seed = initialFormValuesRef.current;
+        if (!seed) return;
+        for (const [key, value] of Object.entries(seed))if (void 0 === form.getFieldValue(key)) form.setFieldsValue({
+            [key]: value
+        });
+    }, [
+        form
+    ]);
+    const formValues = null != (_Form_useWatch = Form.useWatch([], form)) ? _Form_useWatch : {};
+    const [countdown, setCountdown] = useState(null);
+    const [sessionSetup, setSessionSetup] = useState(null);
+    const [sessionSetupError, setSessionSetupError] = useState(null);
+    const [sessionLoading, setSessionLoading] = useState(false);
+    const [sessionMutating, setSessionMutating] = useState(false);
+    const aiConfig = useEnvConfig((state)=>state.config);
+    const aiConfigSignature = useMemo(()=>serializePlaygroundAiConfig(aiConfig), [
+        aiConfig
+    ]);
+    const platformSelectorFieldKey = getPlatformSelectorFieldKey(sessionSetup);
+    const selectedPlatformId = 'string' == typeof platformSelectorFieldKey ? formValues[platformSelectorFieldKey] : void 0;
+    const playgroundSDK = useMemo(()=>new PlaygroundSDK({
+            type: 'remote-execution',
+            serverUrl
+        }), [
+        serverUrl
+    ]);
+    const { serverOnline, isUserOperating, deviceType, runtimeInfo, executionUxHints, refreshServerState } = useServerStatus(playgroundSDK, defaultDeviceType, pollIntervalMs);
+    const sessionViewState = useMemo(()=>resolveSessionViewState(runtimeInfo), [
+        runtimeInfo
+    ]);
+    const countdownTimerRef = useRef(null);
+    const countdownResolveRef = useRef(null);
+    const mountedRef = useRef(true);
+    const lastSetupPlatformIdRef = useRef(void 0);
+    const autoCreateSignatureRef = useRef(null);
+    const autoCreateBlockedSignatureRef = useRef(null);
+    const sessionMutatingRef = useRef(false);
+    const appliedAiConfigSignatureRef = useRef(null);
+    const pendingCreateSessionRef = useRef(null);
+    const pendingAiConfigApplicationRef = useRef(null);
+    const applyAiConfig = useCallback(()=>_async_to_generator(function*() {
+            if (!hasPlaygroundAiConfig(aiConfig)) {
+                appliedAiConfigSignatureRef.current = null;
+                pendingAiConfigApplicationRef.current = null;
+                return true;
+            }
+            if (appliedAiConfigSignatureRef.current === aiConfigSignature) return true;
+            const pendingApplication = pendingAiConfigApplicationRef.current;
+            if ((null == pendingApplication ? void 0 : pendingApplication.signature) === aiConfigSignature) return pendingApplication.promise;
+            const pendingApplicationState = {
+                promise: Promise.resolve(true),
+                signature: aiConfigSignature
+            };
+            const applyPromise = (()=>_async_to_generator(function*() {
+                    try {
+                        yield applyPlaygroundAiConfig(playgroundSDK, aiConfig);
+                        appliedAiConfigSignatureRef.current = aiConfigSignature;
+                        return true;
+                    } catch (error) {
+                        const errorMessage = error instanceof Error ? error.message : 'Failed to apply AI configuration';
+                        message.error(errorMessage);
+                        return false;
+                    } finally{
+                        if (pendingAiConfigApplicationRef.current === pendingApplicationState) pendingAiConfigApplicationRef.current = null;
+                    }
+                })())();
+            pendingApplicationState.promise = applyPromise;
+            pendingAiConfigApplicationRef.current = pendingApplicationState;
+            return applyPromise;
+        })(), [
+        aiConfig,
+        aiConfigSignature,
+        playgroundSDK
+    ]);
+    const finishCountdown = useCallback(()=>{
+        if (null !== countdownTimerRef.current) {
+            window.clearInterval(countdownTimerRef.current);
+            countdownTimerRef.current = null;
+        }
+        const resolve = countdownResolveRef.current;
+        countdownResolveRef.current = null;
+        if (mountedRef.current) setCountdown(null);
+        null == resolve || resolve();
+    }, []);
+    const showCountdownModal = useCallback(()=>_async_to_generator(function*() {
+            if (countdownSeconds <= 0) return;
+            finishCountdown();
+            return new Promise((resolve)=>{
+                countdownResolveRef.current = resolve;
+                let count = countdownSeconds;
+                if (mountedRef.current) setCountdown(count);
+                countdownTimerRef.current = window.setInterval(()=>{
+                    count -= 1;
+                    if (count > 0) {
+                        if (mountedRef.current) setCountdown(count);
+                        return;
+                    }
+                    if (0 === count) {
+                        if (mountedRef.current) setCountdown('GO!');
+                        return;
+                    }
+                    finishCountdown();
+                }, 1000);
+            });
+        })(), [
+        countdownSeconds,
+        finishCountdown
+    ]);
+    useEffect(()=>{
+        mountedRef.current = true;
+        return ()=>{
+            mountedRef.current = false;
+            finishCountdown();
+        };
+    }, [
+        finishCountdown
+    ]);
+    useEffect(()=>{
+        if (!executionUxHints.includes('countdown-before-run')) return void playgroundSDK.setBeforeActionHook(void 0);
+        playgroundSDK.setBeforeActionHook(()=>_async_to_generator(function*() {
+                yield showCountdownModal();
+            })());
+        return ()=>{
+            playgroundSDK.setBeforeActionHook(void 0);
+        };
+    }, [
+        executionUxHints,
+        playgroundSDK,
+        showCountdownModal
+    ]);
+    const refreshSessionSetup = useCallback((input)=>_async_to_generator(function*() {
+            const currentValues = _object_spread({}, form.getFieldsValue(true), input || {});
+            setSessionLoading(true);
+            try {
+                const setup = yield playgroundSDK.getSessionSetup(input);
+                setSessionSetup(setup);
+                setSessionSetupError(null);
+                const currentPlatformSelectorFieldKey = getPlatformSelectorFieldKey(setup);
+                lastSetupPlatformIdRef.current = currentPlatformSelectorFieldKey && 'string' == typeof currentValues[currentPlatformSelectorFieldKey] ? currentValues[currentPlatformSelectorFieldKey] : void 0;
+                form.setFieldsValue(buildSessionInitialValues(setup, currentValues));
+            } catch (error) {
+                console.error('Failed to load session setup:', error);
+                setSessionSetupError(error instanceof Error ? error.message : 'Failed to load session setup');
+            } finally{
+                setSessionLoading(false);
+            }
+        })(), [
+        form,
+        playgroundSDK
+    ]);
+    const createSession = useCallback((input, options)=>_async_to_generator(function*() {
+            return runSingleFlight(pendingCreateSessionRef, ()=>_async_to_generator(function*() {
+                    try {
+                        sessionMutatingRef.current = true;
+                        setSessionMutating(true);
+                        if (!(yield applyAiConfig())) return false;
+                        const values = null != input ? input : yield form.validateFields();
+                        yield playgroundSDK.createSession(values);
+                        if (shouldResetAutoCreateBlock(options)) autoCreateBlockedSignatureRef.current = null;
+                        if (!(null == options ? void 0 : options.silent)) message.success('Agent created');
+                        yield refreshServerState();
+                        return true;
+                    } catch (error) {
+                        if (error.errorFields) return false;
+                        const errorMessage = error instanceof Error ? error.message : 'Failed to create Agent';
+                        message.error(errorMessage);
+                        return false;
+                    } finally{
+                        sessionMutatingRef.current = false;
+                        setSessionMutating(false);
+                    }
+                })());
+        })(), [
+        applyAiConfig,
+        form,
+        playgroundSDK,
+        refreshServerState
+    ]);
+    const destroySession = useCallback(()=>_async_to_generator(function*() {
+            try {
+                autoCreateBlockedSignatureRef.current = serializeAutoCreateInput(resolveAutoCreateSessionInput(sessionSetup, form.getFieldsValue(true)));
+                sessionMutatingRef.current = true;
+                setSessionMutating(true);
+                yield playgroundSDK.destroySession();
+                message.success('Session disconnected');
+                yield refreshServerState();
+                yield refreshSessionSetup();
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Failed to disconnect session';
+                message.error(errorMessage);
+            } finally{
+                sessionMutatingRef.current = false;
+                setSessionMutating(false);
+            }
+        })(), [
+        form,
+        playgroundSDK,
+        refreshServerState,
+        refreshSessionSetup,
+        sessionSetup
+    ]);
+    useEffect(()=>{
+        if (!serverOnline) return;
+        applyAiConfig();
+    }, [
+        applyAiConfig,
+        serverOnline
+    ]);
+    useEffect(()=>{
+        if (!serverOnline || sessionViewState.connected) return;
+        let disposed = false;
+        let refreshing = false;
+        const refreshTargets = ()=>_async_to_generator(function*() {
+                if (disposed || refreshing) return;
+                refreshing = true;
+                try {
+                    yield refreshSessionSetup(form.getFieldsValue(true));
+                } finally{
+                    refreshing = false;
+                }
+            })();
+        refreshTargets();
+        const intervalId = window.setInterval(()=>{
+            refreshTargets();
+        }, pollIntervalMs);
+        return ()=>{
+            disposed = true;
+            window.clearInterval(intervalId);
+        };
+    }, [
+        form,
+        pollIntervalMs,
+        refreshSessionSetup,
+        serverOnline,
+        sessionViewState.connected
+    ]);
+    useEffect(()=>{
+        if (!serverOnline || sessionViewState.connected || !selectedPlatformId) return;
+        const currentPlatformSelectorFieldKey = getPlatformSelectorFieldKey(sessionSetup);
+        if (!currentPlatformSelectorFieldKey) return;
+        if (lastSetupPlatformIdRef.current === selectedPlatformId) return;
+        refreshSessionSetup(_object_spread_props(_object_spread({}, form.getFieldsValue(true)), {
+            [currentPlatformSelectorFieldKey]: selectedPlatformId
+        }));
+    }, [
+        form,
+        refreshSessionSetup,
+        selectedPlatformId,
+        serverOnline,
+        sessionSetup,
+        sessionViewState.connected
+    ]);
+    useEffect(()=>{
+        if (sessionViewState.connected) {
+            autoCreateSignatureRef.current = null;
+            return;
+        }
+        if (!serverOnline || sessionLoading || sessionMutating || sessionMutatingRef.current || sessionSetupError) return;
+        const autoCreateInput = resolveAutoCreateSessionInput(sessionSetup, form.getFieldsValue(true));
+        const { signature, shouldCreate } = resolveAutoCreateDecision({
+            autoCreateInput,
+            lastAttemptedSignature: autoCreateSignatureRef.current,
+            blockedSignature: autoCreateBlockedSignatureRef.current
+        });
+        if (!shouldCreate || !signature) {
+            if (!signature) autoCreateSignatureRef.current = null;
+            return;
+        }
+        autoCreateSignatureRef.current = signature;
+        (()=>_async_to_generator(function*() {
+                const created = yield createSession(null != autoCreateInput ? autoCreateInput : void 0, {
+                    silent: true
+                });
+                if (!created) autoCreateSignatureRef.current = null;
+            })())();
+    }, [
+        createSession,
+        form,
+        serverOnline,
+        sessionLoading,
+        sessionMutating,
+        sessionSetup,
+        sessionSetupError,
+        sessionViewState.connected
+    ]);
+    return {
+        state: {
+            playgroundSDK,
+            form,
+            formValues,
+            serverOnline,
+            isUserOperating,
+            deviceType,
+            runtimeInfo,
+            executionUxHints,
+            sessionViewState,
+            sessionSetup,
+            sessionSetupError,
+            sessionLoading,
+            sessionMutating,
+            countdown,
+            countdownSeconds
+        },
+        actions: {
+            refreshServerState,
+            refreshSessionSetup,
+            createSession,
+            destroySession,
+            finishCountdown
+        }
+    };
+}
+export { usePlaygroundController };

package/dist/es/icons/dropdown-chevron.mjs

@@ -0,0 +1,61 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = null != arguments[i] ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if ("function" == typeof Object.getOwnPropertySymbols) ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+        }));
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function dropdown_chevron_ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) symbols = symbols.filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        });
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = null != source ? source : {};
+    if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    else dropdown_chevron_ownKeys(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+    return target;
+}
+const SvgDropdownChevron = (props)=>/*#__PURE__*/ jsx("svg", _object_spread_props(_object_spread({
+        xmlns: "http://www.w3.org/2000/svg",
+        width: 16,
+        height: 16,
+        fill: "none",
+        viewBox: "0 0 16 16"
+    }, props), {
+        children: /*#__PURE__*/ jsx("path", {
+            stroke: "#333",
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            strokeWidth: 1.333,
+            d: "m12 6-4 4-4-4"
+        })
+    }));
+const dropdown_chevron = SvgDropdownChevron;
+export { dropdown_chevron as default };