@base44/superagent-native 0.0.1 → 0.0.2

package/src/useSuperagentRuntime.ts

@@ -1,6 +1,7 @@
 import {useCallback, useEffect, useMemo, useRef, useState} from 'react';
+import { Alert } from 'react-native';
 import { createSuperagentNativeClient } from './apiClient';
-import { DEFAULT_SANDBOX_FILE_PATHS, normalizeFilePaths } from './fileTreeUtils';
+import { DEFAULT_SANDBOX_FILE_PATHS, normalizeFilePaths, sanitizeSandboxFilePath } from './fileTreeUtils';
 import {
   createSuperagentSocketClient,
   type SuperagentSocketLike,
@@ -146,6 +147,10 @@ export function useSuperagentRuntime({
   }), [config.baseUrl, config.currentUserId, config.getAccessToken, config.getHeaders]);
   const [agents, setAgents] = useState<SuperagentAgent[]>([]);
   const [activeAgentId, setActiveAgentId] = useState<string | null>(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<SuperagentRoute>(
     initialAgentId ? {name: 'agent', agentId: initialAgentId} : {name: 'home'},
   );
@@ -209,13 +214,15 @@ 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]);
 
@@ -223,19 +230,23 @@ export function useSuperagentRuntime({
     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: string) => {
     try {
       const loadedCredits = await superagentService.listAutomationCredits(agentId);
+      if (activeAgentIdRef.current !== agentId) return;
       setAutomationCredits(loadedCredits);
     } catch {
+      if (activeAgentIdRef.current !== agentId) return;
       setAutomationCredits({});
     }
   }, [superagentService]);
@@ -244,16 +255,18 @@ 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]);
 
@@ -261,11 +274,13 @@ export function useSuperagentRuntime({
     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]);
 
@@ -273,11 +288,13 @@ export function useSuperagentRuntime({
     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]);
 
@@ -298,6 +315,7 @@ export function useSuperagentRuntime({
     try {
       const token = await resolveRuntimeToken(agentId);
       const status = await superagentService.getChannelStatus(agentId, token);
+      if (activeAgentIdRef.current !== agentId) return;
       setChannelStatus((current) => ({
         ...status,
         imessage: {
@@ -310,9 +328,10 @@ export function useSuperagentRuntime({
         },
       }));
     } catch {
+      if (activeAgentIdRef.current !== agentId) return;
       setChannelStatus({});
     } finally {
-      setIsLoadingChannels(false);
+      if (activeAgentIdRef.current === agentId) setIsLoadingChannels(false);
     }
   }, [resolveRuntimeToken, superagentService]);
 
@@ -324,16 +343,23 @@ export function useSuperagentRuntime({
   }, [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);
+    setConnectedConnectors([]);
+    setFilePaths([]);
+    setFileLoadError(null);
+    setFileLoadFailed(false);
+    setSecrets([]);
+
     if (!activeAgentId) {
-      setAvailableConnectors([]);
-      setAutomationCredits({});
-      setAutomations([]);
-      setChannelStatus({});
-      setCollaborators([]);
-      setConnectingChannelId(null);
-      setConnectedConnectors([]);
-      setFilePaths([]);
-      setSecrets([]);
       return;
     }
 
@@ -545,6 +571,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]);
 
@@ -705,12 +734,12 @@ export function useSuperagentRuntime({
   }, [config.baseUrl, config.webUrl, nativeAdapters]);
 
   const onOpenSandboxFile = useCallback(async ({agentId, path}: SuperagentSandboxFileActionInput) => {
-    return superagentService.readSandboxFile(agentId, path);
+    return superagentService.readSandboxFile(agentId, sanitizeSandboxFilePath(path));
   }, [superagentService]);
 
   const onSaveSandboxFile = useCallback(async ({agentId, content, path}: SuperagentSandboxFileSaveInput) => {
     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));
@@ -725,11 +754,14 @@ export function useSuperagentRuntime({
         return [];
       }
 
+      const writtenPaths: string[] = [];
       for (const file of files) {
-        await superagentService.writeSandboxFile(agentId, file.name, file.content);
+        const safePath = sanitizeSandboxFilePath(file.name) || 'upload';
+        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)) {
         return [];
@@ -1022,6 +1054,7 @@ export function useSuperagentRuntime({
   }, [loadConnectors, nativeAdapters, superagentService]);
 
   return {
+    activeAgentId,
     agents,
     apiClient,
     availableConnectors,
@@ -1033,6 +1066,10 @@ 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,
     currentUserName: config.currentUserName,
     fileLoadError,
@@ -1086,7 +1123,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,
@@ -1153,11 +1193,27 @@ async function confirmAction(
   nativeAdapters: SuperagentNativeRuntimeAdapters,
   input: Parameters<NonNullable<SuperagentNativeRuntimeAdapters['confirm']>>[0],
 ) {
-  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<boolean>((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: string, path: string) {