nastech-app 1.0.0

package/sources/hooks/useInboxHasContent.ts

@@ -0,0 +1,19 @@
+import { useUpdates } from './useUpdates';
+import { useFriendRequests, useRequestedFriends, useFeedItems } from '@/sync/storage';
+import { useChangelog } from './useChangelog';
+
+// Hook to check if inbox has content to show
+export function useInboxHasContent(): boolean {
+    const { updateAvailable } = useUpdates();
+    const friendRequests = useFriendRequests();
+    const requestedFriends = useRequestedFriends();
+    const changelog = useChangelog();
+
+    // Show dot if there's any actionable content:
+    // - App updates available
+    // - Incoming friend requests (also shown as badge)
+    // - Outgoing friend requests pending
+    // - Feed items (activity updates)
+    // - Unread changelog entries
+    return updateAvailable || friendRequests.length > 0 || requestedFriends.length > 0 || (changelog.hasUnread === true);
+}

package/sources/hooks/useMultiClick.ts

@@ -0,0 +1,56 @@
+import { useCallback, useRef, useState } from 'react';
+
+interface UseMultiClickOptions {
+    /** Number of clicks required to trigger the callback */
+    requiredClicks: number;
+    /** Timeout in milliseconds to reset the click count (default: 2000) */
+    resetTimeout?: number;
+    /** Optional callback when click count changes */
+    onClickCountChange?: (count: number) => void;
+}
+
+/**
+ * Hook that invokes a callback after N consecutive clicks within a timeout window.
+ * Similar to useCallback but triggers only on the Nth click.
+ * 
+ * @param callback - The function to call when N clicks are reached
+ * @param options - Configuration options
+ * @returns A click handler function to attach to onClick events
+ */
+export function useMultiClick(
+    callback: () => void,
+    options: UseMultiClickOptions
+): () => void {
+    const { requiredClicks, resetTimeout = 2000, onClickCountChange } = options;
+    const [clickCount, setClickCount] = useState(0);
+    const resetTimerRef = useRef<ReturnType<typeof setTimeout> | undefined>(undefined);
+
+    const handleClick = useCallback(() => {
+        // Clear existing timer
+        if (resetTimerRef.current) {
+            clearTimeout(resetTimerRef.current);
+        }
+
+        const newCount = clickCount + 1;
+        setClickCount(newCount);
+        
+        // Notify about click count change
+        onClickCountChange?.(newCount);
+
+        if (newCount >= requiredClicks) {
+            // Trigger the callback
+            callback();
+            // Reset count
+            setClickCount(0);
+            onClickCountChange?.(0);
+        } else {
+            // Set timer to reset count after timeout
+            resetTimerRef.current = setTimeout(() => {
+                setClickCount(0);
+                onClickCountChange?.(0);
+            }, resetTimeout);
+        }
+    }, [callback, clickCount, requiredClicks, resetTimeout, onClickCountChange]);
+
+    return handleClick;
+}

package/sources/hooks/useNasTechAction.ts

@@ -0,0 +1,45 @@
+import * as React from 'react';
+import { Modal } from '@/modal';
+import { NasTechError } from '@/utils/errors';
+
+export function useNasTechAction(action: () => Promise<void>) {
+    const [loading, setLoading] = React.useState(false);
+    const loadingRef = React.useRef(false);
+    const doAction = React.useCallback(() => {
+        if (loadingRef.current) {
+            return;
+        }
+        loadingRef.current = true;
+        setLoading(true);
+        (async () => {
+            try {
+                while (true) {
+                    try {
+                        await action();
+                        break;
+                    } catch (e) {
+                        if (e instanceof NasTechError) {
+                            // if (e.canTryAgain) {
+                            //     Modal.alert('Error', e.message, [{ text: 'Try again' }, { text: 'Cancel', style: 'cancel' }]) 
+                            //         break;
+                            //     }
+                            // } else {
+                            //     await alert('Error', e.message, [{ text: 'OK', style: 'cancel' }]);
+                            //     break;
+                            // }
+                            Modal.alert('Error', e.message, [{ text: 'OK', style: 'cancel' }]);
+                            break;
+                        } else {
+                            Modal.alert('Error', 'Unknown error', [{ text: 'OK', style: 'cancel' }]);
+                            break;
+                        }
+                    }
+                }
+            } finally {
+                loadingRef.current = false;
+                setLoading(false);
+            }
+        })();
+    }, [action]);
+    return [loading, doAction] as const;
+}

package/sources/hooks/useNativeUpdate.ts

