@brainfish-ai/devdoc 0.1.42 → 0.1.44

package/renderer/lib/api-docs/auth/auth-context.js

@@ -0,0 +1,157 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useState, useEffect, useCallback, useRef } from 'react';
+import { authStorage, fetchDeviceId } from './auth-storage';
+const AuthContext = /*#__PURE__*/ createContext(null);
+const DEFAULT_AUTH = {
+    authType: 'none',
+    authActive: true
+};
+export function AuthProvider({ children }) {
+    const [globalAuth, setGlobalAuthState] = useState(null);
+    const [isInitialized, setIsInitialized] = useState(false);
+    const [specSchemes, setSpecSchemes] = useState([]);
+    const [specDefaultAuth, setSpecDefaultAuth] = useState(null);
+    const deviceIdRef = useRef(null);
+    // Load auth from localStorage on mount (async with encryption)
+    useEffect(()=>{
+        async function initializeAuth() {
+            try {
+                // Fetch device ID from backend (required for encryption)
+                const deviceId = await fetchDeviceId();
+                deviceIdRef.current = deviceId;
+                // Load encrypted auth from storage
+                const stored = await authStorage.load(deviceId);
+                if (stored) {
+                    setGlobalAuthState(stored);
+                }
+                // Fetch security schemes from the spec
+                const schemesResponse = await fetch('/api/auth-schemes');
+                if (schemesResponse.ok) {
+                    const data = await schemesResponse.json();
+                    setSpecSchemes(data.schemes || []);
+                    setSpecDefaultAuth(data.defaultAuth || null);
+                }
+            } catch (error) {
+                console.error('[AuthProvider] Failed to initialize auth:', error);
+                // Clear any potentially corrupted data
+                authStorage.clear();
+            } finally{
+                setIsInitialized(true);
+            }
+        }
+        initializeAuth();
+    }, []);
+    const setGlobalAuth = useCallback(async (auth)=>{
+        if (!deviceIdRef.current) {
+            console.error('[AuthProvider] Cannot save auth: no device ID');
+            return;
+        }
+        setGlobalAuthState(auth);
+        await authStorage.save(auth, deviceIdRef.current);
+    }, []);
+    const clearAuth = useCallback(()=>{
+        setGlobalAuthState(null);
+        authStorage.clear();
+    }, []);
+    /**
+   * Get effective auth for an endpoint
+   * - If endpoint has 'inherit' auth type, use global auth
+   * - If endpoint has 'none' auth type and global is set, use global
+   * - Otherwise use endpoint's own auth
+   */ const getEffectiveAuth = useCallback((endpointAuth)=>{
+        // If endpoint explicitly wants to inherit, use global
+        if (endpointAuth.authType === 'inherit') {
+            return globalAuth || DEFAULT_AUTH;
+        }
+        // If endpoint has no auth but global is configured, suggest global
+        // but don't override - this allows explicit "no auth" endpoints
+        if (endpointAuth.authType === 'none' && globalAuth && globalAuth.authType !== 'none') {
+            // Return global auth but the UI should indicate it's using global
+            return globalAuth;
+        }
+        // Use endpoint's own auth
+        return endpointAuth;
+    }, [
+        globalAuth
+    ]);
+    /**
+   * Check if an endpoint is using global auth
+   */ const isUsingGlobalAuth = useCallback((endpointAuth)=>{
+        if (!globalAuth || globalAuth.authType === 'none') {
+            return false;
+        }
+        // Using global if inheriting or if endpoint has no auth
+        return endpointAuth.authType === 'inherit' || endpointAuth.authType === 'none';
+    }, [
+        globalAuth
+    ]);
+    const isAuthenticated = globalAuth !== null && globalAuth.authType !== 'none';
+    const value = {
+        globalAuth,
+        isAuthenticated,
+        setGlobalAuth,
+        clearAuth,
+        getEffectiveAuth,
+        isUsingGlobalAuth,
+        specSchemes,
+        specDefaultAuth
+    };
+    // Don't render until we've checked sessionStorage
+    if (!isInitialized) {
+        return null;
+    }
+    return /*#__PURE__*/ _jsx(AuthContext.Provider, {
+        value: value,
+        children: children
+    });
+}
+export function useAuth() {
+    const context = useContext(AuthContext);
+    if (!context) {
+        throw new Error('useAuth must be used within an AuthProvider');
+    }
+    return context;
+}
+/**
+ * Get a human-readable label for auth type
+ */ export function getAuthTypeLabel(auth) {
+    if (!auth || !auth.authType) {
+        return 'Not configured';
+    }
+    switch(auth.authType){
+        case 'none':
+            return 'No Auth';
+        case 'inherit':
+            return 'Inherited';
+        case 'basic':
+            return 'Basic Auth';
+        case 'bearer':
+            return 'Bearer Token';
+        case 'api-key':
+            return `API Key (${auth.key || 'key'})`;
+        case 'oauth-2':
+            return 'OAuth 2.0';
+        default:
+            return 'Not configured';
+    }
+}
+/**
+ * Get a masked preview of auth value
+ */ export function getAuthPreview(auth) {
+    switch(auth.authType){
+        case 'none':
+        case 'inherit':
+            return '';
+        case 'basic':
+            return auth.username ? `${auth.username}:****` : '';
+        case 'bearer':
+            return auth.token ? `${auth.token.slice(0, 8)}••••` : '';
+        case 'api-key':
+            return auth.value ? `${auth.value.slice(0, 4)}••••` : '';
+        case 'oauth-2':
+            return auth.grantTypeInfo.token ? `${auth.grantTypeInfo.token.slice(0, 8)}••••` : '';
+        default:
+            return '';
+    }
+}

