@base44/superagent-native 0.0.1 → 0.0.3

package/lib/module/useSuperagentRuntime.js

@@ -1,8 +1,9 @@
 "use strict";
 
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { Alert } from 'react-native';
 import { createSuperagentNativeClient } from "./apiClient.js";
-import { DEFAULT_SANDBOX_FILE_PATHS, normalizeFilePaths } from "./fileTreeUtils.js";
+import { DEFAULT_SANDBOX_FILE_PATHS, normalizeFilePaths, sanitizeSandboxFilePath } from "./fileTreeUtils.js";
 import { createSuperagentSocketClient } from "./realtimeClient.js";
 import { createSuperagentApiClient } from "./superagentApiClient.js";
 export function useSuperagentRuntime({
@@ -18,6 +19,10 @@ export function useSuperagentRuntime({
   }), [config.baseUrl, config.currentUserId, config.getAccessToken, config.getHeaders]);
   const [agents, setAgents] = useState([]);
   const [activeAgentId, setActiveAgentId] = useState(initialAgentId ?? null);
+  // Always-latest active agent id, so a slow load for a previous agent can detect
+  // that the user has since switched and skip applying its (now stale) result.
+  const activeAgentIdRef = useRef(activeAgentId);
+  activeAgentIdRef.current = activeAgentId;
   const [currentRoute, setCurrentRoute] = useState(initialAgentId ? {
     name: 'agent',
     agentId: initialAgentId
@@ -44,6 +49,11 @@ export function useSuperagentRuntime({
   const [isLoading, setIsLoading] = useState(true);
   const [loadError, setLoadError] = useState(null);
   const [runtimeAuthToken, setRuntimeAuthToken] = useState(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(null);
   const [realtimeClient, setRealtimeClient] = useState();
   const [secrets, setSecrets] = useState([]);
   const connectorFlowRef = useRef(null);
@@ -78,31 +88,37 @@ export function useSuperagentRuntime({
     setIsLoadingConnectors(true);
     try {
       const connectors = await superagentService.listConnectors(agentId);
+      if (activeAgentIdRef.current !== agentId) return;
       setAvailableConnectors(connectors.availableConnectors);
       setConnectedConnectors(connectors.connectedConnectors);
     } catch {
+      if (activeAgentIdRef.current !== agentId) return;
       setAvailableConnectors([]);
       setConnectedConnectors([]);
     } finally {
-      setIsLoadingConnectors(false);
+      if (activeAgentIdRef.current === agentId) setIsLoadingConnectors(false);
     }
   }, [superagentService]);
   const loadAutomations = useCallback(async agentId => {
     setIsLoadingAutomations(true);
     try {
       const loadedAutomations = await superagentService.listAutomations(agentId);
+      if (activeAgentIdRef.current !== agentId) return;
       setAutomations(loadedAutomations);
     } catch {
+      if (activeAgentIdRef.current !== agentId) return;
       setAutomations([]);
     } finally {
-      setIsLoadingAutomations(false);
+      if (activeAgentIdRef.current === agentId) setIsLoadingAutomations(false);
     }
   }, [superagentService]);
   const loadAutomationCredits = useCallback(async agentId => {
     try {
       const loadedCredits = await superagentService.listAutomationCredits(agentId);
+      if (activeAgentIdRef.current !== agentId) return;
       setAutomationCredits(loadedCredits);
     } catch {
+      if (activeAgentIdRef.current !== agentId) return;
       setAutomationCredits({});
     }
   }, [superagentService]);
@@ -110,55 +126,74 @@ export function useSuperagentRuntime({
     setIsLoadingFiles(true);
     try {
       const loadedFilePaths = await superagentService.listSandboxFiles(agentId);
+      if (activeAgentIdRef.current !== agentId) return;
       const normalizedFilePaths = normalizeFilePaths(loadedFilePaths);
       setFilePaths(normalizedFilePaths.length > 0 ? normalizedFilePaths : DEFAULT_SANDBOX_FILE_PATHS);
       setFileLoadError(null);
       setFileLoadFailed(false);
     } catch (error) {
+      if (activeAgentIdRef.current !== agentId) return;
       setFilePaths(DEFAULT_SANDBOX_FILE_PATHS);
       setFileLoadError(getErrorMessage(error));
       setFileLoadFailed(true);
     } finally {
-      setIsLoadingFiles(false);
+      if (activeAgentIdRef.current === agentId) setIsLoadingFiles(false);
     }
   }, [superagentService]);
   const loadAgentSettings = useCallback(async agentId => {
     setIsLoadingAgentSettings(true);
     try {
       const loadedSecrets = await superagentService.listSecrets(agentId);
+      if (activeAgentIdRef.current !== agentId) return;
       setSecrets(loadedSecrets);
     } catch {
+      if (activeAgentIdRef.current !== agentId) return;
       setSecrets([]);
     } finally {
-      setIsLoadingAgentSettings(false);
+      if (activeAgentIdRef.current === agentId) setIsLoadingAgentSettings(false);
     }
   }, [superagentService]);
   const loadCollaborators = useCallback(async agentId => {
     setIsLoadingCollaborators(true);
     try {
       const loadedCollaborators = await superagentService.listCollaborators(agentId);
+      if (activeAgentIdRef.current !== agentId) return;
       setCollaborators(loadedCollaborators);
     } catch {
+      if (activeAgentIdRef.current !== agentId) return;
       setCollaborators([]);
     } finally {
-      setIsLoadingCollaborators(false);
+      if (activeAgentIdRef.current === agentId) setIsLoadingCollaborators(false);
     }
   }, [superagentService]);
   const resolveRuntimeToken = useCallback(async agentId => {
-    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 => {
     setIsLoadingChannels(true);
     try {
       const token = await resolveRuntimeToken(agentId);
       const status = await superagentService.getChannelStatus(agentId, token);
+      if (activeAgentIdRef.current !== agentId) return;
       setChannelStatus(current => ({
         ...status,
         imessage: {
@@ -171,25 +206,33 @@ export function useSuperagentRuntime({
         }
       }));
     } catch {
+      if (activeAgentIdRef.current !== agentId) return;
       setChannelStatus({});
     } finally {
-      setIsLoadingChannels(false);
+      if (activeAgentIdRef.current === agentId) setIsLoadingChannels(false);
     }
   }, [resolveRuntimeToken, superagentService]);
   const refreshAutomations = useCallback(async agentId => {
     await Promise.all([loadAutomations(agentId), loadAutomationCredits(agentId)]);
   }, [loadAutomationCredits, loadAutomations]);
   useEffect(() => {
+    // Reset per-agent state on every active-agent change (not just when it goes
+    // null) so the drawer never shows the previous agent's secrets/connectors/
+    // files/collaborators/automations during the new agent's load window — which
+    // could otherwise let a destructive action target the wrong agent.
+    setAvailableConnectors([]);
+    setAutomationCredits({});
+    setAutomations([]);
+    setChannelStatus({});
+    setCollaborators([]);
+    setConnectingChannelId(null);
+    setConnectingConnectorId(null);
+    setConnectedConnectors([]);
+    setFilePaths([]);
+    setFileLoadError(null);
+    setFileLoadFailed(false);
+    setSecrets([]);
     if (!activeAgentId) {
-      setAvailableConnectors([]);
-      setAutomationCredits({});
-      setAutomations([]);
-      setChannelStatus({});
-      setCollaborators([]);
-      setConnectingChannelId(null);
-      setConnectedConnectors([]);
-      setFilePaths([]);
-      setSecrets([]);
       return;
     }
     loadAgentSettings(activeAgentId);
@@ -227,23 +270,17 @@ export function useSuperagentRuntime({
     if (!flow || flow.cancelled) {
       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);
   }, [completePendingConnectorFromCallback, nativeAdapters]);
@@ -370,6 +407,9 @@ export function useSuperagentRuntime({
       } : agent));
     } 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]);
   const onSaveSecret = useCallback(async ({
@@ -382,6 +422,9 @@ export function useSuperagentRuntime({
       await loadAgentSettings(agentId);
     } catch (error) {
       showAlert(nativeAdapters, 'Secret save failed', getErrorMessage(error));
+      // Rethrow so the form keeps the user's input instead of clearing on a
+      // failed save.
+      throw error;
     }
   }, [loadAgentSettings, nativeAdapters, superagentService]);
   const onDeleteSecret = useCallback(async ({
@@ -444,7 +487,10 @@ export function useSuperagentRuntime({
   const onCloneAgent = useCallback(({
     agentId
   }) => {
-    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
@@ -567,7 +613,7 @@ export function useSuperagentRuntime({
     agentId,
     path
   }) => {
-    return superagentService.readSandboxFile(agentId, path);
+    return superagentService.readSandboxFile(agentId, sanitizeSandboxFilePath(path));
   }, [superagentService]);
   const onSaveSandboxFile = useCallback(async ({
     agentId,
@@ -575,7 +621,7 @@ export function useSuperagentRuntime({
     path
   }) => {
     try {
-      await superagentService.writeSandboxFile(agentId, path, content);
+      await superagentService.writeSandboxFile(agentId, sanitizeSandboxFilePath(path), content);
       await loadFiles(agentId);
     } catch (error) {
       showAlert(nativeAdapters, 'Save failed', getErrorMessage(error));
@@ -590,12 +636,18 @@ export function useSuperagentRuntime({
       if (!files?.length) {
         return [];
       }
+      const writtenPaths = [];
       for (const file of files) {
-        await superagentService.writeSandboxFile(agentId, file.name, file.content);
+        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);
       }
       await loadFiles(agentId);
-      return files.map(file => ({
-        path: file.name
+      return writtenPaths.map(path => ({
+        path
       }));
     } catch (error) {
       if (nativeAdapters.isAttachmentPickerCancel?.(error)) {
@@ -625,19 +677,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]);
   const onSetupTelegram = useCallback(async ({
@@ -648,12 +712,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]);
   const onDisconnectTelegram = useCallback(async ({
@@ -672,16 +738,18 @@ 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]);
   const onGenerateLineCode = useCallback(async ({
@@ -691,18 +759,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]);
   const onGenerateIMessageCode = useCallback(async ({
@@ -712,20 +782,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]);
   const onDisconnectIMessage = useCallback(async ({
@@ -744,14 +816,16 @@ 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 ({
@@ -759,7 +833,10 @@ export function useSuperagentRuntime({
     phoneNumber
   }) => {
     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));
     }
@@ -778,7 +855,11 @@ export function useSuperagentRuntime({
     addFriendUrl,
     code
   }) => {
-    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
@@ -788,7 +869,11 @@ export function useSuperagentRuntime({
     code,
     phoneNumber
   }) => {
-    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)
@@ -824,22 +909,35 @@ 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 (!flow.cancelled) {
+      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);
+
+      // 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));
@@ -901,6 +999,7 @@ export function useSuperagentRuntime({
     }
   }, [loadConnectors, nativeAdapters, superagentService]);
   return {
+    activeAgentId,
     agents,
     apiClient,
     availableConnectors,
@@ -912,7 +1011,12 @@ export function useSuperagentRuntime({
     connectingConnectorId,
     connectedConnectors,
     currentRoute,
+    // Also expose as initialRoute, the prop SuperagentHomeScreen actually consumes,
+    // so spreading the runtime opens on the deep-linked agent (initialAgentId)
+    // instead of defaulting to the home route.
+    initialRoute: currentRoute,
     currentUserAvatarUrl: config.currentUserAvatarUrl,
+    currentUserId: config.currentUserId,
     currentUserName: config.currentUserName,
     fileLoadError,
     fileLoadFailed,
@@ -965,7 +1069,10 @@ export function useSuperagentRuntime({
     onShareAgentLink,
     onShareIMessageCode,
     onShareLineCode,
-    onStartLiveVoice,
+    // Only expose Live Voice when the native audio adapter is actually installed;
+    // otherwise the composer would prefer it and fail on tap ("audio callbacks are
+    // not installed") instead of falling back to onStartVoiceInput.
+    onStartLiveVoice: nativeAdapters.liveVoiceAudio?.startAudioCapture ? onStartLiveVoice : undefined,
     onSetupTelegram,
     onToggleAutomation,
     onUpdateAgentModel,
@@ -976,22 +1083,27 @@ export function useSuperagentRuntime({
   };
 }
 async function waitForConnectorAuthorization(superagentService, agentId, connectorId, connectionId, flow) {
+  // 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.');
 }
@@ -1000,20 +1112,48 @@ async function openAllowedExternalUrl(nativeAdapters, url, allowedHosts, fallbac
     showAlert(nativeAdapters, fallbackMessage, 'The backend returned a channel link that cannot be opened safely.');
     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, title, message) {
-  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(nativeAdapters, input) {
-  if (!nativeAdapters.confirm) {
-    return true;
+  if (nativeAdapters.confirm) {
+    return nativeAdapters.confirm(input);
   }
-  return nativeAdapters.confirm(input);
+
+  // No host confirm adapter — fall back to a native prompt so destructive actions
+  // still require explicit confirmation instead of silently proceeding.
+  return new Promise(resolve => {
+    Alert.alert(input.title, input.message, [{
+      onPress: () => resolve(false),
+      style: 'cancel',
+      text: 'Cancel'
+    }, {
+      onPress: () => resolve(true),
+      style: input.destructive ? 'destructive' : 'default',
+      text: input.confirmText ?? 'Confirm'
+    }], {
+      cancelable: true,
+      onDismiss: () => resolve(false)
+    });
+  });
 }
 function buildWebUrl(baseUrl, path) {
   return `${normalizeBaseUrl(baseUrl)}${path.startsWith('/') ? path : `/${path}`}`;