@@ -0,0 +1,10 @@
+import { storage } from '@/sync/storage';
+import { useShallow } from 'zustand/react/shallow';
+
+export function useNativeUpdate(): string | null {
+    // Get native update status from global storage
+    const nativeUpdateStatus = storage(useShallow((state) => state.nativeUpdateStatus));
+    
+    // Return the update URL if available, otherwise null
+    return nativeUpdateStatus?.updateUrl || null;
+}

package/sources/hooks/useNavigateToSession.ts

@@ -0,0 +1,20 @@
+import type { Router } from "expo-router"
+import { useRouter } from "expo-router"
+import { storage } from '@/sync/storage';
+import { trackSessionSwitched } from '@/track';
+
+export function navigateToSession(router: Router, sessionId: string) {
+    const session = storage.getState().sessions[sessionId];
+    if (session) {
+        trackSessionSwitched(session);
+    }
+
+    router.push(`/session/${encodeURIComponent(sessionId)}`);
+}
+
+export function useNavigateToSession() {
+    const router = useRouter();
+    return (sessionId: string) => {
+        navigateToSession(router, sessionId);
+    }
+}

package/sources/hooks/useNewSessionDraft.ts

@@ -0,0 +1,70 @@
+/**
+ * Zustand store for new session draft state, backed by MMKV.
+ * Persists the user's last-used configuration (machine, path, agent, model, permissions, etc.)
+ * so the new session screen restores the same defaults on next visit.
+ */
+import { create } from 'zustand';
+import {
+    loadNewSessionDraft,
+    saveNewSessionDraft,
+    type NewSessionDraft,
+    type NewSessionAgentType,
+    type NewSessionSessionType,
+} from '@/sync/persistence';
+import type { PermissionModeKey } from '@/components/PermissionModeSelector';
+
+interface NewSessionDraftState {
+    input: string;
+    selectedMachineId: string | null;
+    selectedPath: string | null;
+    agentType: NewSessionAgentType;
+    permissionMode: PermissionModeKey;
+    modelMode: string;
+    sessionType: NewSessionSessionType;
+    worktreeKey: string | null;
+
+    setInput: (input: string) => void;
+    setMachineId: (id: string | null) => void;
+    setPath: (path: string | null) => void;
+    setAgentType: (agent: NewSessionAgentType) => void;
+    setPermissionMode: (mode: PermissionModeKey) => void;
+    setModelMode: (mode: string) => void;
+    setSessionType: (type: NewSessionSessionType) => void;
+    setWorktreeKey: (key: string | null) => void;
+}
+
+function persist(state: NewSessionDraftState) {
+    saveNewSessionDraft({
+        input: state.input,
+        selectedMachineId: state.selectedMachineId,
+        selectedPath: state.selectedPath,
+        agentType: state.agentType,
+        permissionMode: state.permissionMode,
+        modelMode: state.modelMode,
+        sessionType: state.sessionType,
+        worktreeKey: state.worktreeKey,
+        updatedAt: Date.now(),
+    });
+}
+
+const initial = loadNewSessionDraft();
+
+export const useNewSessionDraft = create<NewSessionDraftState>()((set, get) => ({
+    input: initial?.input ?? '',
+    selectedMachineId: initial?.selectedMachineId ?? null,
+    selectedPath: initial?.selectedPath ?? null,
+    agentType: initial?.agentType ?? 'claude',
+    permissionMode: initial?.permissionMode ?? 'default',
+    modelMode: initial?.modelMode ?? 'default',
+    sessionType: initial?.sessionType ?? 'simple',
+    worktreeKey: initial?.worktreeKey ?? null,
+
+    setInput: (input) => { set({ input }); persist(get()); },
+    setMachineId: (id) => { set({ selectedMachineId: id, selectedPath: null, worktreeKey: null }); persist(get()); },
+    setPath: (path) => { set({ selectedPath: path, worktreeKey: null }); persist(get()); },
+    setAgentType: (agent) => { set({ agentType: agent }); persist(get()); },
+    setPermissionMode: (mode) => { set({ permissionMode: mode }); persist(get()); },
+    setModelMode: (mode) => { set({ modelMode: mode }); persist(get()); },
+    setSessionType: (type) => { set({ sessionType: type }); persist(get()); },
+    setWorktreeKey: (key) => { set({ worktreeKey: key }); persist(get()); },
+}));

package/sources/hooks/usePrefetchFileContents.ts