package/renderer/lib/api-docs/auth/auth-storage.js

@@ -0,0 +1,66 @@
+'use client';
+import { encrypt, decrypt } from './crypto';
+const AUTH_STORAGE_KEY = 'brainfish-api-global-auth';
+/**
+ * Fetch device ID from backend API
+ * The device ID is stored in an httpOnly cookie
+ * Throws error if device ID cannot be fetched (no fallback)
+ */ export async function fetchDeviceId() {
+    const response = await fetch('/api/device', {
+        credentials: 'include'
+    });
+    if (!response.ok) {
+        throw new Error('Failed to fetch device ID');
+    }
+    const data = await response.json();
+    if (!data.deviceId) {
+        throw new Error('No device ID returned from server');
+    }
+    return data.deviceId;
+}
+/**
+ * Encrypted localStorage wrapper for global authentication
+ * Uses device ID from backend as encryption key
+ * No fallbacks - encryption is required
+ */ export const authStorage = {
+    /**
+   * Save auth configuration to localStorage (encrypted)
+   * Requires valid device ID - throws if missing
+   */ async save (auth, deviceId) {
+        if (!deviceId) {
+            throw new Error('Device ID required for secure storage');
+        }
+        const data = {
+            globalAuth: auth,
+            timestamp: Date.now()
+        };
+        const encrypted = await encrypt(JSON.stringify(data), deviceId);
+        localStorage.setItem(AUTH_STORAGE_KEY, encrypted);
+    },
+    /**
+   * Load auth configuration from localStorage (decrypted)
+   * Returns null if no data or decryption fails
+   */ async load (deviceId) {
+        if (!deviceId) return null;
+        const stored = localStorage.getItem(AUTH_STORAGE_KEY);
+        if (!stored) return null;
+        try {
+            const jsonData = await decrypt(stored, deviceId);
+            const data = JSON.parse(jsonData);
+            if (!data.globalAuth?.authType) {
+                localStorage.removeItem(AUTH_STORAGE_KEY);
+                return null;
+            }
+            return data.globalAuth;
+        } catch  {
+            // Decryption failed - clear corrupted/invalid data
+            localStorage.removeItem(AUTH_STORAGE_KEY);
+            return null;
+        }
+    },
+    /**
+   * Clear stored auth configuration
+   */ clear () {
+        localStorage.removeItem(AUTH_STORAGE_KEY);
+    }
+};

package/renderer/lib/api-docs/auth/crypto.js

