@pheem49/mint 1.3.0 → 1.4.1

package/src/UI/settings.js

@@ -16,6 +16,7 @@ const DEFAULT_CONFIG = {
     ollamaModel: 'llama3:latest',
     enableVoiceReply: true,
     enableCustomWorkflows: true,
+    enableAgentCollaboration: true,
     ttsProvider: 'google',
     ttsVolume: 1.0,
     ttsSpeed: 1.0,
@@ -57,6 +58,18 @@ function applyConfig(config) {
     // Apply API key
     document.getElementById('api-key-input').value = config.apiKey || '';
 
+    const anthropicInput = document.getElementById('anthropic-api-key-input');
+    if (anthropicInput) anthropicInput.value = config.anthropicApiKey || '';
+
+    const openaiInput = document.getElementById('openai-api-key-input');
+    if (openaiInput) openaiInput.value = config.openaiApiKey || '';
+
+    const hfInput = document.getElementById('hf-api-key');
+    if (hfInput) hfInput.value = config.hfApiKey || '';
+
+    const ollamaHostInput = document.getElementById('ollama-host-input');
+    if (ollamaHostInput) ollamaHostInput.value = config.ollamaHost || 'http://localhost:11434';
+
     // Apply Gemini model
     applyModelSelection(config.geminiModel);
     
@@ -72,6 +85,24 @@ function applyConfig(config) {
         ollamaInput.value = config.ollamaModel || 'llama3:latest';
     }
 
+    applyModelSelectionGeneric('openai-model-select', 'openai-model-custom-row', 'openai-model-custom', config.openaiModel || 'gpt-4o');
+    applyModelSelectionGeneric('anthropic-model-select', 'anthropic-model-custom-row', 'anthropic-model-custom', config.anthropicModel || 'claude-3-5-sonnet-latest');
+
+    const hfModelInput = document.getElementById('hf-model-name');
+    if (hfModelInput) {
+        hfModelInput.value = config.hfModel || 'meta-llama/Meta-Llama-3-8B-Instruct';
+    }
+
+    const localApiBaseUrlInput = document.getElementById('local-api-base-url');
+    if (localApiBaseUrlInput) {
+        localApiBaseUrlInput.value = config.localApiBaseUrl || 'http://localhost:1234/v1';
+    }
+
+    const localModelNameInput = document.getElementById('local-model-name');
+    if (localModelNameInput) {
+        localModelNameInput.value = config.localModelName || 'local-model';
+    }
+
     const voiceReplyToggle = document.getElementById('enable-voice-reply');
     if (voiceReplyToggle) {
         voiceReplyToggle.checked = config.enableVoiceReply !== false;
@@ -103,6 +134,11 @@ function applyConfig(config) {
         enableWorkflowsToggle.checked = config.enableCustomWorkflows !== false;
     }
 
+    const enableAgentCollaborationToggle = document.getElementById('enable-agent-collaboration');
+    if (enableAgentCollaborationToggle) {
+        enableAgentCollaborationToggle.checked = config.enableAgentCollaboration !== false;
+    }
+
     // Plugins logic
     updatePluginButton('spotify', config.pluginSpotifyEnabled);
     updatePluginButton('calendar', config.pluginCalendarEnabled);
@@ -168,9 +204,15 @@ function lightenColor(hex, amount) {
 }
 
 function applyModelSelection(model) {
-    const select = document.getElementById('gemini-model-select');
-    const customRow = document.getElementById('gemini-model-custom-row');
-    const customInput = document.getElementById('gemini-model-custom');
+    applyModelSelectionGeneric('gemini-model-select', 'gemini-model-custom-row', 'gemini-model-custom', model);
+}
+
+function applyModelSelectionGeneric(selectId, customRowId, customInputId, model) {
+    const select = document.getElementById(selectId);
+    const customRow = document.getElementById(customRowId);
+    const customInput = document.getElementById(customInputId);
+    if (!select || !customRow || !customInput) return;
+
     const normalized = (model || '').trim();
     const optionValues = Array.from(select.options).map(opt => opt.value);
 
@@ -186,11 +228,16 @@ function applyModelSelection(model) {
 }
 
 function getSelectedModel() {
-    const select = document.getElementById('gemini-model-select');
-    const customInput = document.getElementById('gemini-model-custom');
+    return getSelectedModelGeneric('gemini-model-select', 'gemini-model-custom', DEFAULT_CONFIG.geminiModel);
+}
+
+function getSelectedModelGeneric(selectId, customInputId, defaultModel) {
+    const select = document.getElementById(selectId);
+    const customInput = document.getElementById(customInputId);
+    if (!select || !customInput) return defaultModel;
     if (select.value === 'custom') {
         const custom = (customInput.value || '').trim();
-        return custom || DEFAULT_CONFIG.geminiModel;
+        return custom || defaultModel;
     }
     return select.value;
 }
@@ -198,21 +245,28 @@ function getSelectedModel() {
 // --- Event Listeners ---
 
 // Close button
-document.getElementById('close-btn').addEventListener('click', () => {
-    window.settingsApi.closeSettings();
-});
+// Close button
+const closeBtn = document.getElementById('close-btn');
+if (closeBtn) {
+    closeBtn.addEventListener('click', () => {
+        window.settingsApi.closeSettings();
+    });
+}
 
 // Toggle API key visibility
-document.getElementById('toggle-key').addEventListener('click', () => {
-    const input = document.getElementById('api-key-input');
-    input.type = input.type === 'password' ? 'text' : 'password';
-});
+const toggleKey = document.getElementById('toggle-key');
+if (toggleKey) {
+    toggleKey.addEventListener('click', () => {
+        const input = document.getElementById('api-key-input');
+        input.type = input.type === 'password' ? 'text' : 'password';
+    });
+}
 
 async function saveApiKeyOnly() {
     const input = document.getElementById('api-key-input');
     const status = document.getElementById('api-save-status');
     const btn = document.getElementById('save-api-key');
-    const apiKey = input.value.trim();
+    const apiKey = input ? input.value.trim() : '';
 
     try {
         const baseConfig = await window.settingsApi.getSettings();
@@ -220,26 +274,31 @@ async function saveApiKeyOnly() {
         await window.settingsApi.saveSettings(nextConfig);
         currentConfig.apiKey = apiKey;
 
-        btn.textContent = 'Saved!';
-        status.textContent = 'API key saved';
+        if (btn) btn.textContent = 'Saved!';
+        if (status) status.textContent = 'API key saved';
         setTimeout(() => {
-            btn.textContent = 'Save API Key';
-            status.textContent = '';
+            if (btn) btn.textContent = 'Save API Key';
+            if (status) status.textContent = '';
         }, 1500);
     } catch (err) {
         console.error('Failed to save API key:', err);
-        status.textContent = 'Save failed';
-        setTimeout(() => { status.textContent = ''; }, 1500);
+        if (status) status.textContent = 'Save failed';
+        setTimeout(() => { if (status) status.textContent = ''; }, 1500);
     }
 }
 
-document.getElementById('save-api-key').addEventListener('click', saveApiKeyOnly);
-document.getElementById('api-key-input').addEventListener('keydown', (e) => {
-    if (e.key === 'Enter') {
-        e.preventDefault();
-        saveApiKeyOnly();
-    }
-});
+const saveApiKey = document.getElementById('save-api-key');
+if (saveApiKey) saveApiKey.addEventListener('click', saveApiKeyOnly);
+
+const apiKeyInput = document.getElementById('api-key-input');
+if (apiKeyInput) {
+    apiKeyInput.addEventListener('keydown', (e) => {
+        if (e.key === 'Enter') {
+            e.preventDefault();
+            saveApiKeyOnly();
+        }
+    });
+}
 
 // Gemini model select
 document.getElementById('gemini-model-select').addEventListener('change', (e) => {
@@ -257,23 +316,45 @@ document.getElementById('gemini-model-custom').addEventListener('input', (e) =>
     currentConfig.geminiModel = e.target.value.trim();
 });
 
-// AI Provider toggle
-function toggleProviderOptions(provider) {
-    const geminiOptions = document.getElementById('gemini-options');
-    const ollamaOptions = document.getElementById('ollama-options');
-    
-    if (provider === 'ollama') {
-        geminiOptions.style.display = 'none';
-        ollamaOptions.style.display = 'block';
+// OpenAI model select
+document.getElementById('openai-model-select').addEventListener('change', (e) => {
+    const customRow = document.getElementById('openai-model-custom-row');
+    if (e.target.value === 'custom') {
+        customRow.style.display = 'block';
+        currentConfig.openaiModel = (document.getElementById('openai-model-custom').value || '').trim();
     } else {
-        geminiOptions.style.display = 'block';
-        ollamaOptions.style.display = 'none';
+        customRow.style.display = 'none';
+        currentConfig.openaiModel = e.target.value;
     }
+});
+
+document.getElementById('openai-model-custom').addEventListener('input', (e) => {
+    currentConfig.openaiModel = e.target.value.trim();
+});
+
+// Anthropic model select
+document.getElementById('anthropic-model-select').addEventListener('change', (e) => {
+    const customRow = document.getElementById('anthropic-model-custom-row');
+    if (e.target.value === 'custom') {
+        customRow.style.display = 'block';
+        currentConfig.anthropicModel = (document.getElementById('anthropic-model-custom').value || '').trim();
+    } else {
+        customRow.style.display = 'none';
+        currentConfig.anthropicModel = e.target.value;
+    }
+});
+
+document.getElementById('anthropic-model-custom').addEventListener('input', (e) => {
+    currentConfig.anthropicModel = e.target.value.trim();
+});
+
+// AI Provider toggle (No-op since all sections stay visible)
+function toggleProviderOptions(provider) {
+    // No-op
 }
 
 document.getElementById('ai-provider-select').addEventListener('change', (e) => {
     currentConfig.aiProvider = e.target.value;
-    toggleProviderOptions(e.target.value);
 });
 
 document.getElementById('ollama-model-input').addEventListener('input', (e) => {
@@ -281,9 +362,12 @@ document.getElementById('ollama-model-input').addEventListener('input', (e) => {
 });
 
 // AI Studio link
-document.getElementById('ai-studio-link').addEventListener('click', () => {
-    window.settingsApi.openExternal('https://aistudio.google.com/');
-});
+const aiStudioLink = document.getElementById('ai-studio-link');
+if (aiStudioLink) {
+    aiStudioLink.addEventListener('click', () => {
+        window.settingsApi.openExternal('https://aistudio.google.com/');
+    });
+}
 
 // Theme cards
 document.querySelectorAll('.theme-card').forEach(card => {
@@ -400,9 +484,34 @@ if (document.getElementById('tts-pitch')) {
 // Save
 document.getElementById('save-btn').addEventListener('click', async () => {
     currentConfig.apiKey = document.getElementById('api-key-input').value.trim();
+    
+    const anthropicInput = document.getElementById('anthropic-api-key-input');
+    if (anthropicInput) currentConfig.anthropicApiKey = anthropicInput.value.trim();
+
+    const openaiInput = document.getElementById('openai-api-key-input');
+    if (openaiInput) currentConfig.openaiApiKey = openaiInput.value.trim();
+
+    const hfInput = document.getElementById('hf-api-key');
+    if (hfInput) currentConfig.hfApiKey = hfInput.value.trim();
+
+    const ollamaHostInput = document.getElementById('ollama-host-input');
+    if (ollamaHostInput) currentConfig.ollamaHost = ollamaHostInput.value.trim();
+
     currentConfig.geminiModel = getSelectedModel();
     currentConfig.aiProvider = document.getElementById('ai-provider-select').value;
     currentConfig.ollamaModel = document.getElementById('ollama-model-input').value.trim();
+
+    currentConfig.openaiModel = getSelectedModelGeneric('openai-model-select', 'openai-model-custom', DEFAULT_CONFIG.openaiModel || 'gpt-4o');
+    currentConfig.anthropicModel = getSelectedModelGeneric('anthropic-model-select', 'anthropic-model-custom', DEFAULT_CONFIG.anthropicModel || 'claude-3-5-sonnet-latest');
+
+    const hfModelInput = document.getElementById('hf-model-name');
+    if (hfModelInput) currentConfig.hfModel = hfModelInput.value.trim();
+
+    const localApiBaseUrlInput = document.getElementById('local-api-base-url');
+    if (localApiBaseUrlInput) currentConfig.localApiBaseUrl = localApiBaseUrlInput.value.trim();
+
+    const localModelNameInput = document.getElementById('local-model-name');
+    if (localModelNameInput) currentConfig.localModelName = localModelNameInput.value.trim();
     
     const voiceReplyToggle = document.getElementById('enable-voice-reply');
     if (voiceReplyToggle) {
@@ -421,6 +530,11 @@ document.getElementById('save-btn').addEventListener('click', async () => {
         currentConfig.enableCustomWorkflows = enableWorkflowsToggle.checked;
     }
 
+    const enableAgentCollaborationToggle = document.getElementById('enable-agent-collaboration');
+    if (enableAgentCollaborationToggle) {
+        currentConfig.enableAgentCollaboration = enableAgentCollaborationToggle.checked;
+    }
+
     const showWidgetToggle = document.getElementById('show-desktop-widget');
     if (showWidgetToggle) {
         currentConfig.showDesktopWidget = showWidgetToggle.checked;

package/tests/agent_orchestrator.test.js

@@ -0,0 +1,41 @@
+/**
+ * Tests: agent_orchestrator.js
+ */
+
+const orchestrator = require('../src/AI_Brain/agent_orchestrator');
+
+describe('Agent Orchestrator', () => {
+    beforeEach(() => {
+        orchestrator.resetAgent();
+    });
+
+    test('starts with general agent', () => {
+        const agent = orchestrator.getCurrentAgent();
+        expect(agent.name).toBe('Mint Default');
+    });
+
+    test('can switch to coder agent', () => {
+        orchestrator.setAgent('coder');
+        const agent = orchestrator.getCurrentAgent();
+        expect(agent.name).toBe('Mint Coder');
+    });
+
+    test('can switch to researcher agent', () => {
+        orchestrator.setAgent('researcher');
+        const agent = orchestrator.getCurrentAgent();
+        expect(agent.name).toBe('Mint Researcher');
+    });
+
+    test('falls back to general for invalid agent', () => {
+        orchestrator.setAgent('nonexistent');
+        const agent = orchestrator.getCurrentAgent();
+        expect(agent.name).toBe('Mint Default');
+    });
+
+    test('lists available agents', () => {
+        const agents = orchestrator.listAgents();
+        expect(agents).toContain('general');
+        expect(agents).toContain('coder');
+        expect(agents).toContain('researcher');
+    });
+});

package/tests/chat_router.test.js

@@ -0,0 +1,42 @@
+/**
+ * Tests: chat_router routing helpers
+ */
+
+jest.mock('@google/genai', () => ({
+    GoogleGenAI: jest.fn()
+}));
+
+jest.mock('../src/CLI/code_agent', () => ({
+    executeCodeTask: jest.fn(),
+    _helpers: {
+        selectSupportedCodeProvider: jest.fn(() => 'gemini')
+    }
+}));
+
+jest.mock('../src/System/config_manager', () => ({
+    readConfig: jest.fn(() => ({})),
+    getAvailableProviders: jest.fn(() => ['gemini'])
+}));
+
+describe('chat_router helpers', () => {
+    test('recognizes direct folder open request as chat task', () => {
+        const { _helpers } = require('../src/CLI/chat_router');
+        expect(_helpers.isDirectFilesystemActionRequest('เปิดโฟลเดอร์ xidaidai ให้หน่อย')).toBe(true);
+    });
+
+    test('does not classify direct folder open request as code intent', () => {
+        const { _helpers } = require('../src/CLI/chat_router');
+        const route = _helpers.detectCodeIntentHeuristic('open folder xidaidai', process.cwd());
+        expect(route).toBe(false);
+    });
+
+    test('treats small file-related request as normal chat', () => {
+        const { _helpers } = require('../src/CLI/chat_router');
+        expect(_helpers.isLargeCodeTaskRequest('ดูไฟล์ package.json ให้หน่อย', process.cwd())).toBe(false);
+    });
+
+    test('treats substantial project fix request as code task', () => {
+        const { _helpers } = require('../src/CLI/chat_router');
+        expect(_helpers.isLargeCodeTaskRequest('fix the failing tests in this project and verify the result', process.cwd())).toBe(true);
+    });
+});

package/tests/code_agent.test.js

@@ -0,0 +1,69 @@
+/**
+ * Tests: code_agent helpers
+ */
+
+jest.mock('@google/genai', () => ({
+    GoogleGenAI: jest.fn()
+}));
+
+jest.mock('axios', () => ({}));
+
+jest.mock('../src/System/config_manager', () => ({
+    readConfig: jest.fn(() => ({})),
+    getAvailableProviders: jest.fn(() => ['ollama', 'gemini'])
+}));
+
+jest.mock('../src/CLI/code_session_memory', () => ({
+    readWorkspaceSession: jest.fn(() => ({
+        summary: '',
+        lastTask: '',
+        lastVerification: '',
+        updatedAt: null
+    })),
+    writeWorkspaceSession: jest.fn()
+}));
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+describe('code_agent helpers', () => {
+    test('extractJson recovers JSON embedded in surrounding text', () => {
+        const { _helpers } = require('../src/CLI/code_agent');
+        const parsed = _helpers.extractJson('note\n{"action":"finish","input":{"summary":"ok"}}\nthanks');
+        expect(parsed.action).toBe('finish');
+        expect(parsed.input.summary).toBe('ok');
+    });
+
+    test('selectSupportedCodeProvider falls back away from unsupported code providers', () => {
+        const { _helpers } = require('../src/CLI/code_agent');
+        const selected = _helpers.selectSupportedCodeProvider(
+            { aiProvider: 'ollama' },
+            ['ollama', 'openai', 'gemini']
+        );
+        expect(selected).toBe('openai');
+    });
+
+    test('selectSupportedCodeProvider keeps configured supported provider when available', () => {
+        const { _helpers } = require('../src/CLI/code_agent');
+        const selected = _helpers.selectSupportedCodeProvider(
+            { aiProvider: 'anthropic' },
+            ['anthropic', 'gemini']
+        );
+        expect(selected).toBe('anthropic');
+    });
+
+    test('findPaths can locate directories by partial name', async () => {
+        const { _helpers } = require('../src/CLI/code_agent');
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mint-code-agent-'));
+        const targetDir = path.join(tempDir, 'projects', 'xidaidai');
+        fs.mkdirSync(targetDir, { recursive: true });
+
+        try {
+            const result = await _helpers.findPaths(tempDir, 'xidaidai', 'dir');
+            expect(result).toContain('[dir] projects/xidaidai');
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+});

package/tests/config_manager.test.js

@@ -0,0 +1,141 @@
+/**
+ * Tests: config_manager.js
+ * Tests readConfig, writeConfig, and getAvailableProviders.
+ *
+ * Isolation strategy: spy on os.homedir() BEFORE requiring config_manager
+ * so CONFIG_DIR and CONFIG_PATH point to a temp directory, never touching
+ * the real ~/.config/mint/mint-config.json.
+ */
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+let tempDir;
+
+beforeEach(() => {
+    // 1. Reset module registry so config_manager re-initialises fresh each test
+    jest.resetModules();
+
+    // 2. Create an isolated temp dir for this test
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mint-cfg-test-'));
+
+    // 3. Mock os.homedir() BEFORE requiring config_manager.
+    //    config_manager computes CONFIG_DIR = os.homedir() + '/.config/mint'
+    //    at load time, so the spy must be active when the module first loads.
+    jest.spyOn(os, 'homedir').mockReturnValue(tempDir);
+});
+
+afterEach(() => {
+    jest.restoreAllMocks();
+    jest.resetModules();
+    fs.rmSync(tempDir, { recursive: true, force: true });
+});
+
+// Helper — always gets a fresh, isolated instance of config_manager
+function getModule() {
+    return require('../src/System/config_manager');
+}
+
+// ── readConfig ─────────────────────────────────────────────────────────────
+
+describe('config_manager — readConfig', () => {
+    test('returns DEFAULT_CONFIG when no config file exists', () => {
+        const { readConfig } = getModule();
+        const config = readConfig();
+        expect(config).toHaveProperty('geminiModel', 'gemini-2.5-flash');
+        expect(config).toHaveProperty('aiProvider', 'gemini');
+        expect(config).toHaveProperty('language', 'th-TH');
+    });
+
+    test('merges saved values with defaults (saved value wins)', () => {
+        const { readConfig, writeConfig } = getModule();
+        writeConfig({ geminiModel: 'gemini-2.0-pro' });
+        const config = readConfig();
+        expect(config.geminiModel).toBe('gemini-2.0-pro');
+        // Default fields still present
+        expect(config.aiProvider).toBe('gemini');
+        expect(config.language).toBe('th-TH');
+    });
+
+    test('missing keys in saved file are filled by defaults', () => {
+        const { readConfig, writeConfig } = getModule();
+        // Write a partial config (no 'ollamaModel' key)
+        writeConfig({ geminiModel: 'my-model' });
+        const config = readConfig();
+        expect(config.ollamaModel).toBe('llama3:latest'); // default
+    });
+});
+
+// ── writeConfig ────────────────────────────────────────────────────────────
+
+describe('config_manager — writeConfig', () => {
+    test('returns { success: true } on valid write', () => {
+        const { writeConfig } = getModule();
+        const result = writeConfig({ testKey: 'testValue' });
+        expect(result).toEqual({ success: true });
+    });
+
+    test('written JSON is readable back correctly', () => {
+        const { readConfig, writeConfig } = getModule();
+        writeConfig({ geminiModel: 'custom-model-test' });
+        const config = readConfig();
+        expect(config.geminiModel).toBe('custom-model-test');
+    });
+
+    test('config file is actually created on disk', () => {
+        const { writeConfig, CONFIG_PATH } = getModule();
+        writeConfig({ geminiModel: 'test' });
+        expect(fs.existsSync(CONFIG_PATH)).toBe(true);
+    });
+});
+
+// ── getAvailableProviders ──────────────────────────────────────────────────
+
+describe('config_manager — getAvailableProviders', () => {
+    test('always includes ollama (local, no key needed)', () => {
+        const { getAvailableProviders } = getModule();
+        expect(getAvailableProviders({})).toContain('ollama');
+    });
+
+    test('includes gemini when apiKey is set', () => {
+        const { getAvailableProviders } = getModule();
+        expect(getAvailableProviders({ apiKey: 'test-key' })).toContain('gemini');
+    });
+
+    test('includes anthropic when anthropicApiKey is set', () => {
+        const { getAvailableProviders } = getModule();
+        expect(getAvailableProviders({ anthropicApiKey: 'ant-key' })).toContain('anthropic');
+    });
+
+    test('includes openai when openaiApiKey is set', () => {
+        const { getAvailableProviders } = getModule();
+        expect(getAvailableProviders({ openaiApiKey: 'oai-key' })).toContain('openai');
+    });
+
+    test('includes huggingface when hfApiKey is set', () => {
+        const { getAvailableProviders } = getModule();
+        expect(getAvailableProviders({ hfApiKey: 'hf-key' })).toContain('huggingface');
+    });
+
+    test('includes local_openai when localApiBaseUrl is set', () => {
+        const { getAvailableProviders } = getModule();
+        expect(
+            getAvailableProviders({ localApiBaseUrl: 'http://localhost:1234/v1' })
+        ).toContain('local_openai');
+    });
+
+    test('does NOT include gemini when no key', () => {
+        const { getAvailableProviders } = getModule();
+        const savedEnv = process.env.GEMINI_API_KEY;
+        delete process.env.GEMINI_API_KEY;
+        const providers = getAvailableProviders({ apiKey: '' });
+        expect(providers).not.toContain('gemini');
+        if (savedEnv) process.env.GEMINI_API_KEY = savedEnv;
+    });
+
+    test('returns array type', () => {
+        const { getAvailableProviders } = getModule();
+        expect(Array.isArray(getAvailableProviders({}))).toBe(true);
+    });
+});

package/tests/docker.test.js

@@ -0,0 +1,46 @@
+/**
+ * Tests: docker.js plugin
+ */
+
+jest.mock('child_process', () => ({
+    execFile: jest.fn()
+}));
+
+let docker;
+let execFile;
+
+beforeEach(() => {
+    jest.resetModules();
+    ({ execFile } = require('child_process'));
+    execFile.mockReset();
+    docker = require('../src/Plugins/docker');
+});
+
+describe('Docker Plugin', () => {
+    test('lists running containers', async () => {
+        execFile.mockImplementation((command, args, callback) => {
+            callback(null, 'web (Up 2 hours)\n', '');
+        });
+
+        const result = await docker.execute('list');
+        expect(execFile).toHaveBeenCalledWith('docker', ['ps', '--format', '{{.Names}} ({{.Status}})'], expect.any(Function));
+        expect(result).toContain('Running Containers');
+        expect(result).toContain('web (Up 2 hours)');
+    });
+
+    test('starts a named container without shell interpolation', async () => {
+        execFile.mockImplementation((command, args, callback) => {
+            callback(null, '', '');
+        });
+
+        const result = await docker.execute('start my-app');
+        expect(execFile).toHaveBeenCalledWith('docker', ['start', 'my-app'], expect.any(Function));
+        expect(result).toContain('Successfully executed "docker start"');
+    });
+
+    test('returns helpful message when command is invalid', async () => {
+        const result = await docker.execute('remove my-app');
+        expect(result).toContain('Invalid docker command');
+        expect(execFile).not.toHaveBeenCalled();
+    });
+});