Architecture

blink/
├── electron/              # Main process code
│   ├── main.ts           # App lifecycle & window management
│   └── preload.ts        # IPC bridge (context isolation)
├── src/                  # Renderer process (React app)
│   ├── components/       # React UI components
│   │   ├── Editor/      # Monaco editor integration
│   │   ├── Explorer/    # File tree sidebar
│   │   ├── Terminal/    # xterm.js terminal
│   │   ├── Navbar/      # Top navigation bar
│   │   ├── BottomBar/   # Status bar & diagnostics
│   │   └── Settings/    # Preferences panel
│   ├── views/           # Page-level components
│   ├── utils/           # Helper functions
│   └── App.tsx          # Root component
├── dist/                 # Vite build output (renderer)
├── dist-electron/        # Compiled Electron code (main)
└── package.json         # Dependencies & build scripts

// electron/main.ts:157-173
function createWindow() {
    win = new BrowserWindow({
        width: 1280,
        height: 800,
        minWidth: 900,
        minHeight: 600,
        icon: path.join(process.env.VITE_PUBLIC, "logo.png"),
        webPreferences: {
            preload: path.join(__dirname, "preload.mjs"),
            devTools: !!VITE_DEV_SERVER_URL,
        },
        autoHideMenuBar: true,
        frame: false,
        maximizable: true,
        resizable: true,
    });
}

// src/App.tsx
import { HashRouter } from "react-router-dom"
import Router from "./views/Router"
import { initGA, logPageView } from "./analytics/analytics"

function App() {
    useEffect(() => {
        initGA()
        logPageView()
    }, [])
    
    return (
        <HashRouter>
            <Router />
        </HashRouter>
    )
}

// electron/main.ts:46-110
async function getFolderTree(dirPath: string, recursive: boolean = false) {
    const stats = await fs.stat(dirPath);
    const name = path.basename(dirPath);
    
    if (stats.isDirectory()) {
        const children = await fs.readdir(dirPath);
        let childrenNodes: any[] = [];
        
        if (recursive) {
            // Full tree expansion
            childrenNodes = await Promise.all(
                children
                    .filter(child => !EXCLUDED_DIRS.includes(child))
                    .map(child => getFolderTree(path.join(dirPath, child), true))
            );
        } else {
            // Shallow fetch: just metadata
            childrenNodes = await Promise.all(
                children.map(async (child) => {
                    const childPath = path.join(dirPath, child);
                    const childStats = await fs.stat(childPath);
                    return {
                        name: child,
                        type: childStats.isDirectory() ? 'folder' : 'file',
                        path: childPath,
                        hasChildren: childStats.isDirectory()
                    };
                })
            );
        }
        // Sort: folders first, then alphabetically
        return {
            name,
            type: 'folder',
            path: dirPath,
            children: childrenNodes.sort((a, b) => {
                if (a.type === b.type) return a.name.localeCompare(b.name);
                return a.type === 'folder' ? -1 : 1;
            })
        };
    }
}

const EXCLUDED_DIRS = ['.git', 'node_modules', 'dist', 'build', '.next', 'vendor', '.DS_Store'];

// src/components/Editor/Editor.tsx:68-79
useEffect(() => {
    if (monacoRef.current && tree && tree.path !== lastSyncedTreeRef.current) {
        syncWorkspaceWithMonaco(monacoRef.current, tree);
        
        // Setup compiler options for module resolution
        const syncDisposables = setupCompilerOptions(monacoRef.current, tree.path);
        disposablesRef.current.push(syncDisposables);
        
        lastSyncedTreeRef.current = tree.path;
    }
}, [tree, monacoRef.current]);

// src/components/BottomBar/TerminalPanel.tsx:95-99
window.electronAPI.invoke('terminal:create', cwd, shell).then((id: string) => {
    terminalIdRef.current = id;
    
    // Bidirectional streaming
    window.electronAPI.on('terminal:data', (_, termId, data) => {
        if (termId === id) term.write(data);
    });
    
    term.onData((data) => {
        window.electronAPI.send('terminal:input', id, data);
    });
});

// electron/main.ts:357-377
const settingsPath = path.join(app.getPath('userData'), 'settings.json');

ipcMain.handle('settings:load', async () => {
    try {
        const data = await fs.readFile(settingsPath, 'utf-8');
        return JSON.parse(data);
    } catch (error) {
        return null; // File doesn't exist yet
    }
});

ipcMain.handle('settings:save', async (_, settingsObj: any) => {
    await fs.writeFile(settingsPath, JSON.stringify(settingsObj, null, 2), 'utf-8');
});

// vite.config.ts:7-35
export default defineConfig({
  plugins: [
    react(),
    electron({
      main: {
        entry: 'electron/main.ts',
        vite: {
          build: {
            rollupOptions: {
              // node-pty must be external (native module)
              external: ['node-pty'],
            },
          },
        },
      },
      preload: {
        input: path.join(__dirname, 'electron/preload.ts'),
      },
      renderer: process.env.NODE_ENV === 'test' ? undefined : {},
    }),
  ],
});

// electron/main.ts:10-16, 439-473
autoUpdater.logger = console;
autoUpdater.autoDownload = true;
autoUpdater.autoInstallOnAppQuit = true;

ipcMain.on('check-update', () => {
    autoUpdater.checkForUpdatesAndNotify();
});

autoUpdater.on('update-available', () => {
    win?.webContents.send('update_available');
});

autoUpdater.on('update-downloaded', () => {
    win?.webContents.send('update_downloaded');
});

ipcMain.on('restart_app', () => {
    autoUpdater.quitAndInstall();
});