@@ -0,0 +1,162 @@
+/**
+ * Impression-based prefetch for file contents.
+ *
+ * When the file list is rendered, this hook prefetches file content + diff
+ * for all non-deleted, non-binary files that aren't already in the Zustand
+ * cache. This way, tapping into a file shows content instantly.
+ *
+ * Prefetch runs with limited concurrency (3 at a time) to avoid overloading
+ * the session with too many RPC calls. Deleted and binary files are skipped.
+ */
+
+import * as React from 'react';
+import { sessionReadFile, sessionBash } from '@/sync/ops';
+import { storage } from '@/sync/storage';
+import { resolveSessionFilePath } from '@/utils/sessionFileLinks';
+import type { GitFileStatus, GitStatusFiles } from '@/sync/gitStatusFiles';
+
+const BINARY_EXTENSIONS = new Set([
+    'png', 'jpg', 'jpeg', 'gif', 'bmp', 'svg', 'ico',
+    'mp4', 'avi', 'mov', 'wmv', 'flv', 'webm',
+    'mp3', 'wav', 'flac', 'aac', 'ogg',
+    'pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx',
+    'zip', 'tar', 'gz', 'rar', '7z',
+    'exe', 'dmg', 'deb', 'rpm',
+    'woff', 'woff2', 'ttf', 'otf',
+    'db', 'sqlite', 'sqlite3',
+]);
+
+function isBinaryPath(path: string): boolean {
+    const ext = path.split('.').pop()?.toLowerCase();
+    return ext ? BINARY_EXTENSIONS.has(ext) : false;
+}
+
+function decodeBase64ToBytes(base64: string): Uint8Array {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i += 1) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+
+/**
+ * Prefetch a single file's content + diff into the Zustand cache.
+ * Silently swallows errors — prefetch is best-effort.
+ */
+async function prefetchFile(sessionId: string, sessionPath: string, file: GitFileStatus): Promise<void> {
+    const resolved = resolveSessionFilePath(file.fullPath, sessionPath);
+    const filePath = resolved?.absolutePath ?? file.fullPath;
+    const gitDiffPath = resolved?.withinSessionRoot ? resolved.relativePath : null;
+
+    let diff: string | null = null;
+
+    // Fetch git diff
+    if (gitDiffPath && gitDiffPath !== '.') {
+        try {
+            const diffResponse = await sessionBash(sessionId, {
+                command: `git diff --no-ext-diff -- "${gitDiffPath}"`,
+                cwd: sessionPath,
+                timeout: 5000,
+            });
+            if (diffResponse.success && diffResponse.stdout.trim()) {
+                diff = diffResponse.stdout;
+            }
+        } catch {
+            // Best-effort
+        }
+    }
+
+    // Fetch file content
+    try {
+        const response = await sessionReadFile(sessionId, filePath);
+        if (response.success && response.content) {
+            let rawBytes: Uint8Array;
+            let decodedContent: string;
+            try {
+                rawBytes = decodeBase64ToBytes(response.content);
+                decodedContent = new TextDecoder().decode(rawBytes);
+            } catch {
+                storage.getState().applyFileCache(sessionId, filePath, '', diff, true);
+                return;
+            }
+
+            const hasNullBytes = rawBytes.some((byte) => byte === 0);
+            const nonPrintableCount = decodedContent.split('').filter((char) => {
+                const code = char.charCodeAt(0);
+                return code < 32 && code !== 9 && code !== 10 && code !== 13;
+            }).length;
+            const isBinary = hasNullBytes || (nonPrintableCount / decodedContent.length > 0.1);
+
+            storage.getState().applyFileCache(
+                sessionId,
+                filePath,
+                isBinary ? '' : decodedContent,
+                diff,
+                isBinary,
+            );
+        }
+    } catch {
+        // Best-effort
+    }
+}
+
+const MAX_CONCURRENCY = 3;
+
+export function usePrefetchFileContents(sessionId: string, gitStatusFiles: GitStatusFiles | null) {
+    React.useEffect(() => {
+        if (!gitStatusFiles) return;
+
+        const session = storage.getState().sessions[sessionId];
+        const sessionPathMaybe = session?.metadata?.path;
+        if (!sessionPathMaybe) return;
+        const sessionPath: string = sessionPathMaybe;
+
+        const existingCache = storage.getState().sessionFileCache[sessionId] || {};
+
+        // Collect files that need prefetching: non-deleted, non-binary, not cached
+        const filesToPrefetch: GitFileStatus[] = [];
+        const allFiles = [...gitStatusFiles.stagedFiles, ...gitStatusFiles.unstagedFiles];
+        const seen = new Set<string>();
+
+        for (const file of allFiles) {
+            if (file.status === 'deleted') continue;
+            if (isBinaryPath(file.fullPath)) continue;
+            if (seen.has(file.fullPath)) continue;
+            seen.add(file.fullPath);
+
+            // Check if already cached by resolving the path the same way file.tsx does
+            const resolved = resolveSessionFilePath(file.fullPath, sessionPath);
+            const absolutePath = resolved?.absolutePath ?? file.fullPath;
+            if (existingCache[absolutePath]) continue;
+
+            filesToPrefetch.push(file);
+        }
+
+        if (filesToPrefetch.length === 0) return;
+
+        let cancelled = false;
+
+        // Run prefetch with limited concurrency
+        (async () => {
+            let i = 0;
+            async function next(): Promise<void> {
+                while (!cancelled) {
+                    const idx = i++;
+                    if (idx >= filesToPrefetch.length) return;
+                    await prefetchFile(sessionId, sessionPath, filesToPrefetch[idx]);
+                }
+            }
+
+            const workers = Array.from(
+                { length: Math.min(MAX_CONCURRENCY, filesToPrefetch.length) },
+                () => next(),
+            );
+            await Promise.all(workers);
+        })();
+
+        return () => {
+            cancelled = true;
+        };
+    }, [sessionId, gitStatusFiles]);
+}

