@pulse-editor/react-api 0.1.1-beta.84 → 0.1.1-beta.86

package/dist/hooks/editor/use-oauth.d.ts

@@ -1,13 +1,4 @@
 import { OAuthConnectConfig } from "@pulse-editor/shared-utils";
-export type OAuthState = {
-    accessToken?: string;
-    refreshToken?: string;
-    tokenType?: string;
-    scope?: string;
-    expiresAt?: string | number;
-    idToken?: string;
-    [key: string]: any;
-};
 /**
  * Hook to manage OAuth credentials for a Pulse App.
  *
@@ -23,14 +14,7 @@ export type OAuthState = {
 export default function useOAuth(appId: string, provider?: string): {
     isReady: boolean;
     isLoading: boolean;
-    oauth: OAuthState | null;
     isAuthenticated: boolean;
     connect: (config: OAuthConnectConfig) => Promise<void>;
     disconnect: () => Promise<void>;
-    refetchOAuth: () => Promise<void>;
-    refreshToken: (params: {
-        tokenEndpoint: string;
-        clientId: string;
-        clientSecret?: string;
-    }) => Promise<OAuthState | null>;
 };

package/dist/main.d.ts

@@ -14,11 +14,10 @@ import useVideoGen from "./hooks/ai-modality/use-video-gen";
 import useAppSettings from "./hooks/editor/use-app-settings";
 import { useArtifact } from "./hooks/editor/use-artifact";
 import useEditorEnv from "./hooks/editor/use-editor-env";
+import useOAuth from "./hooks/editor/use-oauth";
 import useOpenApp from "./hooks/editor/use-open-app";
 import useOpenLink from "./hooks/editor/use-open-link";
 import useOwnedAppView from "./hooks/editor/use-owned-app-view";
-import useOAuth from "./hooks/editor/use-oauth";
-export type { OAuthState } from "./hooks/editor/use-oauth";
 import useSnapshotState from "./hooks/editor/use-snapshot-state";
 import { useTranslations } from "./hooks/editor/use-translations";
 import useFileSystem from "./hooks/workspace/use-file-system";
@@ -27,4 +26,4 @@ import useTerminal from "./hooks/workspace/use-terminal";
 import useWorkspaceInfo from "./hooks/workspace/use-workspace-info";
 import ReceiveFileProvider from "./providers/receive-file-provider";
 import SnapshotProvider from "./providers/snapshot-provider";
-export { ReceiveFileProvider, SnapshotProvider, useActionEffect, useAgents, useAgentTools, useAppSettings, useArtifact, useEditorEnv, useFile, useFileSystem, useImageGen, useLLM, useLoading, useNotification, useOCR, useOpenApp, useOpenLink, useOAuth, useOwnedAppView, useReceiveFile, useSnapshotState, useSTT, useTerminal, useTheme, useTranslations, useTTS, useVideoGen, useWorkspaceInfo, };
+export { ReceiveFileProvider, SnapshotProvider, useActionEffect, useAgents, useAgentTools, useAppSettings, useArtifact, useEditorEnv, useFile, useFileSystem, useImageGen, useLLM, useLoading, useNotification, useOAuth, useOCR, useOpenApp, useOpenLink, useOwnedAppView, useReceiveFile, useSnapshotState, useSTT, useTerminal, useTheme, useTranslations, useTTS, useVideoGen, useWorkspaceInfo, };

package/dist/main.js

@@ -1,4 +1,4 @@
-import { InterModuleCommunication, IMCMessageTypeEnum } from '@pulse-editor/shared-utils';
+import { InterModuleCommunication, IMCMessageTypeEnum, OAuthStatusEnum } from '@pulse-editor/shared-utils';
 import React, { useState, useEffect, useRef, useMemo, useCallback, createContext, useContext } from 'react';
 
 var byteToHex = [];
@@ -5704,7 +5704,7 @@ function useActionEffect(params, deps, isExtReady = true) {
                 returns: actionInfo.returns,
             });
             // Update receiver
-            imc?.updateReceiverHandlerMap(getReceiverHandlerMap(func));
+            imc?.updateReceiverHandlerMap(getReceiverHandlerMap(func, beforeAction, afterAction));
         }
         if (isExtReady) {
             updateAction();
@@ -5737,8 +5737,23 @@ function useActionEffect(params, deps, isExtReady = true) {
         }
         return afterRes !== undefined ? afterRes : res;
     }
-    function getReceiverHandlerMap(actionHandlerFunc) {
+    function getReceiverHandlerMap(actionHandlerFunc, beforeActionFunc, afterActionFunc) {
         const receiverHandlerMap = new Map([
+            [
+                IMCMessageTypeEnum.EditorRestoreActionCache,
+                async (_senderWindow, message) => {
+                    const { name, input, output } = message.payload;
+                    if (params.actionName !== name) {
+                        throw new Error("Message ignored by receiver");
+                    }
+                    if (beforeActionFunc && input !== undefined) {
+                        await beforeActionFunc(input);
+                    }
+                    if (afterActionFunc && output !== undefined) {
+                        await afterActionFunc(output);
+                    }
+                },
+            ],
             [
                 IMCMessageTypeEnum.EditorRunAppAction,
                 async (_senderWindow, message) => {
@@ -6271,68 +6286,6 @@ function useEditorEnv() {
     };
 }
 
-function useOpenApp() {
-    const receiverHandlerMap = new Map();
-    const { imc, isReady } = useIMC(receiverHandlerMap, "open-app");
-    async function openApp(appId, location, version) {
-        if (!isReady) {
-            throw new Error("IMC is not ready");
-        }
-        await imc?.sendMessage(IMCMessageTypeEnum.EditorOpenApp, {
-            appId,
-            version,
-            location,
-        });
-    }
-    return {
-        isReady,
-        openApp,
-    };
-}
-
-function useOpenLink() {
-    const receiverHandlerMap = new Map();
-    const { imc, isReady } = useIMC(receiverHandlerMap, "open-link");
-    async function openLink(url) {
-        if (!isReady) {
-            throw new Error("IMC is not ready");
-        }
-        await imc?.sendMessage(IMCMessageTypeEnum.EditorOpenLink, {
-            url: url.toString(),
-        });
-    }
-    return {
-        isReady,
-        openLink,
-    };
-}
-
-function useOwnedAppView() {
-    const receiverHandlerMap = new Map([]);
-    const { imc, isReady } = useIMC(receiverHandlerMap, "owned-app");
-    const runAppAction = useCallback(async (ownedAppViewModel, actionName, args) => {
-        if (isReady) {
-            const appViewId = ownedAppViewModel.viewId;
-            const skillActions = ownedAppViewModel.appConfig.actions || [];
-            const action = skillActions.find((a) => a.name === actionName);
-            if (!action) {
-                throw new Error(`Action ${actionName} not found in owned app ${ownedAppViewModel.appConfig.id}`);
-            }
-            const result = await imc?.sendMessage(IMCMessageTypeEnum.EditorAppUseOwnedApp, {
-                viewId: appViewId,
-                actionName,
-                args,
-            });
-            return result;
-        }
-        return undefined;
-    }, [imc, isReady]);
-    return {
-        isReady,
-        runAppAction,
-    };
-}
-
 function generateRandomString(length) {
     const array = new Uint8Array(length);
     crypto.getRandomValues(array);
@@ -6351,18 +6304,24 @@ function generateRandomString(length) {
  * @param provider A provider identifier used to namespace the OAuth state.
  */
 function useOAuth(appId, provider = "default") {
-    const { isReady, isLoaded, settings, deleteSetting, refetch } = useAppSettings(appId);
-    const keyPrefix = `oauth:${provider}:`;
-    const oauthEntries = Object.entries(settings).filter(([k]) => k.startsWith(keyPrefix));
-    const oauthRaw = oauthEntries.length > 0
-        ? Object.fromEntries(oauthEntries.map(([k, v]) => [k.slice(keyPrefix.length), v]))
-        : null;
-    const oauth = oauthRaw &&
-        Object.values(oauthRaw).some((v) => v !== null && v !== undefined)
-        ? oauthRaw
-        : null;
+    const { isReady, isLoaded } = useAppSettings(appId);
+    const [isAuthenticated, setIsAuthenticated] = useState(false);
     const receiverHandlerMap = new Map();
     const { imc, isReady: isIMCReady } = useIMC(receiverHandlerMap, "oauth");
+    async function checkAuthStatus() {
+        if (!isIMCReady)
+            return;
+        try {
+            const status = await imc?.sendMessage(IMCMessageTypeEnum.EditorOAuthCheckStatus, { appId, provider });
+            setIsAuthenticated(status === OAuthStatusEnum.Authenticated);
+        }
+        catch {
+            setIsAuthenticated(false);
+        }
+    }
+    useEffect(() => {
+        checkAuthStatus();
+    }, [isIMCReady]);
     /**
      * Initiate the OAuth flow. The editor handles everything:
      * - Dynamic client registration (if `registrationEndpoint` is provided and `clientId` is omitted)
@@ -6388,66 +6347,99 @@ function useOAuth(appId, provider = "default") {
         });
     }
     /**
-     * Sign out: removes all stored OAuth tokens for this provider from the
-     * editor backend and resets local auth state immediately.
+     * Sign out: sends a disconnect request through the editor to remove
+     * stored OAuth tokens on the backend for this provider.
      */
     async function disconnect() {
-        // Collect keys before deletion so we don't rely on stale `oauth`
-        const keysToDelete = oauthEntries.map(([k]) => k);
-        await Promise.all(keysToDelete.map((key) => deleteSetting(key)));
-    }
-    /**
-     * Re-fetch OAuth state from app settings.
-     * Call this after the user completes the OAuth flow in the external window.
-     */
-    async function refetchOAuth() {
-        await refetch();
+        if (!isIMCReady) {
+            throw new Error("IMC is not ready.");
+        }
+        await imc?.sendMessage(IMCMessageTypeEnum.EditorOAuthDisconnect, {
+            appId,
+            provider,
+        });
+        setIsAuthenticated(false);
     }
-    // Revalidate OAuth state when the user returns to the tab
+    // Revalidate OAuth status when the user returns to the tab
     useEffect(() => {
         function handleVisibilityChange() {
             if (document.visibilityState === "visible") {
-                refetch();
+                checkAuthStatus();
             }
         }
         document.addEventListener("visibilitychange", handleVisibilityChange);
         return () => {
             document.removeEventListener("visibilitychange", handleVisibilityChange);
         };
-    }, [isReady]);
-    /**
-     * Refresh the access token using the stored refresh token.
-     * The editor backend exchanges the refresh token with the OAuth provider
-     * and persists the new tokens automatically.
-     */
-    async function refreshToken(params) {
-        if (!isIMCReady) {
-            throw new Error("IMC is not ready.");
-        }
-        if (!oauth?.refreshToken) {
-            throw new Error("No refresh token available.");
+    }, [isIMCReady]);
+    return {
+        isReady,
+        isLoading: !isLoaded,
+        isAuthenticated,
+        connect,
+        disconnect,
+    };
+}
+
+function useOpenApp() {
+    const receiverHandlerMap = new Map();
+    const { imc, isReady } = useIMC(receiverHandlerMap, "open-app");
+    async function openApp(appId, location, version) {
+        if (!isReady) {
+            throw new Error("IMC is not ready");
         }
-        const result = await imc?.sendMessage(IMCMessageTypeEnum.EditorOAuthRefreshToken, {
+        await imc?.sendMessage(IMCMessageTypeEnum.EditorOpenApp, {
             appId,
-            provider,
-            tokenEndpoint: params.tokenEndpoint,
-            refreshToken: oauth.refreshToken,
-            clientId: params.clientId,
-            clientSecret: params.clientSecret,
+            version,
+            location,
         });
-        // Re-fetch settings to sync local state
-        await refetchOAuth();
-        return result ?? null;
     }
     return {
         isReady,
-        isLoading: !isLoaded,
-        oauth,
-        isAuthenticated: Boolean(oauth?.accessToken),
-        connect,
-        disconnect,
-        refetchOAuth,
-        refreshToken,
+        openApp,
+    };
+}
+
+function useOpenLink() {
+    const receiverHandlerMap = new Map();
+    const { imc, isReady } = useIMC(receiverHandlerMap, "open-link");
+    async function openLink(url) {
+        if (!isReady) {
+            throw new Error("IMC is not ready");
+        }
+        await imc?.sendMessage(IMCMessageTypeEnum.EditorOpenLink, {
+            url: url.toString(),
+        });
+    }
+    return {
+        isReady,
+        openLink,
+    };
+}
+
+function useOwnedAppView() {
+    const receiverHandlerMap = new Map([]);
+    const { imc, isReady } = useIMC(receiverHandlerMap, "owned-app");
+    const runAppAction = useCallback(async (ownedAppViewModel, actionName, args) => {
+        if (isReady) {
+            const appViewId = ownedAppViewModel.viewId;
+            const skillActions = ownedAppViewModel.appConfig.actions || [];
+            const action = skillActions.find((a) => a.name === actionName);
+            if (!action) {
+                throw new Error(`Action ${actionName} not found in owned app ${ownedAppViewModel.appConfig.id}`);
+            }
+            const result = await imc?.sendMessage(IMCMessageTypeEnum.EditorAppUseOwnedApp, {
+                viewId: appViewId,
+                actionName,
+                args,
+            });
+            return result;
+        }
+        return undefined;
+    }, [imc, isReady]);
+    return {
+        isReady,
+        runAppAction,
     };
 }