- {filteredEnvironments.map((env) => (
-
renamingEnvUid !== env.uid && handleEnvironmentClick(env)}
- onDoubleClick={() => handleEnvironmentDoubleClick(env)}
- >
- {renamingEnvUid === env.uid ? (
-
+
+
setEnvironmentsExpanded(!environmentsExpanded)}
+ actions={(
+ <>
+
+
+
+
+ )}
+ >
+
+ {filteredEnvironments.map((env) => (
+
renamingEnvUid !== env.uid && handleEnvironmentClick(env)}
+ onDoubleClick={() => handleEnvironmentDoubleClick(env)}
+ >
+ {renamingEnvUid === env.uid ? (
+
+
+
+
+
+
+
+ ) : (
+ <>
+
+
{env.name}
+
+ {activeEnvironmentUid === env.uid ? (
+
+
+
+ ) : (
+
+ )}
+
+
+ )}
+
+ ))}
+
+ {isCreatingInline && (
+
- {activeEnvironmentUid === env.uid ? (
-
-
-
- ) : (
-
- )}
-
{envNameError}
}
+
+ {filteredEnvironments.length === 0 && !isCreatingInline && (
+
+ No environments
+
)}
- ))}
+
- {isCreatingInline && (
-
-
-
-
- )}
-
- {envNameError && (isCreatingInline || renamingEnvUid) && (
-
{envNameError}
- )}
+
- {/* Right Content */}
-
+ {renderContent()}
);
diff --git a/packages/bruno-app/src/components/WorkspaceHome/WorkspaceEnvironments/index.js b/packages/bruno-app/src/components/WorkspaceHome/WorkspaceEnvironments/index.js
index 96914db8b..08a3244ee 100644
--- a/packages/bruno-app/src/components/WorkspaceHome/WorkspaceEnvironments/index.js
+++ b/packages/bruno-app/src/components/WorkspaceHome/WorkspaceEnvironments/index.js
@@ -1,67 +1,34 @@
import React, { useState } from 'react';
import { useSelector } from 'react-redux';
-import CreateEnvironment from './CreateEnvironment';
import EnvironmentList from './EnvironmentList';
import StyledWrapper from './StyledWrapper';
-import { IconFileAlert } from '@tabler/icons';
-import ImportEnvironmentModal from 'components/Environments/Common/ImportEnvironmentModal';
import ExportEnvironmentModal from 'components/Environments/Common/ExportEnvironmentModal';
-import Button from 'ui/Button';
-
-const DefaultTab = ({ setTab }) => (
-
-
-
No Environments
-
-
-
-
-
-);
const WorkspaceEnvironments = ({ workspace }) => {
const [isModified, setIsModified] = useState(false);
const [selectedEnvironment, setSelectedEnvironment] = useState(null);
- const [tab, setTab] = useState('default');
const [showExportModal, setShowExportModal] = useState(false);
const globalEnvironments = useSelector((state) => state.globalEnvironments.globalEnvironments);
const activeGlobalEnvironmentUid = useSelector((state) => state.globalEnvironments.activeGlobalEnvironmentUid);
- if (!globalEnvironments || !globalEnvironments.length) {
- return (
-
- {tab === 'create' ? (
- setTab('default')} />
- ) : tab === 'import' ? (
- setTab('default')} />
- ) : (
-
- )}
-
- );
- }
-
return (
{showExportModal && (
setShowExportModal(false)}
- environments={globalEnvironments}
+ environments={globalEnvironments || []}
environmentType="global"
/>
)}
diff --git a/packages/bruno-app/src/hooks/useOnClickOutside/index.js b/packages/bruno-app/src/hooks/useOnClickOutside/index.js
index 2dbef75f2..d86fcb303 100644
--- a/packages/bruno-app/src/hooks/useOnClickOutside/index.js
+++ b/packages/bruno-app/src/hooks/useOnClickOutside/index.js
@@ -1,9 +1,11 @@
// See https://usehooks.com/useOnClickOutside/
import { useEffect } from 'react';
-const useOnClickOutside = (ref, handler) => {
+const useOnClickOutside = (ref, handler, enabled = true) => {
useEffect(
() => {
+ if (!enabled) return;
+
const listener = (event) => {
// Do nothing if clicking ref's element or descendant elements
if (!ref.current || ref.current.contains(event.target)) {
@@ -27,7 +29,7 @@ const useOnClickOutside = (ref, handler) => {
// ... callback/cleanup to run every render. It's not a big deal ...
// ... but to optimize you can wrap handler in useCallback before ...
// ... passing it into this hook.
- [ref, handler]
+ [ref, handler, enabled]
);
};
diff --git a/packages/bruno-app/src/providers/App/useIpcEvents.js b/packages/bruno-app/src/providers/App/useIpcEvents.js
index 4b256555a..77aa687a1 100644
--- a/packages/bruno-app/src/providers/App/useIpcEvents.js
+++ b/packages/bruno-app/src/providers/App/useIpcEvents.js
@@ -24,11 +24,12 @@ import {
runFolderEvent,
runRequestEvent,
scriptEnvironmentUpdateEvent,
- streamDataReceived
+ streamDataReceived,
+ setDotEnvVariables
} from 'providers/ReduxStore/slices/collections';
import { collectionAddEnvFileEvent, openCollectionEvent, hydrateCollectionWithUiStateSnapshot, mergeAndPersistEnvironment } from 'providers/ReduxStore/slices/collections/actions';
import { workspaceOpenedEvent, workspaceConfigUpdatedEvent } from 'providers/ReduxStore/slices/workspaces/actions';
-import { workspaceDotEnvUpdateEvent } from 'providers/ReduxStore/slices/workspaces';
+import { workspaceDotEnvUpdateEvent, setWorkspaceDotEnvVariables } from 'providers/ReduxStore/slices/workspaces';
import toast from 'react-hot-toast';
import { useDispatch, useStore } from 'react-redux';
import { isElectron } from 'utils/common/platform';
@@ -226,6 +227,33 @@ const useIpcEvents = () => {
dispatch(workspaceEnvUpdateEvent({ processEnvVariables: val.processEnvVariables }));
});
+ const removeDotEnvFileUpdateListener = ipcRenderer.on('main:dotenv-file-update', (val) => {
+ const { type, collectionUid, workspaceUid, filename, variables, exists, processEnvVariables } = val;
+
+ if (type === 'collection' && collectionUid) {
+ dispatch(setDotEnvVariables({
+ collectionUid,
+ variables,
+ exists,
+ filename
+ }));
+ if (filename === '.env') {
+ dispatch(processEnvUpdateEvent({ collectionUid, processEnvVariables }));
+ }
+ } else if (type === 'workspace' && workspaceUid) {
+ dispatch(setWorkspaceDotEnvVariables({
+ workspaceUid,
+ variables,
+ exists,
+ filename
+ }));
+ if (filename === '.env') {
+ dispatch(workspaceDotEnvUpdateEvent(val));
+ dispatch(workspaceEnvUpdateEvent({ processEnvVariables }));
+ }
+ }
+ });
+
const removeConsoleLogListener = ipcRenderer.on('main:console-log', (val) => {
console[val.type](...val.args);
dispatch(addLog({
@@ -321,6 +349,7 @@ const useIpcEvents = () => {
removeRunRequestEventListener();
removeProcessEnvUpdatesListener();
removeWorkspaceDotEnvUpdatesListener();
+ removeDotEnvFileUpdateListener();
removeConsoleLogListener();
removeConfigUpdatesListener();
removeShowPreferencesListener();
diff --git a/packages/bruno-app/src/providers/ReduxStore/slices/collections/actions.js b/packages/bruno-app/src/providers/ReduxStore/slices/collections/actions.js
index 84884aae3..043529020 100644
--- a/packages/bruno-app/src/providers/ReduxStore/slices/collections/actions.js
+++ b/packages/bruno-app/src/providers/ReduxStore/slices/collections/actions.js
@@ -2896,3 +2896,71 @@ export const openCollectionSettings
resolve();
});
};
+
+export const saveDotEnvVariables = (collectionUid, variables, filename = '.env') => (dispatch, getState) => {
+ const { ipcRenderer } = window;
+ return new Promise((resolve, reject) => {
+ const state = getState();
+ const collection = findCollectionByUid(state.collections.collections, collectionUid);
+
+ if (!collection) {
+ return reject(new Error('Collection not found'));
+ }
+
+ ipcRenderer
+ .invoke('renderer:save-dotenv-variables', collection.pathname, variables, filename)
+ .then(resolve)
+ .catch(reject);
+ });
+};
+
+export const saveDotEnvRaw = (collectionUid, content, filename = '.env') => (dispatch, getState) => {
+ const { ipcRenderer } = window;
+ return new Promise((resolve, reject) => {
+ const state = getState();
+ const collection = findCollectionByUid(state.collections.collections, collectionUid);
+
+ if (!collection) {
+ return reject(new Error('Collection not found'));
+ }
+
+ ipcRenderer
+ .invoke('renderer:save-dotenv-raw', collection.pathname, content, filename)
+ .then(resolve)
+ .catch(reject);
+ });
+};
+
+export const createDotEnvFile = (collectionUid, filename = '.env') => (dispatch, getState) => {
+ const { ipcRenderer } = window;
+ return new Promise((resolve, reject) => {
+ const state = getState();
+ const collection = findCollectionByUid(state.collections.collections, collectionUid);
+
+ if (!collection) {
+ return reject(new Error('Collection not found'));
+ }
+
+ ipcRenderer
+ .invoke('renderer:create-dotenv-file', collection.pathname, filename)
+ .then(resolve)
+ .catch(reject);
+ });
+};
+
+export const deleteDotEnvFile = (collectionUid, filename = '.env') => (dispatch, getState) => {
+ const { ipcRenderer } = window;
+ return new Promise((resolve, reject) => {
+ const state = getState();
+ const collection = findCollectionByUid(state.collections.collections, collectionUid);
+
+ if (!collection) {
+ return reject(new Error('Collection not found'));
+ }
+
+ ipcRenderer
+ .invoke('renderer:delete-dotenv-file', collection.pathname, filename)
+ .then(resolve)
+ .catch(reject);
+ });
+};
diff --git a/packages/bruno-app/src/providers/ReduxStore/slices/collections/index.js b/packages/bruno-app/src/providers/ReduxStore/slices/collections/index.js
index a31536246..9972b7c7d 100644
--- a/packages/bruno-app/src/providers/ReduxStore/slices/collections/index.js
+++ b/packages/bruno-app/src/providers/ReduxStore/slices/collections/index.js
@@ -470,6 +470,37 @@ export const collectionsSlice = createSlice({
collection.workspaceProcessEnvVariables = processEnvVariables;
});
},
+ setDotEnvVariables: (state, action) => {
+ const { collectionUid, variables, exists, filename = '.env' } = action.payload;
+ const collection = findCollectionByUid(state.collections, collectionUid);
+
+ if (collection) {
+ if (!collection.dotEnvFiles) {
+ collection.dotEnvFiles = [];
+ }
+
+ const existingIndex = collection.dotEnvFiles.findIndex((f) => f.filename === filename);
+ if (existingIndex >= 0) {
+ if (exists) {
+ collection.dotEnvFiles[existingIndex] = { filename, variables, exists };
+ } else {
+ collection.dotEnvFiles.splice(existingIndex, 1);
+ }
+ } else if (exists) {
+ collection.dotEnvFiles.push({ filename, variables, exists });
+ }
+
+ collection.dotEnvFiles.sort((a, b) => {
+ if (a.filename === '.env') return -1;
+ if (b.filename === '.env') return 1;
+ return a.filename.localeCompare(b.filename);
+ });
+
+ const mainEnvFile = collection.dotEnvFiles.find((f) => f.filename === '.env');
+ collection.dotEnvVariables = mainEnvFile?.variables || [];
+ collection.dotEnvExists = mainEnvFile?.exists || false;
+ }
+ },
requestCancelled: (state, action) => {
const { itemUid, collectionUid, seq, timestamp } = action.payload;
const collection = findCollectionByUid(state.collections, collectionUid);
@@ -3530,6 +3561,7 @@ export const {
scriptEnvironmentUpdateEvent,
processEnvUpdateEvent,
workspaceEnvUpdateEvent,
+ setDotEnvVariables,
requestCancelled,
responseReceived,
runGrpcRequestEvent,
diff --git a/packages/bruno-app/src/providers/ReduxStore/slices/workspaces/actions.js b/packages/bruno-app/src/providers/ReduxStore/slices/workspaces/actions.js
index 1f439acbd..08a255d78 100644
--- a/packages/bruno-app/src/providers/ReduxStore/slices/workspaces/actions.js
+++ b/packages/bruno-app/src/providers/ReduxStore/slices/workspaces/actions.js
@@ -760,3 +760,83 @@ export const importWorkspaceAction = (zipFilePath, extractLocation) => {
}
};
};
+
+export const saveWorkspaceDotEnvVariables = (workspaceUid, variables, filename = '.env') => (dispatch, getState) => {
+ return new Promise((resolve, reject) => {
+ const state = getState();
+ const workspace = state.workspaces.workspaces.find((w) => w.uid === workspaceUid);
+
+ if (!workspace) {
+ return reject(new Error('Workspace not found'));
+ }
+
+ if (!workspace.pathname) {
+ return reject(new Error('Workspace path not found'));
+ }
+
+ ipcRenderer
+ .invoke('renderer:save-workspace-dotenv-variables', { workspacePath: workspace.pathname, variables, filename })
+ .then(resolve)
+ .catch(reject);
+ });
+};
+
+export const saveWorkspaceDotEnvRaw = (workspaceUid, content, filename = '.env') => (dispatch, getState) => {
+ return new Promise((resolve, reject) => {
+ const state = getState();
+ const workspace = state.workspaces.workspaces.find((w) => w.uid === workspaceUid);
+
+ if (!workspace) {
+ return reject(new Error('Workspace not found'));
+ }
+
+ if (!workspace.pathname) {
+ return reject(new Error('Workspace path not found'));
+ }
+
+ ipcRenderer
+ .invoke('renderer:save-workspace-dotenv-raw', { workspacePath: workspace.pathname, content, filename })
+ .then(resolve)
+ .catch(reject);
+ });
+};
+
+export const createWorkspaceDotEnvFile = (workspaceUid, filename = '.env') => (dispatch, getState) => {
+ return new Promise((resolve, reject) => {
+ const state = getState();
+ const workspace = state.workspaces.workspaces.find((w) => w.uid === workspaceUid);
+
+ if (!workspace) {
+ return reject(new Error('Workspace not found'));
+ }
+
+ if (!workspace.pathname) {
+ return reject(new Error('Workspace path not found'));
+ }
+
+ ipcRenderer
+ .invoke('renderer:create-workspace-dotenv-file', { workspacePath: workspace.pathname, filename })
+ .then(resolve)
+ .catch(reject);
+ });
+};
+
+export const deleteWorkspaceDotEnvFile = (workspaceUid, filename = '.env') => (dispatch, getState) => {
+ return new Promise((resolve, reject) => {
+ const state = getState();
+ const workspace = state.workspaces.workspaces.find((w) => w.uid === workspaceUid);
+
+ if (!workspace) {
+ return reject(new Error('Workspace not found'));
+ }
+
+ if (!workspace.pathname) {
+ return reject(new Error('Workspace path not found'));
+ }
+
+ ipcRenderer
+ .invoke('renderer:delete-workspace-dotenv-file', { workspacePath: workspace.pathname, filename })
+ .then(resolve)
+ .catch(reject);
+ });
+};
diff --git a/packages/bruno-app/src/providers/ReduxStore/slices/workspaces/index.js b/packages/bruno-app/src/providers/ReduxStore/slices/workspaces/index.js
index d8bb63f1f..ec62e47c7 100644
--- a/packages/bruno-app/src/providers/ReduxStore/slices/workspaces/index.js
+++ b/packages/bruno-app/src/providers/ReduxStore/slices/workspaces/index.js
@@ -84,6 +84,38 @@ export const workspacesSlice = createSlice({
if (workspace) {
workspace.processEnvVariables = processEnvVariables;
}
+ },
+
+ setWorkspaceDotEnvVariables: (state, action) => {
+ const { workspaceUid, variables, exists, filename = '.env' } = action.payload;
+ const workspace = state.workspaces.find((w) => w.uid === workspaceUid);
+
+ if (workspace) {
+ if (!workspace.dotEnvFiles) {
+ workspace.dotEnvFiles = [];
+ }
+
+ const existingIndex = workspace.dotEnvFiles.findIndex((f) => f.filename === filename);
+ if (existingIndex >= 0) {
+ if (exists) {
+ workspace.dotEnvFiles[existingIndex] = { filename, variables, exists };
+ } else {
+ workspace.dotEnvFiles.splice(existingIndex, 1);
+ }
+ } else if (exists) {
+ workspace.dotEnvFiles.push({ filename, variables, exists });
+ }
+
+ workspace.dotEnvFiles.sort((a, b) => {
+ if (a.filename === '.env') return -1;
+ if (b.filename === '.env') return 1;
+ return a.filename.localeCompare(b.filename);
+ });
+
+ const mainEnvFile = workspace.dotEnvFiles.find((f) => f.filename === '.env');
+ workspace.dotEnvVariables = mainEnvFile?.variables || [];
+ workspace.dotEnvExists = mainEnvFile?.exists || false;
+ }
}
}
});
@@ -96,7 +128,8 @@ export const {
addCollectionToWorkspace,
removeCollectionFromWorkspace,
updateWorkspaceLoadingState,
- workspaceDotEnvUpdateEvent
+ workspaceDotEnvUpdateEvent,
+ setWorkspaceDotEnvVariables
} = workspacesSlice.actions;
export default workspacesSlice.reducer;
diff --git a/packages/bruno-electron/src/app/collection-watcher.js b/packages/bruno-electron/src/app/collection-watcher.js
index 7d03ba77a..038ba0195 100644
--- a/packages/bruno-electron/src/app/collection-watcher.js
+++ b/packages/bruno-electron/src/app/collection-watcher.js
@@ -16,30 +16,22 @@ const {
parseCollection,
parseFolder
} = require('@usebruno/filestore');
-const { parseDotEnv } = require('@usebruno/filestore');
const { uuid } = require('../utils/common');
const { getRequestUid } = require('../cache/requestUids');
const { decryptStringSafe } = require('../utils/encryption');
-const { setDotEnvVars } = require('../store/process-env');
const { setBrunoConfig } = require('../store/bruno-config');
const EnvironmentSecretsStore = require('../store/env-secrets');
const UiStateSnapshot = require('../store/ui-state-snapshot');
const { parseFileMeta, hydrateRequestWithUuid } = require('../utils/collection');
const { parseLargeRequestWithRedaction } = require('../utils/parse');
const { transformBrunoConfigAfterRead } = require('../utils/transformBrunoConfig');
+const dotEnvWatcher = require('./dotenv-watcher');
const MAX_FILE_SIZE = 2.5 * 1024 * 1024;
const environmentSecretsStore = new EnvironmentSecretsStore();
-const isDotEnvFile = (pathname, collectionPath) => {
- const dirname = path.dirname(pathname);
- const basename = path.basename(pathname);
-
- return dirname === collectionPath && basename === '.env';
-};
-
const isBrunoConfigFile = (pathname, collectionPath) => {
const dirname = path.dirname(pathname);
const basename = path.basename(pathname);
@@ -227,24 +219,6 @@ const add = async (win, pathname, collectionUid, collectionPath, useWorkerThread
}
}
- if (isDotEnvFile(pathname, collectionPath)) {
- try {
- const content = fs.readFileSync(pathname, 'utf8');
- const jsonData = parseDotEnv(content);
-
- setDotEnvVars(collectionUid, jsonData);
- const payload = {
- collectionUid,
- processEnvVariables: {
- ...jsonData
- }
- };
- win.webContents.send('main:process-env-update', payload);
- } catch (err) {
- console.error(err);
- }
- }
-
if (isEnvironmentsFolder(pathname, collectionPath)) {
return addEnvironmentFile(win, pathname, collectionUid, collectionPath);
}
@@ -470,26 +444,6 @@ const change = async (win, pathname, collectionUid, collectionPath) => {
return;
}
- if (isDotEnvFile(pathname, collectionPath)) {
- try {
- const content = fs.readFileSync(pathname, 'utf8');
- const jsonData = parseDotEnv(content);
-
- setDotEnvVars(collectionUid, jsonData);
- const payload = {
- collectionUid,
- processEnvVariables: {
- ...jsonData
- }
- };
- win.webContents.send('main:process-env-update', payload);
- } catch (err) {
- console.error(err);
- }
-
- return;
- }
-
if (isEnvironmentsFolder(pathname, collectionPath)) {
return changeEnvironmentFile(win, pathname, collectionUid, collectionPath);
}
@@ -759,6 +713,12 @@ class CollectionWatcher {
ignored: (filepath) => {
const normalizedPath = normalizeAndResolvePath(filepath);
const relativePath = path.relative(watchPath, normalizedPath);
+ const basename = path.basename(filepath);
+
+ // Ignore .env files - handled by dotenv-watcher
+ if (basename === '.env' || basename.startsWith('.env.')) {
+ return true;
+ }
// Check if any path segment matches a default ignore pattern (handles symlinks)
const pathSegments = relativePath.split(path.sep);
@@ -811,6 +771,8 @@ class CollectionWatcher {
});
this.watchers[watchPath] = watcher;
+
+ dotEnvWatcher.addCollectionWatcher(win, watchPath, collectionUid);
}, 100);
}
@@ -824,6 +786,8 @@ class CollectionWatcher {
this.watchers[watchPath] = null;
}
+ dotEnvWatcher.removeCollectionWatcher(watchPath);
+
const tempDirectoryPath = this.tempDirectoryMap[watchPath];
if (tempDirectoryPath && this.watchers[tempDirectoryPath]) {
this.watchers[tempDirectoryPath].close();
diff --git a/packages/bruno-electron/src/app/dotenv-watcher.js b/packages/bruno-electron/src/app/dotenv-watcher.js
new file mode 100644
index 000000000..aef09e6a7
--- /dev/null
+++ b/packages/bruno-electron/src/app/dotenv-watcher.js
@@ -0,0 +1,214 @@
+const fs = require('fs');
+const path = require('path');
+const chokidar = require('chokidar');
+const { parseDotEnv } = require('@usebruno/filestore');
+const { setDotEnvVars, clearDotEnvVars, setWorkspaceDotEnvVars, clearWorkspaceDotEnvVars } = require('../store/process-env');
+
+const isDotEnvFile = (filename) => {
+ return filename === '.env' || filename.startsWith('.env.');
+};
+
+const parseVariablesToArray = (envObject) => {
+ return Object.entries(envObject).map(([name, value]) => ({
+ name,
+ value,
+ enabled: true,
+ secret: false
+ }));
+};
+
+const DEFAULT_WATCHER_OPTIONS = {
+ ignoreInitial: false,
+ persistent: true,
+ ignorePermissionErrors: true,
+ depth: 0
+};
+
+const createFileHandler = (win, options) => (pathname) => {
+ const { type, uid, uidKey, pathKey, basePath, setEnvVars } = options;
+ const filename = path.basename(pathname);
+
+ if (!isDotEnvFile(filename)) {
+ return;
+ }
+
+ try {
+ const content = fs.readFileSync(pathname, 'utf8');
+ const jsonData = parseDotEnv(content);
+
+ if (filename === '.env') {
+ setEnvVars(jsonData);
+ }
+
+ const variables = parseVariablesToArray(jsonData);
+
+ if (!win.isDestroyed()) {
+ const payload = {
+ type,
+ [uidKey]: uid,
+ filename,
+ variables,
+ exists: true,
+ processEnvVariables: { ...jsonData }
+ };
+ if (pathKey) {
+ payload[pathKey] = basePath;
+ }
+ win.webContents.send('main:dotenv-file-update', payload);
+ }
+ } catch (err) {
+ console.error(`Error processing dotenv file ${pathname}:`, err);
+ }
+};
+
+const createUnlinkHandler = (win, options) => (pathname) => {
+ const { type, uid, uidKey, pathKey, basePath, clearEnvVars } = options;
+ const filename = path.basename(pathname);
+
+ if (!isDotEnvFile(filename)) {
+ return;
+ }
+
+ if (filename === '.env') {
+ clearEnvVars();
+ }
+
+ if (!win.isDestroyed()) {
+ const payload = {
+ type,
+ [uidKey]: uid,
+ filename,
+ variables: [],
+ exists: false,
+ processEnvVariables: {}
+ };
+ if (pathKey) {
+ payload[pathKey] = basePath;
+ }
+ win.webContents.send('main:dotenv-file-update', payload);
+ }
+};
+
+class DotEnvWatcher {
+ constructor() {
+ this.collectionWatchers = new Map();
+ this.workspaceWatchers = new Map();
+ }
+
+ addCollectionWatcher(win, collectionPath, collectionUid) {
+ if (this.collectionWatchers.has(collectionPath)) {
+ this.collectionWatchers.get(collectionPath).close();
+ }
+
+ const dotEnvPattern = path.join(collectionPath, '.env*');
+
+ const watcher = chokidar.watch(dotEnvPattern, {
+ ...DEFAULT_WATCHER_OPTIONS,
+ awaitWriteFinish: {
+ stabilityThreshold: 80,
+ pollInterval: 100
+ }
+ });
+
+ const handlerOptions = {
+ type: 'collection',
+ uid: collectionUid,
+ uidKey: 'collectionUid',
+ basePath: collectionPath,
+ setEnvVars: (data) => setDotEnvVars(collectionUid, data),
+ clearEnvVars: () => clearDotEnvVars(collectionUid)
+ };
+
+ const handleFile = createFileHandler(win, handlerOptions);
+ const handleUnlink = createUnlinkHandler(win, handlerOptions);
+
+ watcher.on('add', handleFile);
+ watcher.on('change', handleFile);
+ watcher.on('unlink', handleUnlink);
+ watcher.on('error', (err) => {
+ console.error(`Collection watcher error for ${collectionPath}:`, err);
+ });
+
+ this.collectionWatchers.set(collectionPath, watcher);
+ }
+
+ removeCollectionWatcher(collectionPath, collectionUid) {
+ if (this.collectionWatchers.has(collectionPath)) {
+ this.collectionWatchers.get(collectionPath).close();
+ this.collectionWatchers.delete(collectionPath);
+ }
+ if (collectionUid) {
+ clearDotEnvVars(collectionUid);
+ }
+ }
+
+ hasCollectionWatcher(collectionPath) {
+ return this.collectionWatchers.has(collectionPath);
+ }
+
+ addWorkspaceWatcher(win, workspacePath, workspaceUid) {
+ if (this.workspaceWatchers.has(workspacePath)) {
+ this.workspaceWatchers.get(workspacePath).close();
+ }
+
+ const dotEnvPattern = path.join(workspacePath, '.env*');
+
+ const watcher = chokidar.watch(dotEnvPattern, {
+ ...DEFAULT_WATCHER_OPTIONS,
+ awaitWriteFinish: {
+ stabilityThreshold: 80,
+ pollInterval: 250
+ }
+ });
+
+ const handlerOptions = {
+ type: 'workspace',
+ uid: workspaceUid,
+ uidKey: 'workspaceUid',
+ pathKey: 'workspacePath',
+ basePath: workspacePath,
+ setEnvVars: (data) => setWorkspaceDotEnvVars(workspacePath, data),
+ clearEnvVars: () => clearWorkspaceDotEnvVars(workspacePath)
+ };
+
+ const handleFile = createFileHandler(win, handlerOptions);
+ const handleUnlink = createUnlinkHandler(win, handlerOptions);
+
+ watcher.on('add', handleFile);
+ watcher.on('change', handleFile);
+ watcher.on('unlink', handleUnlink);
+ watcher.on('error', (err) => {
+ console.error(`Workspace watcher error for ${workspacePath}:`, err);
+ });
+
+ this.workspaceWatchers.set(workspacePath, watcher);
+ }
+
+ removeWorkspaceWatcher(workspacePath) {
+ if (this.workspaceWatchers.has(workspacePath)) {
+ this.workspaceWatchers.get(workspacePath).close();
+ this.workspaceWatchers.delete(workspacePath);
+ }
+ clearWorkspaceDotEnvVars(workspacePath);
+ }
+
+ hasWorkspaceWatcher(workspacePath) {
+ return this.workspaceWatchers.has(workspacePath);
+ }
+
+ closeAll() {
+ for (const [path, watcher] of this.collectionWatchers) {
+ watcher.close();
+ }
+ this.collectionWatchers.clear();
+
+ for (const [path, watcher] of this.workspaceWatchers) {
+ watcher.close();
+ }
+ this.workspaceWatchers.clear();
+ }
+}
+
+const dotEnvWatcher = new DotEnvWatcher();
+
+module.exports = dotEnvWatcher;
diff --git a/packages/bruno-electron/src/app/workspace-watcher.js b/packages/bruno-electron/src/app/workspace-watcher.js
index aecaa27d2..1cc38c87c 100644
--- a/packages/bruno-electron/src/app/workspace-watcher.js
+++ b/packages/bruno-electron/src/app/workspace-watcher.js
@@ -5,10 +5,10 @@ const chokidar = require('chokidar');
const yaml = require('js-yaml');
const { generateUidBasedOnHash, uuid } = require('../utils/common');
const { getWorkspaceUid } = require('../utils/workspace-config');
-const { parseEnvironment, parseDotEnv } = require('@usebruno/filestore');
+const { parseEnvironment } = require('@usebruno/filestore');
const EnvironmentSecretsStore = require('../store/env-secrets');
const { decryptStringSafe } = require('../utils/encryption');
-const { setWorkspaceDotEnvVars, clearWorkspaceDotEnvVars } = require('../store/process-env');
+const dotEnvWatcher = require('./dotenv-watcher');
const environmentSecretsStore = new EnvironmentSecretsStore();
@@ -123,51 +123,15 @@ const handleGlobalEnvironmentFileUnlink = async (win, pathname, workspaceUid) =>
}
};
-const handleWorkspaceDotEnvFile = (win, workspacePath, workspaceUid) => {
- try {
- const dotEnvPath = path.join(workspacePath, '.env');
- if (!fs.existsSync(dotEnvPath)) {
- return;
- }
-
- const content = fs.readFileSync(dotEnvPath, 'utf8');
- const jsonData = parseDotEnv(content);
-
- setWorkspaceDotEnvVars(workspacePath, jsonData);
- win.webContents.send('main:workspace-dotenv-update', {
- workspaceUid,
- workspacePath,
- processEnvVariables: { ...jsonData }
- });
- } catch (error) {
- console.error('Error handling workspace .env file:', error);
- }
-};
-
-const handleWorkspaceDotEnvUnlink = (win, workspacePath, workspaceUid) => {
- try {
- clearWorkspaceDotEnvVars(workspacePath);
- win.webContents.send('main:workspace-dotenv-update', {
- workspaceUid,
- workspacePath,
- processEnvVariables: {}
- });
- } catch (error) {
- console.error('Error handling workspace .env file unlink:', error);
- }
-};
-
class WorkspaceWatcher {
constructor() {
this.watchers = {};
this.environmentWatchers = {};
- this.dotEnvWatchers = {};
}
addWatcher(win, workspacePath) {
const workspaceFilePath = path.join(workspacePath, 'workspace.yml');
const environmentsDir = path.join(workspacePath, 'environments');
- const dotEnvFilePath = path.join(workspacePath, '.env');
const workspaceUid = getWorkspaceUid(workspacePath);
if (this.watchers[workspacePath]) {
@@ -176,9 +140,6 @@ class WorkspaceWatcher {
if (this.environmentWatchers[workspacePath]) {
this.environmentWatchers[workspacePath].close();
}
- if (this.dotEnvWatchers[workspacePath]) {
- this.dotEnvWatchers[workspacePath].close();
- }
const self = this;
setTimeout(() => {
@@ -186,9 +147,6 @@ class WorkspaceWatcher {
return;
}
- // Load initial .env file if exists
- handleWorkspaceDotEnvFile(win, workspacePath, workspaceUid);
-
const watcher = chokidar.watch(workspaceFilePath, {
ignoreInitial: true,
persistent: true,
@@ -199,29 +157,11 @@ class WorkspaceWatcher {
}
});
- // Only listen for 'change' events - 'add' event is not needed because:
- // 1. The workspace is already loaded when the watcher is started
- // 2. ignoreInitial: true prevents firing for existing files
- // 3. If workspace.yml is deleted and recreated, 'change' will catch it
watcher.on('change', () => handleWorkspaceFileChange(win, workspacePath));
self.watchers[workspacePath] = watcher;
- const dotEnvWatcher = chokidar.watch(dotEnvFilePath, {
- ignoreInitial: true,
- persistent: true,
- ignorePermissionErrors: true,
- awaitWriteFinish: {
- stabilityThreshold: 80,
- pollInterval: 250
- }
- });
-
- dotEnvWatcher.on('add', () => handleWorkspaceDotEnvFile(win, workspacePath, workspaceUid));
- dotEnvWatcher.on('change', () => handleWorkspaceDotEnvFile(win, workspacePath, workspaceUid));
- dotEnvWatcher.on('unlink', () => handleWorkspaceDotEnvUnlink(win, workspacePath, workspaceUid));
-
- self.dotEnvWatchers[workspacePath] = dotEnvWatcher;
+ dotEnvWatcher.addWorkspaceWatcher(win, workspacePath, workspaceUid);
if (fs.existsSync(environmentsDir)) {
const envWatcher = chokidar.watch(path.join(environmentsDir, `*.yml`), {
@@ -275,12 +215,7 @@ class WorkspaceWatcher {
this.environmentWatchers[workspacePath].close();
delete this.environmentWatchers[workspacePath];
}
- if (this.dotEnvWatchers[workspacePath]) {
- this.dotEnvWatchers[workspacePath].close();
- delete this.dotEnvWatchers[workspacePath];
- }
- // Clear workspace env vars when watcher is removed
- clearWorkspaceDotEnvVars(workspacePath);
+ dotEnvWatcher.removeWorkspaceWatcher(workspacePath);
} catch (error) {
console.error('Error removing workspace watcher:', error);
}
diff --git a/packages/bruno-electron/src/ipc/collection.js b/packages/bruno-electron/src/ipc/collection.js
index e72e41195..68ce1bbe0 100644
--- a/packages/bruno-electron/src/ipc/collection.js
+++ b/packages/bruno-electron/src/ipc/collection.js
@@ -46,6 +46,7 @@ const {
getPaths,
generateUniqueName,
isDotEnvFile,
+ isValidDotEnvFilename,
isBrunoConfigFile,
isBruEnvironmentConfig,
isCollectionRootBruFile
@@ -620,6 +621,99 @@ const registerRendererEventHandlers = (mainWindow, watcher) => {
}
});
+ // Save .env file variables for collection
+ ipcMain.handle('renderer:save-dotenv-variables', async (event, collectionPathname, variables, filename = '.env') => {
+ try {
+ if (!isValidDotEnvFilename(filename)) {
+ throw new Error('Invalid .env filename');
+ }
+
+ const dotEnvPath = path.join(collectionPathname, filename);
+
+ // Convert variables array to .env format
+ const content = variables
+ .filter((v) => v.name && v.name.trim() !== '')
+ .map((v) => {
+ const value = v.value || '';
+ // If value contains newlines or special characters, wrap in quotes
+ if (value.includes('\n') || value.includes('"') || value.includes('\'') || value.includes('\\')) {
+ // Escape backslashes first, then double quotes
+ const escapedValue = value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+ return `${v.name}="${escapedValue}"`;
+ }
+ return `${v.name}=${value}`;
+ })
+ .join('\n');
+
+ await writeFile(dotEnvPath, content);
+
+ return { success: true };
+ } catch (error) {
+ console.error('Error saving .env file:', error);
+ return Promise.reject(error);
+ }
+ });
+
+ // Save .env file raw content for collection
+ ipcMain.handle('renderer:save-dotenv-raw', async (event, collectionPathname, content, filename = '.env') => {
+ try {
+ if (!isValidDotEnvFilename(filename)) {
+ throw new Error('Invalid .env filename');
+ }
+
+ const dotEnvPath = path.join(collectionPathname, filename);
+ await writeFile(dotEnvPath, content);
+ return { success: true };
+ } catch (error) {
+ console.error('Error saving .env file:', error);
+ return Promise.reject(error);
+ }
+ });
+
+ // Create .env file for collection
+ ipcMain.handle('renderer:create-dotenv-file', async (event, collectionPathname, filename = '.env') => {
+ try {
+ if (!isValidDotEnvFilename(filename)) {
+ throw new Error('Invalid .env filename');
+ }
+
+ const dotEnvPath = path.join(collectionPathname, filename);
+
+ if (fs.existsSync(dotEnvPath)) {
+ throw new Error(`${filename} file already exists`);
+ }
+
+ await writeFile(dotEnvPath, '');
+
+ return { success: true, filename };
+ } catch (error) {
+ console.error('Error creating .env file:', error);
+ return Promise.reject(error);
+ }
+ });
+
+ // Delete .env file for collection
+ ipcMain.handle('renderer:delete-dotenv-file', async (event, collectionPathname, filename = '.env') => {
+ try {
+ if (!isValidDotEnvFilename(filename)) {
+ throw new Error('Invalid .env filename');
+ }
+
+ const dotEnvPath = path.join(collectionPathname, filename);
+
+ if (!fs.existsSync(dotEnvPath)) {
+ throw new Error(`${filename} file does not exist`);
+ }
+
+ fs.unlinkSync(dotEnvPath);
+
+ return { success: true };
+ } catch (error) {
+ console.error('Error deleting .env file:', error);
+ return Promise.reject(error);
+ }
+ });
+
// update environment color
ipcMain.handle('renderer:update-environment-color', async (event, collectionPathname, environmentName, color) => {
try {
diff --git a/packages/bruno-electron/src/ipc/global-environments.js b/packages/bruno-electron/src/ipc/global-environments.js
index 432fd7330..7821e233e 100644
--- a/packages/bruno-electron/src/ipc/global-environments.js
+++ b/packages/bruno-electron/src/ipc/global-environments.js
@@ -1,7 +1,9 @@
require('dotenv').config();
+const fs = require('fs');
+const path = require('path');
const { ipcMain } = require('electron');
const { globalEnvironmentsStore } = require('../store/global-environments');
-const { generateUniqueName, sanitizeName } = require('../utils/filesystem');
+const { generateUniqueName, sanitizeName, writeFile, isValidDotEnvFilename } = require('../utils/filesystem');
const registerGlobalEnvironmentsIpc = (mainWindow, workspaceEnvironmentsManager) => {
ipcMain.handle('renderer:create-global-environment', async (event, { uid, name, variables, workspaceUid, workspacePath }) => {
@@ -100,6 +102,116 @@ const registerGlobalEnvironmentsIpc = (mainWindow, workspaceEnvironmentsManager)
}
});
+ // Save workspace .env file variables
+ ipcMain.handle('renderer:save-workspace-dotenv-variables', async (event, { workspacePath, variables, filename = '.env' }) => {
+ try {
+ if (!workspacePath) {
+ throw new Error('Workspace path is required');
+ }
+
+ if (!isValidDotEnvFilename(filename)) {
+ throw new Error('Invalid .env filename');
+ }
+
+ const dotEnvPath = path.join(workspacePath, filename);
+
+ // Convert variables array to .env format
+ const content = variables
+ .filter((v) => v.name && v.name.trim() !== '')
+ .map((v) => {
+ const value = v.value || '';
+ // If value contains newlines or special characters, wrap in quotes
+ if (value.includes('\n') || value.includes('"') || value.includes('\'') || value.includes('\\')) {
+ // Escape backslashes first, then double quotes
+ const escapedValue = value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+ return `${v.name}="${escapedValue}"`;
+ }
+ return `${v.name}=${value}`;
+ })
+ .join('\n');
+
+ await writeFile(dotEnvPath, content);
+
+ return { success: true };
+ } catch (error) {
+ console.error('Error saving workspace .env file:', error);
+ return Promise.reject(error);
+ }
+ });
+
+ // Save workspace .env file raw content
+ ipcMain.handle('renderer:save-workspace-dotenv-raw', async (event, { workspacePath, content, filename = '.env' }) => {
+ try {
+ if (!workspacePath) {
+ throw new Error('Workspace path is required');
+ }
+
+ if (!isValidDotEnvFilename(filename)) {
+ throw new Error('Invalid .env filename');
+ }
+
+ const dotEnvPath = path.join(workspacePath, filename);
+ await writeFile(dotEnvPath, content);
+
+ return { success: true };
+ } catch (error) {
+ console.error('Error saving workspace .env file:', error);
+ return Promise.reject(error);
+ }
+ });
+
+ // Create workspace .env file
+ ipcMain.handle('renderer:create-workspace-dotenv-file', async (event, { workspacePath, filename = '.env' }) => {
+ try {
+ if (!workspacePath) {
+ throw new Error('Workspace path is required');
+ }
+
+ if (!isValidDotEnvFilename(filename)) {
+ throw new Error('Invalid .env filename');
+ }
+
+ const dotEnvPath = path.join(workspacePath, filename);
+
+ if (fs.existsSync(dotEnvPath)) {
+ throw new Error(`${filename} file already exists`);
+ }
+
+ await writeFile(dotEnvPath, '');
+
+ return { success: true };
+ } catch (error) {
+ console.error('Error creating workspace .env file:', error);
+ return Promise.reject(error);
+ }
+ });
+
+ // Delete workspace .env file
+ ipcMain.handle('renderer:delete-workspace-dotenv-file', async (event, { workspacePath, filename = '.env' }) => {
+ try {
+ if (!workspacePath) {
+ throw new Error('Workspace path is required');
+ }
+
+ if (!isValidDotEnvFilename(filename)) {
+ throw new Error('Invalid .env filename');
+ }
+
+ const dotEnvPath = path.join(workspacePath, filename);
+
+ if (!fs.existsSync(dotEnvPath)) {
+ throw new Error(`${filename} file does not exist`);
+ }
+
+ fs.unlinkSync(dotEnvPath);
+
+ return { success: true };
+ } catch (error) {
+ console.error('Error deleting workspace .env file:', error);
+ return Promise.reject(error);
+ }
+ });
+
ipcMain.handle('renderer:update-global-environment-color', async (event, { environmentUid, color, workspacePath }) => {
try {
if (workspacePath && workspaceEnvironmentsManager) {
diff --git a/packages/bruno-electron/src/store/process-env.js b/packages/bruno-electron/src/store/process-env.js
index 3dbdd087b..d68258fe7 100644
--- a/packages/bruno-electron/src/store/process-env.js
+++ b/packages/bruno-electron/src/store/process-env.js
@@ -32,6 +32,10 @@ const setDotEnvVars = (collectionUid, envVars) => {
dotEnvVars[collectionUid] = envVars;
};
+const clearDotEnvVars = (collectionUid) => {
+ delete dotEnvVars[collectionUid];
+};
+
const setWorkspaceDotEnvVars = (workspacePath, envVars) => {
workspaceDotEnvVars[workspacePath] = envVars;
};
@@ -51,6 +55,7 @@ const clearCollectionWorkspace = (collectionUid) => {
module.exports = {
getProcessEnvVars,
setDotEnvVars,
+ clearDotEnvVars,
setWorkspaceDotEnvVars,
clearWorkspaceDotEnvVars,
setCollectionWorkspace,
diff --git a/packages/bruno-electron/src/utils/filesystem.js b/packages/bruno-electron/src/utils/filesystem.js
index 0d405419f..7e88f0c95 100644
--- a/packages/bruno-electron/src/utils/filesystem.js
+++ b/packages/bruno-electron/src/utils/filesystem.js
@@ -445,6 +445,13 @@ const isDotEnvFile = (pathname, collectionPath) => {
return dirname === collectionPath && basename === '.env';
};
+const isValidDotEnvFilename = (filename) => {
+ if (!filename || typeof filename !== 'string') return false;
+ const basename = path.basename(filename);
+ if (basename !== filename) return false;
+ return basename === '.env' || (basename.startsWith('.env.') && /^\.env\.[a-zA-Z0-9._-]+$/.test(basename));
+};
+
const isBrunoConfigFile = (pathname, collectionPath) => {
const dirname = path.dirname(pathname);
const basename = path.basename(pathname);
@@ -504,6 +511,7 @@ module.exports = {
generateUniqueName,
getCollectionFormat,
isDotEnvFile,
+ isValidDotEnvFilename,
isBrunoConfigFile,
isBruEnvironmentConfig,
isCollectionRootBruFile