@machina.ai/cell-cli 1.64.0-rc3 → 1.66.0-rc1

package/dist/src/config/settings.test.js

@@ -832,6 +832,28 @@ describe('Settings Loading and Merging', () => {
             const settings = loadSettings(MOCK_WORKSPACE_DIR);
             expect(settings.merged.telemetry?.enabled).toBe(false);
         });
+        it('should load telemetry.otlpHeaders from settings', () => {
+            mockFsExistsSync.mockImplementation((p) => normalizePath(p) === normalizePath(USER_SETTINGS_PATH));
+            const userSettingsContent = {
+                telemetry: {
+                    enabled: true,
+                    otlpHeaders: {
+                        Authorization: 'Bearer test-token-value',
+                        'x-custom': 'static-val',
+                    },
+                },
+            };
+            fs.readFileSync.mockImplementation((p) => {
+                if (normalizePath(p) === normalizePath(USER_SETTINGS_PATH))
+                    return JSON.stringify(userSettingsContent);
+                return '{}';
+            });
+            const settings = loadSettings(MOCK_WORKSPACE_DIR);
+            expect(settings.merged.telemetry?.otlpHeaders).toEqual({
+                Authorization: 'Bearer test-token-value',
+                'x-custom': 'static-val',
+            });
+        });
         it('should have telemetry as undefined if not in any settings file', () => {
             mockFsExistsSync.mockReturnValue(false); // No settings files exist
             fs.readFileSync.mockReturnValue('{}');
@@ -1794,6 +1816,93 @@ describe('Settings Loading and Merging', () => {
                 'USER.md',
             ]); // User setting
         });
+        it('should mark workspace scope as readOnly and block setValue when workspace is not trusted', () => {
+            vi.spyOn(trustedFolders, 'isWorkspaceTrusted').mockReturnValue({
+                isTrusted: false,
+                source: 'file',
+            });
+            mockFsExistsSync.mockReturnValue(true);
+            const workspaceSettingsContent = {
+                ui: { theme: 'dark' },
+                mcpServers: {
+                    existing: { command: 'node', args: ['server.js'] },
+                },
+            };
+            fs.readFileSync.mockImplementation((p) => {
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH))
+                    return JSON.stringify(workspaceSettingsContent);
+                return '{}';
+            });
+            const settings = loadSettings(MOCK_WORKSPACE_DIR);
+            expect(settings.workspace.readOnly).toBe(true);
+            expect(settings.forScope(SettingScope.Workspace).readOnly).toBe(true);
+            expect(() => {
+                settings.setValue(SettingScope.Workspace, 'mcpServers', {
+                    newsrv: { command: 'echo' },
+                });
+            }).toThrow(/Cannot modify settings in an untrusted workspace/);
+            expect(updateSettingsFilePreservingFormat).not.toHaveBeenCalled();
+        });
+        it('should restore workspace writability when setTrusted(true) is called and re-block when setTrusted(false) is called', () => {
+            vi.spyOn(trustedFolders, 'isWorkspaceTrusted').mockReturnValue({
+                isTrusted: false,
+                source: 'file',
+            });
+            mockFsExistsSync.mockReturnValue(true);
+            const workspaceSettingsContent = {
+                ui: { theme: 'dark' },
+                mcpServers: {
+                    existing: { command: 'node', args: ['server.js'] },
+                },
+            };
+            fs.readFileSync.mockImplementation((p) => {
+                if (normalizePath(p) === normalizePath(MOCK_WORKSPACE_SETTINGS_PATH))
+                    return JSON.stringify(workspaceSettingsContent);
+                return '{}';
+            });
+            const settings = loadSettings(MOCK_WORKSPACE_DIR);
+            expect(settings.workspace.readOnly).toBe(true);
+            settings.setTrusted(true);
+            expect(settings.workspace.readOnly).toBe(false);
+            expect(settings.workspace.settings).toEqual(workspaceSettingsContent);
+            settings.setValue(SettingScope.Workspace, 'mcpServers', {
+                ...workspaceSettingsContent.mcpServers,
+                newsrv: { command: 'echo' },
+            });
+            expect(updateSettingsFilePreservingFormat).toHaveBeenCalledWith(MOCK_WORKSPACE_SETTINGS_PATH, expect.objectContaining({
+                ui: { theme: 'dark' },
+                mcpServers: {
+                    existing: { command: 'node', args: ['server.js'] },
+                    newsrv: { command: 'echo' },
+                },
+            }));
+            vi.mocked(updateSettingsFilePreservingFormat).mockClear();
+            settings.setTrusted(false);
+            expect(settings.workspace.readOnly).toBe(true);
+            expect(() => {
+                settings.setValue(SettingScope.Workspace, 'ui.theme', 'light');
+            }).toThrow(/Cannot modify settings in an untrusted workspace/);
+            expect(updateSettingsFilePreservingFormat).not.toHaveBeenCalled();
+        });
+        it('should throw a home directory error when setValue is called on workspace scope in the home directory', () => {
+            const isWorkspaceHomeDirSpy = vi
+                .spyOn(Storage.prototype, 'isWorkspaceHomeDir')
+                .mockReturnValue(true);
+            try {
+                const settings = loadSettings(path.resolve('/mock/home/user'));
+                expect(settings.workspace.path).toBe('');
+                expect(settings.workspace.readOnly).toBe(true);
+                expect(() => {
+                    settings.setValue(SettingScope.Workspace, 'mcpServers', {
+                        newsrv: { command: 'echo' },
+                    });
+                }).toThrow('Cannot modify workspace settings in the home directory. Please use user scope instead.');
+                expect(updateSettingsFilePreservingFormat).not.toHaveBeenCalled();
+            }
+            finally {
+                isWorkspaceHomeDirSpy.mockRestore();
+            }
+        });
     });
     describe('loadEnvironment', () => {
         function setup({ isFolderTrustEnabled = true, isWorkspaceTrustedValue = true, }) {
@@ -1904,6 +2013,197 @@ describe('Settings Loading and Merging', () => {
             }
         });
     });
