@didim365/agent-cli-core 0.1.0

package/dist/src/utils/editor.js

@@ -0,0 +1,219 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { execSync, spawn, spawnSync } from 'node:child_process';
+import { debugLogger } from './debugLogger.js';
+import { coreEvents, CoreEvent } from './events.js';
+const GUI_EDITORS = [
+    'vscode',
+    'vscodium',
+    'windsurf',
+    'cursor',
+    'zed',
+    'antigravity',
+];
+const TERMINAL_EDITORS = ['vim', 'neovim', 'emacs', 'hx'];
+const EDITORS = [...GUI_EDITORS, ...TERMINAL_EDITORS];
+const GUI_EDITORS_SET = new Set(GUI_EDITORS);
+const TERMINAL_EDITORS_SET = new Set(TERMINAL_EDITORS);
+const EDITORS_SET = new Set(EDITORS);
+export const DEFAULT_GUI_EDITOR = 'vscode';
+export function isGuiEditor(editor) {
+    return GUI_EDITORS_SET.has(editor);
+}
+export function isTerminalEditor(editor) {
+    return TERMINAL_EDITORS_SET.has(editor);
+}
+export const EDITOR_DISPLAY_NAMES = {
+    vscode: 'VS Code',
+    vscodium: 'VSCodium',
+    windsurf: 'Windsurf',
+    cursor: 'Cursor',
+    vim: 'Vim',
+    neovim: 'Neovim',
+    zed: 'Zed',
+    emacs: 'Emacs',
+    antigravity: 'Antigravity',
+    hx: 'Helix',
+};
+export function getEditorDisplayName(editor) {
+    return EDITOR_DISPLAY_NAMES[editor] || editor;
+}
+function isValidEditorType(editor) {
+    return EDITORS_SET.has(editor);
+}
+/**
+ * Escapes a string for use in an Emacs Lisp string literal.
+ * Wraps in double quotes and escapes backslashes and double quotes.
+ */
+function escapeELispString(str) {
+    return `"${str.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+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'] },
+    antigravity: {
+        win32: ['agy.cmd', 'antigravity.cmd', 'antigravity'],
+        default: ['agy', 'antigravity'],
+    },
+    hx: { win32: ['hx'], default: ['hx'] },
+};
+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 getEditorCommand(editor) {
+    const commandConfig = editorCommands[editor];
+    const commands = process.platform === 'win32' ? commandConfig.win32 : commandConfig.default;
+    return (commands.slice(0, -1).find((cmd) => commandExists(cmd)) ||
+        commands[commands.length - 1]);
+}
+export function allowEditorTypeInSandbox(editor) {
+    const notUsingSandbox = !process.env['SANDBOX'];
+    if (isGuiEditor(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 command = getEditorCommand(editor);
+    switch (editor) {
+        case 'vscode':
+        case 'vscodium':
+        case 'windsurf':
+        case 'cursor':
+        case 'zed':
+        case 'antigravity':
+            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 ${escapeELispString(oldPath)} ${escapeELispString(newPath)})`,
+                ],
+            };
+        case 'hx':
+            return {
+                command: 'hx',
+                args: ['--vsplit', '--', 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) {
+    const diffCommand = getDiffCommand(oldPath, newPath, editor);
+    if (!diffCommand) {
+        debugLogger.error('No diff tool available. Install a supported editor.');
+        return;
+    }
+    if (isTerminalEditor(editor)) {
+        try {
+            const result = spawnSync(diffCommand.command, diffCommand.args, {
+                stdio: 'inherit',
+            });
+            if (result.error) {
+                throw result.error;
+            }
+            if (result.status !== 0) {
+                throw new Error(`${editor} exited with code ${result.status}`);
+            }
+        }
+        finally {
+            coreEvents.emit(CoreEvent.ExternalEditorClosed);
+        }
+        return;
+    }
+    return new Promise((resolve, reject) => {
+        const childProcess = spawn(diffCommand.command, diffCommand.args, {
+            stdio: 'inherit',
+            shell: process.platform === 'win32',
+        });
+        childProcess.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`${editor} exited with code ${code}`));
+            }
+        });
+        childProcess.on('error', (error) => {
+            reject(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,429 @@
+/**
+ * @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, spawnSync } from 'node:child_process';
+import { debugLogger } from './debugLogger.js';
+vi.mock('child_process', () => ({
+    execSync: vi.fn(),
+    spawn: vi.fn(),
+    spawnSync: vi.fn(() => ({ error: null, status: 0 })),
+}));
+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'] },
+            {
+                editor: 'antigravity',
+                commands: ['agy', 'antigravity'],
+                win32Commands: ['agy.cmd', 'antigravity.cmd', 'antigravity'],
+            },
+            { editor: 'hx', commands: ['hx'], win32Commands: ['hx'] },
+        ];
+        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'] },
+            {
+                editor: 'antigravity',
+                commands: ['agy', 'antigravity'],
+                win32Commands: ['agy.cmd', 'antigravity.cmd', 'antigravity'],
+            },
+        ];
+        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 with escaped paths', () => {
+            const command = getDiffCommand('old file "quote".txt', 'new file \\back\\slash.txt', 'emacs');
+            expect(command).toEqual({
+                command: 'emacs',
+                args: [
+                    '--eval',
+                    '(ediff "old file \\"quote\\".txt" "new file \\\\back\\\\slash.txt")',
+                ],
+            });
+        });
+        it('should return the correct command for helix', () => {
+            const command = getDiffCommand('old.txt', 'new.txt', 'hx');
+            expect(command).toEqual({
+                command: 'hx',
+                args: ['--vsplit', '--', '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 guiEditors = [
+            'vscode',
+            'vscodium',
+            'windsurf',
+            'cursor',
+            'zed',
+        ];
+        for (const editor of guiEditors) {
+            it(`should call spawn for ${editor}`, async () => {
+                const mockSpawnOn = vi.fn((event, cb) => {
+                    if (event === 'close') {
+                        cb(0);
+                    }
+                });
+                spawn.mockReturnValue({ on: mockSpawnOn });
+                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: process.platform === 'win32',
+                });
+                expect(mockSpawnOn).toHaveBeenCalledWith('close', expect.any(Function));
+                expect(mockSpawnOn).toHaveBeenCalledWith('error', expect.any(Function));
+            });
+            it(`should reject if spawn for ${editor} fails`, async () => {
+                const mockError = new Error('spawn error');
+                const mockSpawnOn = vi.fn((event, cb) => {
+                    if (event === 'error') {
+                        cb(mockError);
+                    }
+                });
+                spawn.mockReturnValue({ on: mockSpawnOn });
+                await expect(openDiff('old.txt', 'new.txt', editor)).rejects.toThrow('spawn error');
+            });
+            it(`should reject if ${editor} exits with non-zero code`, async () => {
+                const mockSpawnOn = vi.fn((event, cb) => {
+                    if (event === 'close') {
+                        cb(1);
+                    }
+                });
+                spawn.mockReturnValue({ on: mockSpawnOn });
+                await expect(openDiff('old.txt', 'new.txt', editor)).rejects.toThrow(`${editor} exited with code 1`);
+            });
+        }
+        const terminalEditors = ['vim', 'neovim', 'emacs', 'hx'];
+        for (const editor of terminalEditors) {
+            it(`should call spawnSync for ${editor}`, async () => {
+                await openDiff('old.txt', 'new.txt', editor);
+                const diffCommand = getDiffCommand('old.txt', 'new.txt', editor);
+                expect(spawnSync).toHaveBeenCalledWith(diffCommand.command, diffCommand.args, {
+                    stdio: 'inherit',
+                });
+            });
+        }
+        it('should log an error if diff command is not available', async () => {
+            const consoleErrorSpy = vi
+                .spyOn(debugLogger, '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('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);
+        });
+        it('should allow hx in sandbox mode', () => {
+            vi.stubEnv('SANDBOX', 'sandbox');
+            expect(allowEditorTypeInSandbox('hx')).toBe(true);
+        });
+        it('should allow hx when not in sandbox mode', () => {
+            expect(allowEditorTypeInSandbox('hx')).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`, () => {
+                vi.stubEnv('SANDBOX', '');
+                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'));
+            vi.stubEnv('SANDBOX', '');
+            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 hx when installed and in sandbox mode', () => {
+            execSync.mockReturnValue(Buffer.from('/usr/bin/hx'));
+            vi.stubEnv('SANDBOX', 'sandbox');
+            expect(isEditorAvailable('hx')).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