@@ -0,0 +1,64 @@
+'use client';
+/**
+ * Web Crypto API utilities for encrypting/decrypting auth credentials
+ * Uses AES-GCM with a key derived from device ID
+ */ const ALGORITHM = 'AES-GCM';
+const KEY_LENGTH = 256;
+const IV_LENGTH = 12 // 96 bits for AES-GCM
+;
+/**
+ * Derive a crypto key from a device ID using PBKDF2
+ */ async function deriveKey(deviceId) {
+    const encoder = new TextEncoder();
+    const keyMaterial = await crypto.subtle.importKey('raw', encoder.encode(deviceId), 'PBKDF2', false, [
+        'deriveKey'
+    ]);
+    // Use a fixed salt (could be made dynamic per-user if needed)
+    const salt = encoder.encode('brainfish-api-docs-v1');
+    return crypto.subtle.deriveKey({
+        name: 'PBKDF2',
+        salt,
+        iterations: 100000,
+        hash: 'SHA-256'
+    }, keyMaterial, {
+        name: ALGORITHM,
+        length: KEY_LENGTH
+    }, false, [
+        'encrypt',
+        'decrypt'
+    ]);
+}
+/**
+ * Encrypt a string using AES-GCM with device ID as key
+ */ export async function encrypt(plaintext, deviceId) {
+    const key = await deriveKey(deviceId);
+    const encoder = new TextEncoder();
+    const data = encoder.encode(plaintext);
+    // Generate random IV
+    const iv = crypto.getRandomValues(new Uint8Array(IV_LENGTH));
+    const encrypted = await crypto.subtle.encrypt({
+        name: ALGORITHM,
+        iv
+    }, key, data);
+    // Combine IV + encrypted data and encode as base64
+    const combined = new Uint8Array(iv.length + encrypted.byteLength);
+    combined.set(iv);
+    combined.set(new Uint8Array(encrypted), iv.length);
+    return btoa(String.fromCharCode(...combined));
+}
+/**
+ * Decrypt a string using AES-GCM with device ID as key
+ */ export async function decrypt(ciphertext, deviceId) {
+    const key = await deriveKey(deviceId);
+    // Decode base64
+    const combined = Uint8Array.from(atob(ciphertext), (c)=>c.charCodeAt(0));
+    // Extract IV and encrypted data
+    const iv = combined.slice(0, IV_LENGTH);
+    const encrypted = combined.slice(IV_LENGTH);
+    const decrypted = await crypto.subtle.decrypt({
+        name: ALGORITHM,
+        iv
+    }, key, encrypted);
+    const decoder = new TextDecoder();
+    return decoder.decode(decrypted);
+}

package/renderer/lib/api-docs/auth/index.js

@@ -0,0 +1,3 @@
+export { AuthProvider, useAuth, getAuthTypeLabel, getAuthPreview } from './auth-context';
+export { authStorage, fetchDeviceId } from './auth-storage';
+export { encrypt, decrypt } from './crypto';

package/renderer/lib/api-docs/code-editor/db.js

@@ -0,0 +1,145 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import Dexie from 'dexie';
+/**
+ * Simplified database for Notes workspace
+ * - One workspace per API (not multiple projects)
+ * - Notes are files for brainstorming (code, diagrams, markdown)
+ */ class NotesDatabase extends Dexie {
+    constructor(){
+        super('brainfish-notes'), _define_property(this, "workspaces", void 0), _define_property(this, "notes", void 0), _define_property(this, "editorStates", void 0);
+        this.version(1).stores({
+            // Single workspace per API
+            workspaces: 'id, apiSpecUrl, updatedAt',
+            // Notes/files in workspace
+            notes: 'id, workspaceId, [workspaceId+path], updatedAt',
+            // Editor state per workspace
+            editorStates: 'workspaceId'
+        });
+    }
+}
+// Singleton database instance
+export const db = new NotesDatabase();
+/**
+ * Generate a workspace ID from API spec URL
+ */ export function getWorkspaceId(apiSpecUrl) {
+    // Simple hash for consistent ID
+    let hash = 0;
+    for(let i = 0; i < apiSpecUrl.length; i++){
+        const char = apiSpecUrl.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash = hash & hash; // Convert to 32-bit integer
+    }
+    return `ws-${Math.abs(hash).toString(16)}`;
+}
+/**
+ * Database operations - simplified for notes workspace
+ */ export const dbOperations = {
+    // Workspace operations (auto-created, one per API)
+    async getOrCreateWorkspace (apiSpecUrl, name) {
+        const id = getWorkspaceId(apiSpecUrl);
+        let workspace = await db.workspaces.get(id);
+        if (!workspace) {
+            workspace = {
+                id,
+                name,
+                apiSpecUrl,
+                createdAt: new Date(),
+                updatedAt: new Date()
+            };
+            await db.workspaces.add(workspace);
+        }
+        return workspace;
+    },
+    async getWorkspace (id) {
+        return db.workspaces.get(id);
+    },
+    async updateWorkspace (id, updates) {
+        await db.workspaces.update(id, {
+            ...updates,
+            updatedAt: new Date()
+        });
+    },
+    // Note/file operations
+    async createNote (workspaceId, path, content = '') {
+        const note = {
+            id: crypto.randomUUID(),
+            workspaceId,
+            path,
+            content,
+            createdAt: new Date(),
+            updatedAt: new Date()
+        };
+        await db.notes.add(note);
+        // Update workspace timestamp
+        await db.workspaces.update(workspaceId, {
+            updatedAt: new Date()
+        });
+        return note;
+    },
+    async getNote (workspaceId, path) {
+        return db.notes.where('[workspaceId+path]').equals([
+            workspaceId,
+            path
+        ]).first();
+    },
+    async listNotes (workspaceId) {
+        return db.notes.where('workspaceId').equals(workspaceId).toArray();
+    },
+    async updateNote (workspaceId, path, content) {
+        await db.notes.where('[workspaceId+path]').equals([
+            workspaceId,
+            path
+        ]).modify({
+            content,
+            updatedAt: new Date()
+        });
+        await db.workspaces.update(workspaceId, {
+            updatedAt: new Date()
+        });
+    },
+    async deleteNote (workspaceId, path) {
+        await db.notes.where('[workspaceId+path]').equals([
+            workspaceId,
+            path
+        ]).delete();
+        await db.workspaces.update(workspaceId, {
+            updatedAt: new Date()
+        });
+    },
+    async renameNote (workspaceId, oldPath, newPath) {
+        await db.notes.where('[workspaceId+path]').equals([
+            workspaceId,
+            oldPath
+        ]).modify({
+            path: newPath,
+            updatedAt: new Date()
+        });
+        await db.workspaces.update(workspaceId, {
+            updatedAt: new Date()
+        });
+    },
+    // Editor state operations
+    async getEditorState (workspaceId) {
+        return db.editorStates.get(workspaceId);
+    },
+    async saveEditorState (state) {
+        await db.editorStates.put(state);
+    },
+    // Clear all notes in workspace (reset)
+    async clearWorkspace (workspaceId) {
+        await db.notes.where('workspaceId').equals(workspaceId).delete();
+        await db.editorStates.delete(workspaceId);
+    }
+};

