@google/gemini-cli-core 0.0.3-preview.4

package/dist/src/utils/editor.js

@@ -0,0 +1,186 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { execSync, spawn } from 'node:child_process';
+function isValidEditorType(editor) {
+    return [
+        'vscode',
+        'vscodium',
+        'windsurf',
+        'cursor',
+        'vim',
+        'neovim',
+        'zed',
+        'emacs',
+    ].includes(editor);
+}
+function commandExists(cmd) {
+    try {
+        execSync(process.platform === 'win32' ? `where.exe ${cmd}` : `command -v ${cmd}`, { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Editor command configurations for different platforms.
+ * Each editor can have multiple possible command names, listed in order of preference.
+ */
+const editorCommands = {
+    vscode: { win32: ['code.cmd'], default: ['code'] },
+    vscodium: { win32: ['codium.cmd'], default: ['codium'] },
+    windsurf: { win32: ['windsurf'], default: ['windsurf'] },
+    cursor: { win32: ['cursor'], default: ['cursor'] },
+    vim: { win32: ['vim'], default: ['vim'] },
+    neovim: { win32: ['nvim'], default: ['nvim'] },
+    zed: { win32: ['zed'], default: ['zed', 'zeditor'] },
+    emacs: { win32: ['emacs.exe'], default: ['emacs'] },
+};
+export function checkHasEditorType(editor) {
+    const commandConfig = editorCommands[editor];
+    const commands = process.platform === 'win32' ? commandConfig.win32 : commandConfig.default;
+    return commands.some((cmd) => commandExists(cmd));
+}
+export function allowEditorTypeInSandbox(editor) {
+    const notUsingSandbox = !process.env['SANDBOX'];
+    if (['vscode', 'vscodium', 'windsurf', 'cursor', 'zed'].includes(editor)) {
+        return notUsingSandbox;
+    }
+    // For terminal-based editors like vim and emacs, allow in sandbox.
+    return true;
+}
+/**
+ * Check if the editor is valid and can be used.
+ * Returns false if preferred editor is not set / invalid / not available / not allowed in sandbox.
+ */
+export function isEditorAvailable(editor) {
+    if (editor && isValidEditorType(editor)) {
+        return checkHasEditorType(editor) && allowEditorTypeInSandbox(editor);
+    }
+    return false;
+}
+/**
+ * Get the diff command for a specific editor.
+ */
+export function getDiffCommand(oldPath, newPath, editor) {
+    if (!isValidEditorType(editor)) {
+        return null;
+    }
+    const commandConfig = editorCommands[editor];
+    const commands = process.platform === 'win32' ? commandConfig.win32 : commandConfig.default;
+    const command = commands.slice(0, -1).find((cmd) => commandExists(cmd)) ||
+        commands[commands.length - 1];
+    switch (editor) {
+        case 'vscode':
+        case 'vscodium':
+        case 'windsurf':
+        case 'cursor':
+        case 'zed':
+            return { command, args: ['--wait', '--diff', oldPath, newPath] };
+        case 'vim':
+        case 'neovim':
+            return {
+                command,
+                args: [
+                    '-d',
+                    // skip viminfo file to avoid E138 errors
+                    '-i',
+                    'NONE',
+                    // make the left window read-only and the right window editable
+                    '-c',
+                    'wincmd h | set readonly | wincmd l',
+                    // set up colors for diffs
+                    '-c',
+                    'highlight DiffAdd cterm=bold ctermbg=22 guibg=#005f00 | highlight DiffChange cterm=bold ctermbg=24 guibg=#005f87 | highlight DiffText ctermbg=21 guibg=#0000af | highlight DiffDelete ctermbg=52 guibg=#5f0000',
+                    // Show helpful messages
+                    '-c',
+                    'set showtabline=2 | set tabline=[Instructions]\\ :wqa(save\\ &\\ quit)\\ \\|\\ i/esc(toggle\\ edit\\ mode)',
+                    '-c',
+                    'wincmd h | setlocal statusline=OLD\\ FILE',
+                    '-c',
+                    'wincmd l | setlocal statusline=%#StatusBold#NEW\\ FILE\\ :wqa(save\\ &\\ quit)\\ \\|\\ i/esc(toggle\\ edit\\ mode)',
+                    // Auto close all windows when one is closed
+                    '-c',
+                    'autocmd BufWritePost * wqa',
+                    oldPath,
+                    newPath,
+                ],
+            };
+        case 'emacs':
+            return {
+                command: 'emacs',
+                args: ['--eval', `(ediff "${oldPath}" "${newPath}")`],
+            };
+        default:
+            return null;
+    }
+}
+/**
+ * Opens a diff tool to compare two files.
+ * Terminal-based editors by default blocks parent process until the editor exits.
+ * GUI-based editors require args such as "--wait" to block parent process.
+ */
+export async function openDiff(oldPath, newPath, editor, onEditorClose) {
+    const diffCommand = getDiffCommand(oldPath, newPath, editor);
+    if (!diffCommand) {
+        console.error('No diff tool available. Install a supported editor.');
+        return;
+    }
+    try {
+        switch (editor) {
+            case 'vscode':
+            case 'vscodium':
+            case 'windsurf':
+            case 'cursor':
+            case 'zed':
+                // Use spawn for GUI-based editors to avoid blocking the entire process
+                return new Promise((resolve, reject) => {
+                    const childProcess = spawn(diffCommand.command, diffCommand.args, {
+                        stdio: 'inherit',
+                        shell: true,
+                    });
+                    childProcess.on('close', (code) => {
+                        if (code === 0) {
+                            resolve();
+                        }
+                        else {
+                            reject(new Error(`${editor} exited with code ${code}`));
+                        }
+                    });
+                    childProcess.on('error', (error) => {
+                        reject(error);
+                    });
+                });
+            case 'vim':
+            case 'emacs':
+            case 'neovim': {
+                // Use execSync for terminal-based editors
+                const command = process.platform === 'win32'
+                    ? `${diffCommand.command} ${diffCommand.args.join(' ')}`
+                    : `${diffCommand.command} ${diffCommand.args.map((arg) => `"${arg}"`).join(' ')}`;
+                try {
+                    execSync(command, {
+                        stdio: 'inherit',
+                        encoding: 'utf8',
+                    });
+                }
+                catch (e) {
+                    console.error('Error in onEditorClose callback:', e);
+                }
+                finally {
+                    onEditorClose();
+                }
+                break;
+            }
+            default:
+                throw new Error(`Unsupported editor: ${editor}`);
+        }
+    }
+    catch (error) {
+        console.error(error);
+    }
+}
+//# sourceMappingURL=editor.js.map

package/dist/src/utils/editor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor.js","sourceRoot":"","sources":["../../../src/utils/editor.ts"],"names":[],"mappings":"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"}

package/dist/src/utils/editor.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

package/dist/src/utils/editor.test.js

@@ -0,0 +1,445 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { vi, describe, it, expect, beforeEach, afterEach, } from 'vitest';
+import { checkHasEditorType, getDiffCommand, openDiff, allowEditorTypeInSandbox, isEditorAvailable, } from './editor.js';
+import { execSync, spawn } from 'node:child_process';
+vi.mock('child_process', () => ({
+    execSync: vi.fn(),
+    spawn: vi.fn(),
+}));
+const originalPlatform = process.platform;
+describe('editor utils', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.unstubAllEnvs();
+        Object.defineProperty(process, 'platform', {
+            value: originalPlatform,
+            writable: true,
+        });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+        vi.unstubAllEnvs();
+        Object.defineProperty(process, 'platform', {
+            value: originalPlatform,
+            writable: true,
+        });
+    });
+    describe('checkHasEditorType', () => {
+        const testCases = [
+            { editor: 'vscode', commands: ['code'], win32Commands: ['code.cmd'] },
+            {
+                editor: 'vscodium',
+                commands: ['codium'],
+                win32Commands: ['codium.cmd'],
+            },
+            {
+                editor: 'windsurf',
+                commands: ['windsurf'],
+                win32Commands: ['windsurf'],
+            },
+            { editor: 'cursor', commands: ['cursor'], win32Commands: ['cursor'] },
+            { editor: 'vim', commands: ['vim'], win32Commands: ['vim'] },
+            { editor: 'neovim', commands: ['nvim'], win32Commands: ['nvim'] },
+            { editor: 'zed', commands: ['zed', 'zeditor'], win32Commands: ['zed'] },
+            { editor: 'emacs', commands: ['emacs'], win32Commands: ['emacs.exe'] },
+        ];
+        for (const { editor, commands, win32Commands } of testCases) {
+            describe(`${editor}`, () => {
+                // Non-windows tests
+                it(`should return true if first command "${commands[0]}" exists on non-windows`, () => {
+                    Object.defineProperty(process, 'platform', { value: 'linux' });
+                    execSync.mockReturnValue(Buffer.from(`/usr/bin/${commands[0]}`));
+                    expect(checkHasEditorType(editor)).toBe(true);
+                    expect(execSync).toHaveBeenCalledWith(`command -v ${commands[0]}`, {
+                        stdio: 'ignore',
+                    });
+                });
+                if (commands.length > 1) {
+                    it(`should return true if first command doesn't exist but second command "${commands[1]}" exists on non-windows`, () => {
+                        Object.defineProperty(process, 'platform', { value: 'linux' });
+                        execSync
+                            .mockImplementationOnce(() => {
+                            throw new Error(); // first command not found
+                        })
+                            .mockReturnValueOnce(Buffer.from(`/usr/bin/${commands[1]}`)); // second command found
+                        expect(checkHasEditorType(editor)).toBe(true);
+                        expect(execSync).toHaveBeenCalledTimes(2);
+                    });
+                }
+                it(`should return false if none of the commands exist on non-windows`, () => {
+                    Object.defineProperty(process, 'platform', { value: 'linux' });
+                    execSync.mockImplementation(() => {
+                        throw new Error(); // all commands not found
+                    });
+                    expect(checkHasEditorType(editor)).toBe(false);
+                    expect(execSync).toHaveBeenCalledTimes(commands.length);
+                });
+                // Windows tests
+                it(`should return true if first command "${win32Commands[0]}" exists on windows`, () => {
+                    Object.defineProperty(process, 'platform', { value: 'win32' });
+                    execSync.mockReturnValue(Buffer.from(`C:\\Program Files\\...\\${win32Commands[0]}`));
+                    expect(checkHasEditorType(editor)).toBe(true);
+                    expect(execSync).toHaveBeenCalledWith(`where.exe ${win32Commands[0]}`, {
+                        stdio: 'ignore',
+                    });
+                });
+                if (win32Commands.length > 1) {
+                    it(`should return true if first command doesn't exist but second command "${win32Commands[1]}" exists on windows`, () => {
+                        Object.defineProperty(process, 'platform', { value: 'win32' });
+                        execSync
+                            .mockImplementationOnce(() => {
+                            throw new Error(); // first command not found
+                        })
+                            .mockReturnValueOnce(Buffer.from(`C:\\Program Files\\...\\${win32Commands[1]}`)); // second command found
+                        expect(checkHasEditorType(editor)).toBe(true);
+                        expect(execSync).toHaveBeenCalledTimes(2);
+                    });
+                }
+                it(`should return false if none of the commands exist on windows`, () => {
+                    Object.defineProperty(process, 'platform', { value: 'win32' });
+                    execSync.mockImplementation(() => {
+                        throw new Error(); // all commands not found
+                    });
+                    expect(checkHasEditorType(editor)).toBe(false);
+                    expect(execSync).toHaveBeenCalledTimes(win32Commands.length);
+                });
+            });
+        }
+    });
+    describe('getDiffCommand', () => {
+        const guiEditors = [
+            { editor: 'vscode', commands: ['code'], win32Commands: ['code.cmd'] },
+            {
+                editor: 'vscodium',
+                commands: ['codium'],
+                win32Commands: ['codium.cmd'],
+            },
+            {
+                editor: 'windsurf',
+                commands: ['windsurf'],
+                win32Commands: ['windsurf'],
+            },
+            { editor: 'cursor', commands: ['cursor'], win32Commands: ['cursor'] },
+            { editor: 'zed', commands: ['zed', 'zeditor'], win32Commands: ['zed'] },
+        ];
+        for (const { editor, commands, win32Commands } of guiEditors) {
+            // Non-windows tests
+            it(`should use first command "${commands[0]}" when it exists on non-windows`, () => {
+                Object.defineProperty(process, 'platform', { value: 'linux' });
+                execSync.mockReturnValue(Buffer.from(`/usr/bin/${commands[0]}`));
+                const diffCommand = getDiffCommand('old.txt', 'new.txt', editor);
+                expect(diffCommand).toEqual({
+                    command: commands[0],
+                    args: ['--wait', '--diff', 'old.txt', 'new.txt'],
+                });
+            });
+            if (commands.length > 1) {
+                it(`should use second command "${commands[1]}" when first doesn't exist on non-windows`, () => {
+                    Object.defineProperty(process, 'platform', { value: 'linux' });
+                    execSync
+                        .mockImplementationOnce(() => {
+                        throw new Error(); // first command not found
+                    })
+                        .mockReturnValueOnce(Buffer.from(`/usr/bin/${commands[1]}`)); // second command found
+                    const diffCommand = getDiffCommand('old.txt', 'new.txt', editor);
+                    expect(diffCommand).toEqual({
+                        command: commands[1],
+                        args: ['--wait', '--diff', 'old.txt', 'new.txt'],
+                    });
+                });
+            }
+            it(`should fall back to last command "${commands[commands.length - 1]}" when none exist on non-windows`, () => {
+                Object.defineProperty(process, 'platform', { value: 'linux' });
+                execSync.mockImplementation(() => {
+                    throw new Error(); // all commands not found
+                });
+                const diffCommand = getDiffCommand('old.txt', 'new.txt', editor);
+                expect(diffCommand).toEqual({
+                    command: commands[commands.length - 1],
+                    args: ['--wait', '--diff', 'old.txt', 'new.txt'],
+                });
+            });
+            // Windows tests
+            it(`should use first command "${win32Commands[0]}" when it exists on windows`, () => {
+                Object.defineProperty(process, 'platform', { value: 'win32' });
+                execSync.mockReturnValue(Buffer.from(`C:\\Program Files\\...\\${win32Commands[0]}`));
+                const diffCommand = getDiffCommand('old.txt', 'new.txt', editor);
+                expect(diffCommand).toEqual({
+                    command: win32Commands[0],
+                    args: ['--wait', '--diff', 'old.txt', 'new.txt'],
+                });
+            });
+            if (win32Commands.length > 1) {
+                it(`should use second command "${win32Commands[1]}" when first doesn't exist on windows`, () => {
+                    Object.defineProperty(process, 'platform', { value: 'win32' });
+                    execSync
+                        .mockImplementationOnce(() => {
+                        throw new Error(); // first command not found
+                    })
+                        .mockReturnValueOnce(Buffer.from(`C:\\Program Files\\...\\${win32Commands[1]}`)); // second command found
+                    const diffCommand = getDiffCommand('old.txt', 'new.txt', editor);
+                    expect(diffCommand).toEqual({
+                        command: win32Commands[1],
+                        args: ['--wait', '--diff', 'old.txt', 'new.txt'],
+                    });
+                });
+            }
+            it(`should fall back to last command "${win32Commands[win32Commands.length - 1]}" when none exist on windows`, () => {
+                Object.defineProperty(process, 'platform', { value: 'win32' });
+                execSync.mockImplementation(() => {
+                    throw new Error(); // all commands not found
+                });
+                const diffCommand = getDiffCommand('old.txt', 'new.txt', editor);
+                expect(diffCommand).toEqual({
+                    command: win32Commands[win32Commands.length - 1],
+                    args: ['--wait', '--diff', 'old.txt', 'new.txt'],
+                });
+            });
+        }
+        const terminalEditors = [
+            { editor: 'vim', command: 'vim' },
+            { editor: 'neovim', command: 'nvim' },
+        ];
+        for (const { editor, command } of terminalEditors) {
+            it(`should return the correct command for ${editor}`, () => {
+                const diffCommand = getDiffCommand('old.txt', 'new.txt', editor);
+                expect(diffCommand).toEqual({
+                    command,
+                    args: [
+                        '-d',
+                        '-i',
+                        'NONE',
+                        '-c',
+                        'wincmd h | set readonly | wincmd l',
+                        '-c',
+                        'highlight DiffAdd cterm=bold ctermbg=22 guibg=#005f00 | highlight DiffChange cterm=bold ctermbg=24 guibg=#005f87 | highlight DiffText ctermbg=21 guibg=#0000af | highlight DiffDelete ctermbg=52 guibg=#5f0000',
+                        '-c',
+                        'set showtabline=2 | set tabline=[Instructions]\\ :wqa(save\\ &\\ quit)\\ \\|\\ i/esc(toggle\\ edit\\ mode)',
+                        '-c',
+                        'wincmd h | setlocal statusline=OLD\\ FILE',
+                        '-c',
+                        'wincmd l | setlocal statusline=%#StatusBold#NEW\\ FILE\\ :wqa(save\\ &\\ quit)\\ \\|\\ i/esc(toggle\\ edit\\ mode)',
+                        '-c',
+                        'autocmd BufWritePost * wqa',
+                        'old.txt',
+                        'new.txt',
+                    ],
+                });
+            });
+        }
+        it('should return the correct command for emacs', () => {
+            const command = getDiffCommand('old.txt', 'new.txt', 'emacs');
+            expect(command).toEqual({
+                command: 'emacs',
+                args: ['--eval', '(ediff "old.txt" "new.txt")'],
+            });
+        });
+        it('should return null for an unsupported editor', () => {
+            // @ts-expect-error Testing unsupported editor
+            const command = getDiffCommand('old.txt', 'new.txt', 'foobar');
+            expect(command).toBeNull();
+        });
+    });
+    describe('openDiff', () => {
+        const spawnEditors = [
+            'vscode',
+            'vscodium',
+            'windsurf',
+            'cursor',
+            'zed',
+        ];
+        for (const editor of spawnEditors) {
+            it(`should call spawn for ${editor}`, async () => {
+                const mockSpawn = {
+                    on: vi.fn((event, cb) => {
+                        if (event === 'close') {
+                            cb(0);
+                        }
+                    }),
+                };
+                spawn.mockReturnValue(mockSpawn);
+                await openDiff('old.txt', 'new.txt', editor, () => { });
+                const diffCommand = getDiffCommand('old.txt', 'new.txt', editor);
+                expect(spawn).toHaveBeenCalledWith(diffCommand.command, diffCommand.args, {
+                    stdio: 'inherit',
+                    shell: true,
+                });
+                expect(mockSpawn.on).toHaveBeenCalledWith('close', expect.any(Function));
+                expect(mockSpawn.on).toHaveBeenCalledWith('error', expect.any(Function));
+            });
+            it(`should reject if spawn for ${editor} fails`, async () => {
+                const mockError = new Error('spawn error');
+                const mockSpawn = {
+                    on: vi.fn((event, cb) => {
+                        if (event === 'error') {
+                            cb(mockError);
+                        }
+                    }),
+                };
+                spawn.mockReturnValue(mockSpawn);
+                await expect(openDiff('old.txt', 'new.txt', editor, () => { })).rejects.toThrow('spawn error');
+            });
+            it(`should reject if ${editor} exits with non-zero code`, async () => {
+                const mockSpawn = {
+                    on: vi.fn((event, cb) => {
+                        if (event === 'close') {
+                            cb(1);
+                        }
+                    }),
+                };
+                spawn.mockReturnValue(mockSpawn);
+                await expect(openDiff('old.txt', 'new.txt', editor, () => { })).rejects.toThrow(`${editor} exited with code 1`);
+            });
+        }
+        const execSyncEditors = ['vim', 'neovim', 'emacs'];
+        for (const editor of execSyncEditors) {
+            it(`should call execSync for ${editor} on non-windows`, async () => {
+                Object.defineProperty(process, 'platform', { value: 'linux' });
+                await openDiff('old.txt', 'new.txt', editor, () => { });
+                expect(execSync).toHaveBeenCalledTimes(1);
+                const diffCommand = getDiffCommand('old.txt', 'new.txt', editor);
+                const expectedCommand = `${diffCommand.command} ${diffCommand.args.map((arg) => `"${arg}"`).join(' ')}`;
+                expect(execSync).toHaveBeenCalledWith(expectedCommand, {
+                    stdio: 'inherit',
+                    encoding: 'utf8',
+                });
+            });
+            it(`should call execSync for ${editor} on windows`, async () => {
+                Object.defineProperty(process, 'platform', { value: 'win32' });
+                await openDiff('old.txt', 'new.txt', editor, () => { });
+                expect(execSync).toHaveBeenCalledTimes(1);
+                const diffCommand = getDiffCommand('old.txt', 'new.txt', editor);
+                const expectedCommand = `${diffCommand.command} ${diffCommand.args.join(' ')}`;
+                expect(execSync).toHaveBeenCalledWith(expectedCommand, {
+                    stdio: 'inherit',
+                    encoding: 'utf8',
+                });
+            });
+        }
+        it('should log an error if diff command is not available', async () => {
+            const consoleErrorSpy = vi
+                .spyOn(console, 'error')
+                .mockImplementation(() => { });
+            // @ts-expect-error Testing unsupported editor
+            await openDiff('old.txt', 'new.txt', 'foobar', () => { });
+            expect(consoleErrorSpy).toHaveBeenCalledWith('No diff tool available. Install a supported editor.');
+        });
+        describe('onEditorClose callback', () => {
+            it('should call onEditorClose for execSync editors', async () => {
+                execSync.mockReturnValue(Buffer.from(`/usr/bin/`));
+                const onEditorClose = vi.fn();
+                await openDiff('old.txt', 'new.txt', 'vim', onEditorClose);
+                expect(execSync).toHaveBeenCalledTimes(1);
+                expect(onEditorClose).toHaveBeenCalledTimes(1);
+            });
+            it('should call onEditorClose for execSync editors when an error is thrown', async () => {
+                execSync.mockImplementation(() => {
+                    throw new Error('test error');
+                });
+                const onEditorClose = vi.fn();
+                openDiff('old.txt', 'new.txt', 'vim', onEditorClose);
+                expect(execSync).toHaveBeenCalledTimes(1);
+                expect(onEditorClose).toHaveBeenCalledTimes(1);
+            });
+            it('should not call onEditorClose for spawn editors', async () => {
+                const onEditorClose = vi.fn();
+                const mockSpawn = {
+                    on: vi.fn((event, cb) => {
+                        if (event === 'close') {
+                            cb(0);
+                        }
+                    }),
+                };
+                spawn.mockReturnValue(mockSpawn);
+                await openDiff('old.txt', 'new.txt', 'vscode', onEditorClose);
+                expect(spawn).toHaveBeenCalledTimes(1);
+                expect(onEditorClose).not.toHaveBeenCalled();
+            });
+        });
+    });
+    describe('allowEditorTypeInSandbox', () => {
+        it('should allow vim in sandbox mode', () => {
+            vi.stubEnv('SANDBOX', 'sandbox');
+            expect(allowEditorTypeInSandbox('vim')).toBe(true);
+        });
+        it('should allow vim when not in sandbox mode', () => {
+            expect(allowEditorTypeInSandbox('vim')).toBe(true);
+        });
+        it('should allow emacs in sandbox mode', () => {
+            vi.stubEnv('SANDBOX', 'sandbox');
+            expect(allowEditorTypeInSandbox('emacs')).toBe(true);
+        });
+        it('should allow emacs when not in sandbox mode', () => {
+            expect(allowEditorTypeInSandbox('emacs')).toBe(true);
+        });
+        it('should allow neovim in sandbox mode', () => {
+            vi.stubEnv('SANDBOX', 'sandbox');
+            expect(allowEditorTypeInSandbox('neovim')).toBe(true);
+        });
+        it('should allow neovim when not in sandbox mode', () => {
+            expect(allowEditorTypeInSandbox('neovim')).toBe(true);
+        });
+        const guiEditors = [
+            'vscode',
+            'vscodium',
+            'windsurf',
+            'cursor',
+            'zed',
+        ];
+        for (const editor of guiEditors) {
+            it(`should not allow ${editor} in sandbox mode`, () => {
+                vi.stubEnv('SANDBOX', 'sandbox');
+                expect(allowEditorTypeInSandbox(editor)).toBe(false);
+            });
+            it(`should allow ${editor} when not in sandbox mode`, () => {
+                expect(allowEditorTypeInSandbox(editor)).toBe(true);
+            });
+        }
+    });
+    describe('isEditorAvailable', () => {
+        it('should return false for undefined editor', () => {
+            expect(isEditorAvailable(undefined)).toBe(false);
+        });
+        it('should return false for empty string editor', () => {
+            expect(isEditorAvailable('')).toBe(false);
+        });
+        it('should return false for invalid editor type', () => {
+            expect(isEditorAvailable('invalid-editor')).toBe(false);
+        });
+        it('should return true for vscode when installed and not in sandbox mode', () => {
+            execSync.mockReturnValue(Buffer.from('/usr/bin/code'));
+            expect(isEditorAvailable('vscode')).toBe(true);
+        });
+        it('should return false for vscode when not installed and not in sandbox mode', () => {
+            execSync.mockImplementation(() => {
+                throw new Error();
+            });
+            expect(isEditorAvailable('vscode')).toBe(false);
+        });
+        it('should return false for vscode when installed and in sandbox mode', () => {
+            execSync.mockReturnValue(Buffer.from('/usr/bin/code'));
+            vi.stubEnv('SANDBOX', 'sandbox');
+            expect(isEditorAvailable('vscode')).toBe(false);
+        });
+        it('should return true for vim when installed and in sandbox mode', () => {
+            execSync.mockReturnValue(Buffer.from('/usr/bin/vim'));
+            vi.stubEnv('SANDBOX', 'sandbox');
+            expect(isEditorAvailable('vim')).toBe(true);
+        });
+        it('should return true for emacs when installed and in sandbox mode', () => {
+            execSync.mockReturnValue(Buffer.from('/usr/bin/emacs'));
+            vi.stubEnv('SANDBOX', 'sandbox');
+            expect(isEditorAvailable('emacs')).toBe(true);
+        });
+        it('should return true for neovim when installed and in sandbox mode', () => {
+            execSync.mockReturnValue(Buffer.from('/usr/bin/nvim'));
+            vi.stubEnv('SANDBOX', 'sandbox');
+            expect(isEditorAvailable('neovim')).toBe(true);
+        });
+    });
+});
+//# sourceMappingURL=editor.test.js.map