@base44/superagent-native 0.0.2 → 0.0.3

package/src/useSuperagentRuntime.ts

@@ -174,6 +174,11 @@ export function useSuperagentRuntime({
   const [isLoading, setIsLoading] = useState(true);
   const [loadError, setLoadError] = useState<string | null>(null);
   const [runtimeAuthToken, setRuntimeAuthToken] = useState<string | null>(null);
+  // Caches the resolved runtime token keyed by the agent it belongs to. The
+  // runtimeAuthToken state lags an agent switch (it's cleared in a later effect),
+  // so resolveRuntimeToken must not trust it as a cache — this ref can never hand
+  // back a different agent's token.
+  const runtimeTokenRef = useRef<{ agentId: string; token: string } | null>(null);
   const [realtimeClient, setRealtimeClient] = useState<SuperagentRealtimeClient | undefined>();
   const [secrets, setSecrets] = useState<SuperagentSecret[]>([]);
   const connectorFlowRef = useRef<ConnectorFlow | null>(null);
@@ -299,16 +304,25 @@ export function useSuperagentRuntime({
   }, [superagentService]);
 
   const resolveRuntimeToken = useCallback(async (agentId: string) => {
-    if (agentId === activeAgentId && runtimeAuthToken) {
-      return runtimeAuthToken;
+    // Use the agent-keyed ref, not the runtimeAuthToken state: the state still
+    // holds the previous agent's token during a switch (it's cleared in a later
+    // effect), so trusting it could return the wrong agent's token here.
+    const cached = runtimeTokenRef.current;
+    if (cached && cached.agentId === agentId) {
+      return cached.token;
     }
 
     const token = await superagentService.getRuntimeAuthToken(agentId);
-    if (agentId === activeAgentId) {
+    runtimeTokenRef.current = { agentId, token };
+    // Compare against the latest active agent (ref), not the closure-captured
+    // activeAgentId: the user may have switched agents while the fetch was in
+    // flight, and writing a stale agent's token into shared state would point
+    // realtime/channel calls at the wrong agent.
+    if (agentId === activeAgentIdRef.current) {
       setRuntimeAuthToken(token);
     }
     return token;
-  }, [activeAgentId, runtimeAuthToken, superagentService]);
+  }, [superagentService]);
 
   const loadChannels = useCallback(async (agentId: string) => {
     setIsLoadingChannels(true);
@@ -353,6 +367,7 @@ export function useSuperagentRuntime({
     setChannelStatus({});
     setCollaborators([]);
     setConnectingChannelId(null);
+    setConnectingConnectorId(null);
     setConnectedConnectors([]);
     setFilePaths([]);
     setFileLoadError(null);
@@ -406,25 +421,16 @@ export function useSuperagentRuntime({
       return;
     }
 
-    if (event.status === 'success') {
-      flow.cancelled = true;
-      connectorFlowRef.current = null;
-      setConnectingConnectorId(null);
-      await loadConnectors(flow.agentId);
-      return;
-    }
-
-    if (event.status === 'error') {
-      flow.cancelled = true;
-      connectorFlowRef.current = null;
-      setConnectingConnectorId(null);
+    // The callback event carries no connection/connector identifier, so it can't
+    // be reliably attributed to this flow — a late callback from a superseded
+    // connect could otherwise mark the wrong flow. Don't mutate flow state here;
+    // waitForConnectorAuthorization polls the authoritative per-connection status
+    // (it detects ACTIVE/FAILED on its own). Just refresh the connector list so
+    // the UI reflects the latest state.
+    if (event.status === 'success' || event.status === 'error') {
       await loadConnectors(flow.agentId);
-      showAlert(nativeAdapters, 'Connector failed', 'OAuth authorization did not complete. Please try connecting again.');
-      return;
     }
-
-    await loadConnectors(flow.agentId);
-  }, [loadConnectors, nativeAdapters]);
+  }, [loadConnectors]);
 
   useEffect(() => {
     return nativeAdapters.subscribeToExternalAuthCallbacks?.(completePendingConnectorFromCallback);
@@ -562,6 +568,9 @@ export function useSuperagentRuntime({
       )));
     } catch (error) {
       showAlert(nativeAdapters, 'Permissions update failed', getErrorMessage(error));
+      // Rethrow so optimistic callers (the permission toggle) can revert; the
+      // guard-config caller wraps this in try/catch since the alert already fired.
+      throw error;
     }
   }, [nativeAdapters, superagentService]);
 
@@ -634,7 +643,10 @@ export function useSuperagentRuntime({
   }, [config.baseUrl, config.webUrl, nativeAdapters]);
 
   const onCloneAgent = useCallback(({agentId}: SuperagentAgentActionInput) => {
-    nativeAdapters.openWebUrl?.(buildWebUrl(config.webUrl ?? config.baseUrl, `/remix-app/${encodeURIComponent(agentId)}?clone_history=true`));
+    // Use the Superagent clone route — /remix-app is an app route that the web
+    // builder redirects back to /superagent/:id for user_agent apps (reopening the
+    // original instead of cloning). /clone-superagent/:id is the agent clone flow.
+    nativeAdapters.openWebUrl?.(buildWebUrl(config.webUrl ?? config.baseUrl, `/clone-superagent/${encodeURIComponent(agentId)}`));
   }, [config.baseUrl, config.webUrl, nativeAdapters]);
 
   const onDeleteAgent = useCallback(async ({agentId}: SuperagentAgentActionInput) => {
@@ -756,7 +768,10 @@ export function useSuperagentRuntime({
 
       const writtenPaths: string[] = [];
       for (const file of files) {
-        const safePath = sanitizeSandboxFilePath(file.name) || 'upload';
+        const safeName = sanitizeSandboxFilePath(file.name) || 'upload';
+        // Stage uploads under a dedicated folder so a picked file named like a
+        // generated-app file (package.json, README.md, ...) can't overwrite it.
+        const safePath = `incoming_files/${safeName}`;
         await superagentService.writeSandboxFile(agentId, safePath, file.content);
         writtenPaths.push(safePath);
       }
@@ -792,19 +807,31 @@ export function useSuperagentRuntime({
     setConnectingChannelId('whatsapp');
     try {
       const token = await resolveRuntimeToken(agentId);
+      // Editor gate: the connect redirect only authenticates the app-user token and
+      // does not re-check live editor access, so a downgraded viewer could otherwise
+      // open it. /whatsapp/status enforces the two-layer editor check and throws
+      // (403) for viewers — require it to pass before opening the setup page.
+      await superagentService.getWhatsAppStatus(agentId, token);
       const connectUrl = superagentService.getWhatsAppConnectUrl(agentId, token);
-      setChannelStatus((current) => ({
-        ...current,
-        whatsapp: {
-          ...current.whatsapp,
-          connectUrl,
-        },
-      }));
-      await nativeAdapters.openUrl?.(connectUrl);
+      if (activeAgentIdRef.current === agentId) {
+        setChannelStatus((current) => ({
+          ...current,
+          whatsapp: {
+            ...current.whatsapp,
+            connectUrl,
+          },
+        }));
+      }
+      if (!nativeAdapters.openUrl) {
+        // Without a URL opener the setup page never launches; surface an error
+        // instead of completing silently (mirrors the connector OAuth flow).
+        throw new Error('This app cannot open the WhatsApp setup page. Connect WhatsApp from the web app.');
+      }
+      await nativeAdapters.openUrl(connectUrl);
     } catch (error) {
       showAlert(nativeAdapters, 'WhatsApp setup failed', getErrorMessage(error));
     } finally {
-      setConnectingChannelId(null);
+      if (activeAgentIdRef.current === agentId) setConnectingChannelId(null);
     }
   }, [nativeAdapters, resolveRuntimeToken, superagentService]);
 
@@ -813,12 +840,14 @@ export function useSuperagentRuntime({
     try {
       const runtimeToken = await resolveRuntimeToken(agentId);
       const telegram = await superagentService.setupTelegram(agentId, runtimeToken, token);
-      setChannelStatus((current) => ({
-        ...current,
-        telegram,
-      }));
+      if (activeAgentIdRef.current === agentId) {
+        setChannelStatus((current) => ({
+          ...current,
+          telegram,
+        }));
+      }
     } finally {
-      setConnectingChannelId(null);
+      if (activeAgentIdRef.current === agentId) setConnectingChannelId(null);
     }
   }, [resolveRuntimeToken, superagentService]);
 
@@ -837,14 +866,16 @@ export function useSuperagentRuntime({
     try {
       const token = await resolveRuntimeToken(agentId);
       await superagentService.disconnectTelegram(agentId, token);
-      setChannelStatus((current) => ({
-        ...current,
-        telegram: {connected: false},
-      }));
+      if (activeAgentIdRef.current === agentId) {
+        setChannelStatus((current) => ({
+          ...current,
+          telegram: {connected: false},
+        }));
+      }
     } catch (error) {
       showAlert(nativeAdapters, 'Telegram disconnect failed', getErrorMessage(error));
     } finally {
-      setConnectingChannelId(null);
+      if (activeAgentIdRef.current === agentId) setConnectingChannelId(null);
     }
   }, [nativeAdapters, resolveRuntimeToken, superagentService]);
 
@@ -853,18 +884,20 @@ export function useSuperagentRuntime({
     try {
       const token = await resolveRuntimeToken(agentId);
       const activation = await superagentService.generateLineCode(agentId, token);
-      setChannelStatus((current) => ({
-        ...current,
-        line: {
-          ...current.line,
-          activation,
-          connected: false,
-        },
-      }));
+      if (activeAgentIdRef.current === agentId) {
+        setChannelStatus((current) => ({
+          ...current,
+          line: {
+            ...current.line,
+            activation,
+            connected: false,
+          },
+        }));
+      }
     } catch (error) {
       showAlert(nativeAdapters, 'LINE setup failed', getErrorMessage(error));
     } finally {
-      setConnectingChannelId(null);
+      if (activeAgentIdRef.current === agentId) setConnectingChannelId(null);
     }
   }, [nativeAdapters, resolveRuntimeToken, superagentService]);
 
@@ -873,20 +906,22 @@ export function useSuperagentRuntime({
     try {
       const token = await resolveRuntimeToken(agentId);
       const activation = await superagentService.generateIMessageCode(agentId, token);
-      setChannelStatus((current) => ({
-        ...current,
-        imessage: {
-          ...current.imessage,
-          activation,
-          connected: current.imessage?.connected ?? false,
-        },
-      }));
+      if (activeAgentIdRef.current === agentId) {
+        setChannelStatus((current) => ({
+          ...current,
+          imessage: {
+            ...current.imessage,
+            activation,
+            connected: current.imessage?.connected ?? false,
+          },
+        }));
+      }
       return activation;
     } catch (error) {
       showAlert(nativeAdapters, 'iMessage setup failed', getErrorMessage(error));
       throw error;
     } finally {
-      setConnectingChannelId(null);
+      if (activeAgentIdRef.current === agentId) setConnectingChannelId(null);
     }
   }, [nativeAdapters, resolveRuntimeToken, superagentService]);
 
@@ -905,20 +940,25 @@ export function useSuperagentRuntime({
     try {
       const token = await resolveRuntimeToken(agentId);
       const imessage = await superagentService.disconnectIMessage(agentId, token);
-      setChannelStatus((current) => ({
-        ...current,
-        imessage,
-      }));
+      if (activeAgentIdRef.current === agentId) {
+        setChannelStatus((current) => ({
+          ...current,
+          imessage,
+        }));
+      }
     } catch (error) {
       showAlert(nativeAdapters, 'iMessage disconnect failed', getErrorMessage(error));
     } finally {
-      setConnectingChannelId(null);
+      if (activeAgentIdRef.current === agentId) setConnectingChannelId(null);
     }
   }, [nativeAdapters, resolveRuntimeToken, superagentService]);
 
   const onOpenIMessage = useCallback(async ({code, phoneNumber}: SuperagentIMessageCodeShareInput) => {
     try {
-      await nativeAdapters.openUrl?.(buildIMessageUrl(phoneNumber, code));
+      if (!nativeAdapters.openUrl) {
+        throw new Error('This app cannot open Messages. Use the web app to share the iMessage code.');
+      }
+      await nativeAdapters.openUrl(buildIMessageUrl(phoneNumber, code));
     } catch (error) {
       showAlert(nativeAdapters, 'iMessage link unavailable', getErrorMessage(error));
     }
@@ -933,7 +973,11 @@ export function useSuperagentRuntime({
   }, [nativeAdapters]);
 
   const onShareLineCode = useCallback(async ({addFriendUrl, code}: SuperagentLineCodeShareInput) => {
-    await nativeAdapters.share?.({
+    if (!nativeAdapters.share) {
+      showAlert(nativeAdapters, 'Sharing unavailable', 'This app cannot share the activation code. Copy it manually instead.');
+      return;
+    }
+    await nativeAdapters.share({
       message: `LINE activation code: ${code}\n${addFriendUrl}`,
       title: 'LINE activation code',
       url: addFriendUrl,
@@ -941,7 +985,11 @@ export function useSuperagentRuntime({
   }, [nativeAdapters]);
 
   const onShareIMessageCode = useCallback(async ({code, phoneNumber}: SuperagentIMessageCodeShareInput) => {
-    await nativeAdapters.share?.({
+    if (!nativeAdapters.share) {
+      showAlert(nativeAdapters, 'Sharing unavailable', 'This app cannot share the activation code. Copy it manually instead.');
+      return;
+    }
+    await nativeAdapters.share({
       message: `Text ${code} to ${phoneNumber} to connect this Superagent on iMessage.`,
       title: 'iMessage activation code',
       url: buildIMessageUrl(phoneNumber, code),
@@ -976,26 +1024,38 @@ export function useSuperagentRuntime({
         connectorFlowRef.current = null;
         setConnectingConnectorId(null);
         await loadConnectors(agentId);
-        return true;
+        // Return the connection_id (string) so the connector tool-approval can
+        // submit it; fall back to `true` when the backend omits it.
+        return connection.connection_id ?? true;
       }
 
       if (!connection.redirect_url || !connection.connection_id) {
         throw new Error('The backend did not return an authorization URL for this connector.');
       }
 
-      await nativeAdapters.openUrl?.(connection.redirect_url);
-      await waitForConnectorAuthorization(superagentService, agentId, connectorId, connection.connection_id, flow);
+      if (!nativeAdapters.openUrl) {
+        // Without a URL opener the browser never launches, so polling would just
+        // time out after ~2 minutes. Fail immediately with an actionable error.
+        throw new Error('This app cannot open the authorization page. Connect this integration from the web app.');
+      }
+
+      await nativeAdapters.openUrl(connection.redirect_url);
+      const connected = await waitForConnectorAuthorization(superagentService, agentId, connectorId, connection.connection_id, flow);
 
-      if (!flow.cancelled) {
+      // Only clear shared state if this flow is still the active one — a newer
+      // connect may have superseded it (and owns connectorFlowRef now).
+      if (connectorFlowRef.current === flow) {
         connectorFlowRef.current = null;
         setConnectingConnectorId(null);
+      }
+      if (connected) {
         await loadConnectors(agentId);
-        return true;
       }
-
-      return false;
+      // On success return the connection_id so the connector tool-approval can
+      // submit it for backend verification; `false` on failure.
+      return connected ? connection.connection_id : false;
     } catch (error) {
-      if (!flow.cancelled) {
+      if (connectorFlowRef.current === flow) {
         connectorFlowRef.current = null;
         setConnectingConnectorId(null);
         showAlert(nativeAdapters, 'Connector failed', getErrorMessage(error));
@@ -1071,6 +1131,7 @@ export function useSuperagentRuntime({
     // instead of defaulting to the home route.
     initialRoute: currentRoute,
     currentUserAvatarUrl: config.currentUserAvatarUrl,
+    currentUserId: config.currentUserId,
     currentUserName: config.currentUserName,
     fileLoadError,
     fileLoadFailed,
@@ -1143,25 +1204,32 @@ async function waitForConnectorAuthorization(
   connectorId: string,
   connectionId: string,
   flow: ConnectorFlow,
-) {
+): Promise<boolean> {
+  // The connection status (scoped to this flow's connectionId) is the
+  // authoritative source of truth — not a global callback flag, which can't be
+  // attributed to a specific flow. Returns whether the connector ended up ACTIVE.
+  const isActive = async () =>
+    (await superagentService.getConnectorConnectionStatus(agentId, connectorId, connectionId)) === 'ACTIVE';
+
   const maxAttempts = 40;
   for (let attempt = 0; attempt < maxAttempts; attempt++) {
     if (flow.cancelled) {
-      return;
+      // Cancelled — but OAuth may have already completed; confirm with the
+      // authoritative status before reporting not-connected.
+      return isActive().catch(() => false);
     }
 
     await delay(3000);
-    if (flow.cancelled) {
-      return;
-    }
 
     const status = await superagentService.getConnectorConnectionStatus(agentId, connectorId, connectionId);
     if (status === 'ACTIVE') {
-      return;
+      return true;
     }
     if (status === 'FAILED') {
       throw new Error('OAuth connection failed.');
     }
+    // If the user cancelled during the delay, the next iteration's top-of-loop
+    // check re-confirms via the authoritative status before returning.
   }
 
   throw new Error('Connection timed out after 2 minutes.');
@@ -1178,15 +1246,28 @@ async function openAllowedExternalUrl(
     return;
   }
 
+  if (!nativeAdapters.openUrl) {
+    // No URL opener: surface it instead of passing the host check and then
+    // silently doing nothing.
+    showAlert(nativeAdapters, fallbackMessage, 'This app cannot open external links. Use the web app instead.');
+    return;
+  }
+
   try {
-    await nativeAdapters.openUrl?.(url);
+    await nativeAdapters.openUrl(url);
   } catch (error) {
     showAlert(nativeAdapters, fallbackMessage, getErrorMessage(error));
   }
 }
 
 function showAlert(nativeAdapters: SuperagentNativeRuntimeAdapters, title: string, message?: string) {
-  nativeAdapters.alert?.(title, message);
+  if (nativeAdapters.alert) {
+    nativeAdapters.alert(title, message);
+    return;
+  }
+  // No host alert adapter — fall back to React Native's Alert (as confirmAction
+  // does) so connector/channel/file/model errors aren't silently swallowed.
+  Alert.alert(title, message);
 }
 
 async function confirmAction(