+    describe('resolving settings placeholders from .env files', () => {
+        const WORKSPACE_ENV_PATH = path.resolve(path.join(MOCK_WORKSPACE_DIR, '.env'));
+        /**
+         * Sets up a workspace containing a project `.env` file alongside the
+         * given user and workspace settings files.
+         */
+        function setupEnvFileScenario({ envFileContent, userSettingsContent = {}, workspaceSettingsContent = {}, }) {
+            mockFsExistsSync.mockImplementation((p) => [
+                path.resolve(USER_SETTINGS_PATH),
+                path.resolve(MOCK_WORKSPACE_SETTINGS_PATH),
+                WORKSPACE_ENV_PATH,
+            ].includes(path.resolve(p.toString())));
+            fs.readFileSync.mockImplementation((p) => {
+                const normalizedP = path.resolve(p.toString());
+                if (normalizedP === path.resolve(USER_SETTINGS_PATH)) {
+                    return JSON.stringify(userSettingsContent);
+                }
+                if (normalizedP === path.resolve(MOCK_WORKSPACE_SETTINGS_PATH)) {
+                    return JSON.stringify(workspaceSettingsContent);
+                }
+                if (normalizedP === WORKSPACE_ENV_PATH) {
+                    return envFileContent;
+                }
+                return '{}';
+            });
+        }
+        it('should resolve placeholders in settings using variables defined only in a .env file', () => {
+            setupEnvFileScenario({
+                envFileContent: 'GITHUB_MCP_PAT=ghp_secretTokenHere\nWORKSPACE_API_TOKEN=ws-token',
+                userSettingsContent: {
+                    mcpServers: {
+                        github: {
+                            httpUrl: 'https://api.githubcopilot.com/mcp/',
+                            headers: { Authorization: 'Bearer $GITHUB_MCP_PAT' },
+                        },
+                    },
+                },
+                workspaceSettingsContent: {
+                    mcpServers: {
+                        internal: {
+                            url: 'https://internal.example.com/sse?token=${WORKSPACE_API_TOKEN}',
+                        },
+                    },
+                },
+            });
+            const settings = loadSettings(MOCK_WORKSPACE_DIR);
+            expect(settings.merged.mcpServers?.['github']?.headers).toEqual({
+                Authorization: 'Bearer ghp_secretTokenHere',
+            });
+            expect(settings.merged.mcpServers?.['internal']?.url).toBe('https://internal.example.com/sse?token=ws-token');
+            expect(settings.user.settings.mcpServers?.['github']?.headers).toEqual({
+                Authorization: 'Bearer ghp_secretTokenHere',
+            });
+            expect(settings.workspace.settings.mcpServers?.['internal']?.url).toBe('https://internal.example.com/sse?token=ws-token');
+        });
+        it('should keep the unexpanded placeholders in originalSettings', () => {
+            setupEnvFileScenario({
+                envFileContent: 'GITHUB_ORIGINAL_MCP_PAT=ghp_secretTokenHere',
+                userSettingsContent: {
+                    mcpServers: {
+                        github: {
+                            headers: { Authorization: 'Bearer $GITHUB_ORIGINAL_MCP_PAT' },
+                        },
+                    },
+                },
+            });
+            const settings = loadSettings(MOCK_WORKSPACE_DIR);
+            expect(settings.user.originalSettings.mcpServers?.['github']?.headers).toEqual({ Authorization: 'Bearer $GITHUB_ORIGINAL_MCP_PAT' });
+        });
+        it('should validate settings after .env variables have been resolved', () => {
+            setupEnvFileScenario({
+                envFileContent: 'MAX_TURNS_FROM_ENV_FILE=15',
+                userSettingsContent: {
+                    model: { maxSessionTurns: '$MAX_TURNS_FROM_ENV_FILE' },
+                },
+            });
+            const settings = loadSettings(MOCK_WORKSPACE_DIR);
+            expect(settings.merged.model.maxSessionTurns).toBe(15);
+            expect(settings.errors).toHaveLength(0);
+        });
+        it('should record validation warnings only once when a .env variable expands to an invalid type', () => {
+            setupEnvFileScenario({
+                envFileContent: 'INVALID_MAX_TURNS_FROM_ENV_FILE=not-a-number',
+                userSettingsContent: {
+                    model: { maxSessionTurns: '$INVALID_MAX_TURNS_FROM_ENV_FILE' },
+                },
+            });
+            const settings = loadSettings(MOCK_WORKSPACE_DIR);
+            expect(settings.errors).toHaveLength(1);
+            expect(settings.errors[0]?.severity).toBe('warning');
+        });
+        it('should prefer variables from the shell environment over .env files', () => {
+            vi.stubEnv('SHELL_PRECEDENCE_MCP_PAT', 'token-from-shell');
+            setupEnvFileScenario({
+                envFileContent: 'SHELL_PRECEDENCE_MCP_PAT=token-from-env-file',
+                userSettingsContent: {
+                    mcpServers: {
+                        github: {
+                            headers: { Authorization: 'Bearer $SHELL_PRECEDENCE_MCP_PAT' },
+                        },
+                    },
+                },
+            });
+            const settings = loadSettings(MOCK_WORKSPACE_DIR);
+            expect(settings.merged.mcpServers?.['github']?.headers).toEqual({
+                Authorization: 'Bearer token-from-shell',
+            });
+        });
+        it('should not resolve placeholders from a .env file in an untrusted workspace', () => {
+            vi.spyOn(trustedFolders, 'isWorkspaceTrusted').mockReturnValue({
+                isTrusted: false,
+                source: 'file',
+            });
+            setupEnvFileScenario({
+                envFileContent: 'UNTRUSTED_MCP_PAT=ghp_secretTokenHere',
+                userSettingsContent: {
+                    mcpServers: {
+                        github: {
+                            headers: { Authorization: 'Bearer $UNTRUSTED_MCP_PAT' },
+                        },
+                    },
+                },
+            });
+            const settings = loadSettings(MOCK_WORKSPACE_DIR);
+            expect(process.env['UNTRUSTED_MCP_PAT']).toBeUndefined();
+            expect(settings.merged.mcpServers?.['github']?.headers).toEqual({
+                Authorization: 'Bearer $UNTRUSTED_MCP_PAT',
+            });
+        });
+        it('should not resolve or validate workspace settings in an untrusted workspace to avoid leaking shell secrets in validation errors', () => {
+            vi.spyOn(trustedFolders, 'isWorkspaceTrusted').mockReturnValue({
+                isTrusted: false,
+                source: 'file',
+            });
+            vi.stubEnv('SECRET_TOKEN_FROM_SHELL', 'super-secret-shell-value');
+            setupEnvFileScenario({
+                envFileContent: '',
+                workspaceSettingsContent: {
+                    model: { maxSessionTurns: '$SECRET_TOKEN_FROM_SHELL' },
+                },
+            });
+            const settings = loadSettings(MOCK_WORKSPACE_DIR);
+            expect(settings.errors).toEqual([]);
+            expect(settings.workspace.settings).toEqual({});
+            settings.setTrusted(true);
+            expect(settings.workspace.settings).toEqual({
+                model: { maxSessionTurns: 'super-secret-shell-value' },
+            });
+            expect(settings.errors).toHaveLength(1);
+        });
+        it('should normalize legacy theme names when an initially untrusted workspace is later trusted', () => {
+            vi.spyOn(trustedFolders, 'isWorkspaceTrusted').mockReturnValue({
+                isTrusted: false,
+                source: 'file',
+            });
+            setupEnvFileScenario({
+                envFileContent: '',
+                workspaceSettingsContent: {
+                    ui: { theme: 'VS2015' },
+                },
+            });
+            const settings = loadSettings(MOCK_WORKSPACE_DIR);
+            expect(settings.workspace.settings).toEqual({});
+            settings.setTrusted(true);
+            expect(settings.workspace.settings.ui?.theme).toBe('Default');
+            expect(settings.merged.ui.theme).toBe('Default');
+        });
+        it('should evaluate workspace trust with settings resolved from the shell environment even when other settings reference .env variables', () => {
+            // The trust check gates whether a workspace .env file may be loaded, so
+            // it must be evaluated against the environment as it exists *before*
+            // any .env file is loaded, with placeholders resolved and coerced even if
+            // another typed setting still holds an unexpanded .env placeholder.
+            vi.stubEnv('FOLDER_TRUST_FROM_SHELL', 'false');
+            setupEnvFileScenario({
+                envFileContent: 'TRUST_CHECK_MAX_TURNS=25',
+                userSettingsContent: {
+                    security: { folderTrust: { enabled: '$FOLDER_TRUST_FROM_SHELL' } },
+                    model: { maxSessionTurns: '$TRUST_CHECK_MAX_TURNS' },
+                },
+            });
+            const settings = loadSettings(MOCK_WORKSPACE_DIR);
+            expect(isWorkspaceTrusted).toHaveBeenCalledWith(expect.objectContaining({
+                security: expect.objectContaining({
+                    folderTrust: expect.objectContaining({ enabled: false }),
+                }),
+            }), MOCK_WORKSPACE_DIR);
+            expect(settings.merged.security.folderTrust.enabled).toBe(false);
+            expect(settings.merged.model.maxSessionTurns).toBe(25);
+            expect(settings.errors).toEqual([]);
+        });
+    });
     describe('migrateDeprecatedSettings', () => {
         let mockFsExistsSync;
         let mockFsReadFileSync;