package/sources/hooks/useSearch.ts

@@ -0,0 +1,120 @@
+import { useEffect, useRef, useState, useCallback } from 'react';
+
+/**
+ * Production-ready search hook with automatic debouncing, caching, and retry logic.
+ * 
+ * Features:
+ * - Prevents parallel queries by skipping new requests while one is in progress
+ * - Permanent in-memory cache for the lifetime of the component
+ * - Automatic retry on errors with exponential backoff
+ * - 300ms debounce to reduce API calls
+ * - Returns cached results immediately if available
+ * 
+ * @param query - The search query string
+ * @param searchFn - The async function to perform the search
+ * @returns Object with results array and isSearching boolean
+ */
+export function useSearch<T>(
+    query: string,
+    searchFn: (query: string) => Promise<T[]>
+): { results: T[]; isSearching: boolean } {
+    const [results, setResults] = useState<T[]>([]);
+    const [isSearching, setIsSearching] = useState(false);
+    
+    // Permanent cache for search results
+    const cacheRef = useRef<Map<string, T[]>>(new Map());
+    
+    // Ref to prevent parallel queries
+    const isSearchingRef = useRef(false);
+    
+    // Timeout ref for debouncing
+    const timeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+    
+    // Perform the search with retry logic
+    const performSearch = useCallback(async (searchQuery: string) => {
+        // Skip if already searching
+        if (isSearchingRef.current) {
+            return;
+        }
+        
+        // Check cache first
+        const cached = cacheRef.current.get(searchQuery);
+        if (cached) {
+            setResults(cached);
+            return;
+        }
+        
+        // Mark as searching
+        isSearchingRef.current = true;
+        setIsSearching(true);
+        
+        // Retry logic with exponential backoff
+        let retryDelay = 1000; // Start with 1 second
+        
+        while (true) {
+            try {
+                const searchResults = await searchFn(searchQuery);
+                
+                // Cache the results
+                cacheRef.current.set(searchQuery, searchResults);
+                
+                // Update state
+                setResults(searchResults);
+                break; // Success, exit the retry loop
+                
+            } catch (error) {
+                // Wait before retrying
+                await new Promise(resolve => setTimeout(resolve, retryDelay));
+                
+                // Exponential backoff with max delay of 30 seconds
+                retryDelay = Math.min(retryDelay * 2, 30000);
+                
+                // Continue retrying (loop will continue)
+            }
+        }
+        
+        // Mark as not searching
+        isSearchingRef.current = false;
+        setIsSearching(false);
+    }, [searchFn]);
+    
+    // Effect to handle debounced search
+    useEffect(() => {
+        // Clear previous timeout
+        if (timeoutRef.current) {
+            clearTimeout(timeoutRef.current);
+        }
+        
+        // If query is empty, clear results immediately
+        if (!query.trim()) {
+            setResults([]);
+            setIsSearching(false);
+            return;
+        }
+        
+        // Check cache immediately
+        const cached = cacheRef.current.get(query);
+        if (cached) {
+            setResults(cached);
+            setIsSearching(false);
+            return;
+        }
+        
+        // Set searching state immediately for better UX
+        setIsSearching(true);
+        
+        // Debounce the actual search
+        timeoutRef.current = setTimeout(() => {
+            performSearch(query);
+        }, 300); // Hardcoded 300ms debounce
+        
+        // Cleanup
+        return () => {
+            if (timeoutRef.current) {
+                clearTimeout(timeoutRef.current);
+            }
+        };
+    }, [query, performSearch]);
+    
+    return { results, isSearching };
+}