package/renderer/lib/api-docs/code-editor/hooks.js

@@ -0,0 +1,254 @@
+'use client';
+import { useState, useEffect, useCallback } from 'react';
+import { dbOperations } from './db';
+/**
+ * Hook for managing the workspace (auto-created per API)
+ */ export function useWorkspace(apiSpecUrl, apiName = 'API Notes') {
+    const [workspace, setWorkspace] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    useEffect(()=>{
+        if (!apiSpecUrl) {
+            setWorkspace(null);
+            setLoading(false);
+            return;
+        }
+        const loadWorkspace = async ()=>{
+            try {
+                setLoading(true);
+                const ws = await dbOperations.getOrCreateWorkspace(apiSpecUrl, `${apiName} Notes`);
+                setWorkspace(ws);
+                setError(null);
+            } catch (err) {
+                setError(err instanceof Error ? err : new Error('Failed to load workspace'));
+            } finally{
+                setLoading(false);
+            }
+        };
+        loadWorkspace();
+    }, [
+        apiSpecUrl,
+        apiName
+    ]);
+    const clearWorkspace = useCallback(async ()=>{
+        if (!workspace) return;
+        await dbOperations.clearWorkspace(workspace.id);
+    }, [
+        workspace
+    ]);
+    return {
+        workspace,
+        loading,
+        error,
+        clearWorkspace,
+        workspaceId: workspace?.id || null
+    };
+}
+/**
+ * Hook for managing notes/files in the workspace
+ */ export function useNotes(workspaceId) {
+    const [notes, setNotes] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const loadNotes = useCallback(async ()=>{
+        if (!workspaceId) {
+            setNotes([]);
+            setLoading(false);
+            return;
+        }
+        try {
+            setLoading(true);
+            const list = await dbOperations.listNotes(workspaceId);
+            setNotes(list);
+            setError(null);
+        } catch (err) {
+            setError(err instanceof Error ? err : new Error('Failed to load notes'));
+        } finally{
+            setLoading(false);
+        }
+    }, [
+        workspaceId
+    ]);
+    useEffect(()=>{
+        loadNotes();
+    }, [
+        loadNotes
+    ]);
+    const createNote = useCallback(async (path, content = '')=>{
+        if (!workspaceId) return null;
+        const note = await dbOperations.createNote(workspaceId, path, content);
+        setNotes((prev)=>[
+                ...prev,
+                note
+            ]);
+        return note;
+    }, [
+        workspaceId
+    ]);
+    const readNote = useCallback(async (path)=>{
+        if (!workspaceId) return '';
+        const note = await dbOperations.getNote(workspaceId, path);
+        return note?.content || '';
+    }, [
+        workspaceId
+    ]);
+    const updateNote = useCallback(async (path, content)=>{
+        if (!workspaceId) return;
+        await dbOperations.updateNote(workspaceId, path, content);
+        setNotes((prev)=>prev.map((n)=>n.path === path ? {
+                    ...n,
+                    content,
+                    updatedAt: new Date()
+                } : n));
+    }, [
+        workspaceId
+    ]);
+    const deleteNote = useCallback(async (path)=>{
+        if (!workspaceId) return;
+        await dbOperations.deleteNote(workspaceId, path);
+        setNotes((prev)=>prev.filter((n)=>n.path !== path));
+    }, [
+        workspaceId
+    ]);
+    const renameNote = useCallback(async (oldPath, newPath)=>{
+        if (!workspaceId) return;
+        await dbOperations.renameNote(workspaceId, oldPath, newPath);
+        setNotes((prev)=>prev.map((n)=>n.path === oldPath ? {
+                    ...n,
+                    path: newPath,
+                    updatedAt: new Date()
+                } : n));
+    }, [
+        workspaceId
+    ]);
+    const deleteAllNotes = useCallback(async ()=>{
+        if (!workspaceId) return;
+        await dbOperations.clearWorkspace(workspaceId);
+        setNotes([]);
+    }, [
+        workspaceId
+    ]);
+    return {
+        notes,
+        loading,
+        error,
+        createNote,
+        readNote,
+        updateNote,
+        deleteNote,
+        deleteAllNotes,
+        renameNote,
+        refresh: loadNotes
+    };
+}
+/**
+ * Hook for managing editor state (tabs, active file, etc.)
+ */ export function useEditorState(workspaceId) {
+    const [state, setState] = useState(null);
+    // Load saved state
+    useEffect(()=>{
+        if (!workspaceId) {
+            setState(null);
+            return;
+        }
+        const loadState = async ()=>{
+            const saved = await dbOperations.getEditorState(workspaceId);
+            if (saved) {
+                setState(saved);
+            } else {
+                // Initialize new state
+                setState({
+                    workspaceId,
+                    openTabs: [],
+                    activeTab: null,
+                    cursorPositions: {},
+                    scrollPositions: {}
+                });
+            }
+        };
+        loadState();
+    }, [
+        workspaceId
+    ]);
+    // Save state when it changes
+    useEffect(()=>{
+        if (state && workspaceId) {
+            dbOperations.saveEditorState(state);
+        }
+    }, [
+        state,
+        workspaceId
+    ]);
+    const openTab = useCallback(async (path)=>{
+        setState((prev)=>{
+            if (!prev) return prev;
+            const newTabs = prev.openTabs.includes(path) ? prev.openTabs : [
+                ...prev.openTabs,
+                path
+            ];
+            return {
+                ...prev,
+                openTabs: newTabs,
+                activeTab: path
+            };
+        });
+    }, []);
+    const closeTab = useCallback((path)=>{
+        setState((prev)=>{
+            if (!prev) return prev;
+            const newTabs = prev.openTabs.filter((t)=>t !== path);
+            const newActive = prev.activeTab === path ? newTabs[newTabs.length - 1] || null : prev.activeTab;
+            return {
+                ...prev,
+                openTabs: newTabs,
+                activeTab: newActive
+            };
+        });
+    }, []);
+    const setActiveTab = useCallback((path)=>{
+        setState((prev)=>{
+            if (!prev) return prev;
+            return {
+                ...prev,
+                activeTab: path
+            };
+        });
+    }, []);
+    const saveCursorPosition = useCallback((path, line, column)=>{
+        setState((prev)=>{
+            if (!prev) return prev;
+            return {
+                ...prev,
+                cursorPositions: {
+                    ...prev.cursorPositions,
+                    [path]: {
+                        line,
+                        column
+                    }
+                }
+            };
+        });
+    }, []);
+    const clearAllTabs = useCallback(()=>{
+        setState((prev)=>{
+            if (!prev) return prev;
+            return {
+                ...prev,
+                openTabs: [],
+                activeTab: null,
+                cursorPositions: {},
+                scrollPositions: {}
+            };
+        });
+    }, []);
+    return {
+        state,
+        openTab,
+        closeTab,
+        setActiveTab,
+        saveCursorPosition,
+        clearAllTabs
+    };
+}
+export { getFileType, getMonacoLanguage, supportsPreview } from './types';
+export { getWorkspaceId } from './db';

package/renderer/lib/api-docs/code-editor/{index.ts → index.js}

@@ -1,6 +1,5 @@
 // Notes workspace - simplified code editor for brainstorming
 // Not for building apps, just for organizing ideas around APIs
-
-export * from './types'
-export * from './hooks'
-export { useModeContext, ModeProvider } from './mode-context'
+export * from './types';
+export * from './hooks';
+export { useModeContext, ModeProvider } from './mode-context';