@pheem49/mint 1.4.0 → 1.4.1

package/src/CLI/chat_ui.js

@@ -90,11 +90,10 @@ function createChatUI({ onSubmit, onExit }) {
         style: { bg: 'default' }
     });
 
-    // ─── Input area ───────────────────────────────────────────────────────────
     const inputBox = blessed.textbox({
         bottom: 3, left: 1, width: '100%-2', height: 3,
         tags: false,
-        inputOnFocus: true,
+        inputOnFocus: false, // We'll manage this manually for stability
         keys: true,
         style: {
             bg: INPUT_BG,
@@ -111,6 +110,16 @@ function createChatUI({ onSubmit, onExit }) {
         label: ' Message '
     });
 
+    // --- SAFETY PATCH ---
+    // Prevent "TypeError: done is not a function" if a listener survives a blur/focus cycle.
+    const originalListener = inputBox._listener;
+    inputBox._listener = function(ch, key) {
+        if (typeof this._done !== 'function') return;
+        return originalListener.call(this, ch, key);
+    };
+
+
+
     // ─── Placeholder (SIBLING widget floating over input content area) ─────────
     // inputBox: bottom=3, height=3, border=1 → content row at bottom=4, left=2
     const placeholderWidget = blessed.text({
@@ -236,6 +245,7 @@ function createChatUI({ onSubmit, onExit }) {
 
     /** Update model name in status bar (called after /models switch) */
     function updateStatusModel(newModel) {
+        if (!newModel) return;
         statusRight.setContent(`{#88e0b0-fg}${newModel}{/}`);
         screen.render();
     }
@@ -284,7 +294,7 @@ function createChatUI({ onSubmit, onExit }) {
             border: { fg: '#88e0b0' }
         },
         width: '80%',
-        height: 'shrink',
+        height: 12, // Fixed height to avoid 'shrink' miscalculation with buttons
         top: 'center',
         left: 'center',
         label: ' Approval ',
@@ -381,26 +391,28 @@ function createChatUI({ onSubmit, onExit }) {
 
 
     // Submit or Select Suggestion on Enter
-    inputBox.key(['enter'], () => {
+    inputBox.on('submit', (value) => {
         if (!commandList.hidden) {
             const selected = activeSuggestions[commandList.selected];
             if (selected) {
                 inputBox.setValue(selected.name + ' ');
                 commandList.hide();
                 hidePlaceholder();
-                inputBox.focus();
+                inputBox.focus(); 
+                inputBox.readInput(); // Re-focus to continue typing
                 refreshInputStyles();
                 screen.render();
                 return; // Don't submit yet, let user add args or press enter again
             }
         }
 
-        const raw = (inputBox.getValue ? inputBox.getValue() : inputBox.value) || '';
+        const raw = value || '';
         const text = raw.trim();
         if (!text) {
             inputBox.clearValue();
             showPlaceholder();
-            inputBox.focus();
+            inputBox.focus(); 
+            inputBox.readInput(); // Re-focus to continue typing
             refreshInputStyles();
             screen.render();
             return;
@@ -409,7 +421,8 @@ function createChatUI({ onSubmit, onExit }) {
         // Clear input and restore placeholder
         inputBox.clearValue();
         showPlaceholder();
-        inputBox.focus();
+        inputBox.focus(); 
+        inputBox.readInput(); // Explicitly restart reading
         refreshInputStyles();
         screen.render();
 
@@ -486,6 +499,7 @@ function createChatUI({ onSubmit, onExit }) {
 
     // ─── Initial render ───────────────────────────────────────────────────────
     inputBox.focus();
+    inputBox.readInput(); // Initial start
     refreshInputStyles();
     screen.render();
 
@@ -691,18 +705,28 @@ function createChatUI({ onSubmit, onExit }) {
                 ? 'Shell Command'
                 : request.type === 'patch'
                     ? 'Patch Edit'
-                    : 'File Write';
+                    : request.type === 'code_mode'
+                        ? 'Enter Code Mode'
+                        : 'File Write';
             const preview = request.preview || request.label || '';
             const message = [
                 `{bold}${typeLabel}{/bold}`,
                 '',
                 preview,
                 '',
-                'Approve this action?'
+                'Approve this action?',
+                '', // Extra lines to push buttons down and avoid overlapping
+                ''
             ].join('\n');
 
+            // Temporarily stop reading input so the dialog can receive keys
+            if (inputBox._reading) {
+                inputBox.cancel();
+            }
+
             approvalDialog.ask(message, (approved) => {
                 inputBox.focus();
+                inputBox.readInput(); // Ensure we resume reading after dialog
                 refreshInputStyles();
                 screen.render();
                 resolve(Boolean(approved));

package/src/CLI/code_agent.js

@@ -11,6 +11,8 @@ const execFileAsync = promisify(execFile);
 const DEFAULT_GEMINI_MODEL = 'gemini-2.5-flash';
 const MAX_TOOL_OUTPUT = 12000;
 const MAX_AGENT_STEPS = 16;
+const MAX_JSON_REPAIR_ATTEMPTS = 2;
+const SUPPORTED_CODE_PROVIDERS = ['gemini', 'anthropic', 'openai', 'local_openai'];
 
 const CODE_AGENT_PROMPT = `You are Mint Code Mode, a careful coding agent for a local workspace.
 
@@ -31,10 +33,11 @@ Rules:
 Response format:
 {
   "thought": "short reasoning",
-  "action": "list_files" | "read_file" | "search_code" | "run_shell" | "apply_patch" | "write_file" | "finish",
+  "action": "list_files" | "read_file" | "search_code" | "find_path" | "run_shell" | "apply_patch" | "write_file" | "finish",
   "input": {
     "path": "relative/path",
     "query": "search text",
+    "type": "file" | "dir" | "any",
     "command": "shell command",
     "startLine": 1,
     "endLine": 120,
@@ -58,6 +61,7 @@ Tool notes:
 - "list_files": inspect the workspace or a subdirectory.
 - "read_file": read a file, optionally with startLine/endLine.
 - "search_code": search by text or regex-like pattern.
+- "find_path": find files or directories by path/name when the user is looking for a folder, filename, or location.
 - "run_shell": run a non-destructive command in the workspace.
 - "apply_patch": update an existing file using one or more exact replacement hunks.
 - "write_file": create a new file or fully rewrite a file when replacement is not practical.
@@ -81,6 +85,22 @@ function extractJson(text) {
     }
 }
 
+function selectSupportedCodeProvider(config, availableProviders = getAvailableProviders(config || {})) {
+    const requestedProvider = (config && config.aiProvider) || 'gemini';
+    if (SUPPORTED_CODE_PROVIDERS.includes(requestedProvider) && availableProviders.includes(requestedProvider)) {
+        return requestedProvider;
+    }
+
+    const priority = ['anthropic', 'openai', 'gemini', 'local_openai'];
+    for (const provider of priority) {
+        if (availableProviders.includes(provider)) {
+            return provider;
+        }
+    }
+
+    return 'gemini';
+}
+
 function resolveWorkspacePath(workspaceRoot, targetPath = '.') {
     const resolved = path.resolve(workspaceRoot, targetPath);
     const relative = path.relative(workspaceRoot, resolved);
@@ -160,6 +180,40 @@ async function searchCode(workspaceRoot, query) {
     }
 }
 
+async function findPaths(workspaceRoot, query, type = 'any') {
+    if (!query || !query.trim()) {
+        throw new Error('Path search query is required.');
+    }
+
+    const normalizedType = ['file', 'dir', 'any'].includes(type) ? type : 'any';
+    const loweredQuery = query.trim().toLowerCase();
+    const results = [];
+
+    function visit(currentPath) {
+        const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const absoluteEntryPath = path.join(currentPath, entry.name);
+            const relativeEntryPath = path.relative(workspaceRoot, absoluteEntryPath) || '.';
+            const entryType = entry.isDirectory() ? 'dir' : 'file';
+            const matchesType = normalizedType === 'any' || normalizedType === entryType;
+            const matchesQuery = entry.name.toLowerCase().includes(loweredQuery) || relativeEntryPath.toLowerCase().includes(loweredQuery);
+
+            if (matchesType && matchesQuery) {
+                results.push(`${entryType === 'dir' ? '[dir]' : '[file]'} ${relativeEntryPath}`);
+                if (results.length >= 200) return;
+            }
+
+            if (entry.isDirectory() && results.length < 200) {
+                visit(absoluteEntryPath);
+                if (results.length >= 200) return;
+            }
+        }
+    }
+
+    visit(workspaceRoot);
+    return results.length > 0 ? results.join('\n') : '(no matching paths)';
+}
+
 function assertSafeShell(command) {
     const blockedPatterns = [
         /\brm\s+-rf\b/,
@@ -247,7 +301,7 @@ function writeFile(workspaceRoot, targetPath, content) {
 
 class UnifiedAgentClient {
     constructor(provider, config) {
-        this.provider = provider;
+        this.provider = SUPPORTED_CODE_PROVIDERS.includes(provider) ? provider : 'gemini';
         this.config = config;
         this.history = [];
         this.systemInstruction = CODE_AGENT_PROMPT;
@@ -342,6 +396,29 @@ class UnifiedAgentClient {
     }
 }
 
+async function getAgentDecision(client, observation, options = {}) {
+    const onProgress = typeof options.onProgress === 'function' ? options.onProgress : () => {};
+    const step = options.step || 0;
+
+    let rawText = await client.sendMessage(observation);
+    for (let attempt = 0; attempt <= MAX_JSON_REPAIR_ATTEMPTS; attempt++) {
+        try {
+            return extractJson(rawText);
+        } catch (error) {
+            if (attempt === MAX_JSON_REPAIR_ATTEMPTS) {
+                throw new Error(`Agent returned invalid JSON after ${MAX_JSON_REPAIR_ATTEMPTS + 1} attempts: ${error.message}`);
+            }
+
+            onProgress(`Step ${step}: invalid JSON response, requesting repair (${attempt + 1}/${MAX_JSON_REPAIR_ATTEMPTS})`);
+            rawText = await client.sendMessage([
+                'Your previous response was not valid JSON for Code Mode.',
+                'Reply again with valid JSON only, following the required schema exactly.',
+                `Previous response:\n${truncate(rawText, 4000)}`
+            ].join('\n'));
+        }
+    }
+}
+
 function detectPackageManager(workspaceRoot) {
     if (fs.existsSync(path.join(workspaceRoot, 'package-lock.json'))) return 'npm';
     if (fs.existsSync(path.join(workspaceRoot, 'pnpm-lock.yaml'))) return 'pnpm';
@@ -384,12 +461,17 @@ async function getGitContext(workspaceRoot) {
     return { isRepo: true, branch, status, diffSummary };
 }
 
-async function buildInitialObservation(task, workspaceRoot) {
+async function buildInitialObservation(task, workspaceRoot, history = []) {
     const session = readWorkspaceSession(workspaceRoot);
     const gitContext = await getGitContext(workspaceRoot);
     const testCommands = detectTestCommands(workspaceRoot);
 
+    const contextStr = history.length > 0 
+        ? `Recent Context:\n${history.slice(-10).map(m => `${m.sender}: ${m.text}`).join('\n')}\n`
+        : '';
+
     return [
+        contextStr,
         `Task: ${task}`,
         `Workspace: ${workspaceRoot}`,
         `Git branch: ${gitContext.branch}`,
@@ -409,24 +491,26 @@ async function buildInitialObservation(task, workspaceRoot) {
 
 async function executeCodeTask(task, options = {}) {
     const workspaceRoot = path.resolve(options.cwd || process.cwd());
+    const history = options.history || [];
     const onProgress = typeof options.onProgress === 'function' ? options.onProgress : () => {};
     const requestApproval = typeof options.requestApproval === 'function'
         ? options.requestApproval
         : async () => true;
     const config = readConfig();
-    const provider = options.provider || 'gemini';
+    const provider = options.provider || selectSupportedCodeProvider(config);
     const client = new UnifiedAgentClient(provider, config);
 
-    let observation = await buildInitialObservation(task, workspaceRoot);
+    let observation = await buildInitialObservation(task, workspaceRoot, history);
 
     let finalSummary = '';
     let finalVerification = '';
     let finalSessionSummary = '';
+    let executedSteps = 0;
 
     for (let step = 1; step <= MAX_AGENT_STEPS; step++) {
+        executedSteps = step;
         onProgress(`Step ${step}: thinking`);
-        const text = await client.sendMessage(observation);
-        const decision = extractJson(text);
+        const decision = await getAgentDecision(client, observation, { onProgress, step });
         const action = decision.action;
         const input = decision.input || {};
 
@@ -455,6 +539,9 @@ async function executeCodeTask(task, options = {}) {
             case 'search_code':
                 toolResult = await searchCode(workspaceRoot, input.query);
                 break;
+            case 'find_path':
+                toolResult = await findPaths(workspaceRoot, input.query, input.type);
+                break;
             case 'run_shell': {
                 const approved = await requestApproval({
                     type: 'shell',
@@ -510,9 +597,15 @@ async function executeCodeTask(task, options = {}) {
     // Check for Agent Collaboration (Review)
     if (config.enableAgentCollaboration !== false) {
         const availableProviders = getAvailableProviders(config);
-        const altProviders = availableProviders.filter(p => p !== provider && p !== 'ollama' && p !== 'huggingface');
-        if (altProviders.length > 0 && finalSummary) {
-            const reviewerProvider = altProviders[0];
+        // Exclude providers that often need special local setup or are slow/unreliable for tiny reviews
+        const altProviders = availableProviders.filter(p => p !== provider && p !== 'ollama' && p !== 'huggingface' && p !== 'local_openai');
+        
+        // Fallback to provider itself if no other good ones exist, or pick the best available
+        const reviewerProvider = altProviders.length > 0 
+            ? altProviders[0] 
+            : (availableProviders.includes('gemini') ? 'gemini' : availableProviders[0]);
+
+        if (reviewerProvider && finalSummary) {
             onProgress(`Invoking Reviewer Agent (${reviewerProvider})...`);
             
             const reviewerClient = new UnifiedAgentClient(reviewerProvider, config);
@@ -536,7 +629,7 @@ async function executeCodeTask(task, options = {}) {
         return {
             summary: finalSummary,
             verification: finalVerification,
-            steps: MAX_AGENT_STEPS
+            steps: executedSteps
         };
     }
 
@@ -549,8 +642,15 @@ async function executeCodeTask(task, options = {}) {
     return {
         summary: 'Stopped after reaching the maximum number of agent steps.',
         verification: 'Agent limit reached before explicit completion.',
-        steps: MAX_AGENT_STEPS
+        steps: executedSteps || MAX_AGENT_STEPS
     };
 }
 
-module.exports = { executeCodeTask };
+module.exports = {
+    executeCodeTask,
+    _helpers: {
+        extractJson,
+        selectSupportedCodeProvider,
+        findPaths
+    }
+};

package/src/CLI/workspace_manager.js

@@ -9,26 +9,35 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
-const WORKSPACE_FILE = path.join(os.homedir(), '.config', 'mint', 'workspaces.json');
+function getWorkspaceFile() {
+    return process.env.MINT_WORKSPACE_FILE || path.join(os.homedir(), '.config', 'mint', 'workspaces.json');
+}
 
 function ensureDir() {
-    const dir = path.dirname(WORKSPACE_FILE);
+    const dir = path.dirname(getWorkspaceFile());
     if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
 }
 
 function loadWorkspaces() {
+    const workspaceFile = getWorkspaceFile();
     ensureDir();
-    if (!fs.existsSync(WORKSPACE_FILE)) return {};
+    if (!fs.existsSync(workspaceFile)) return {};
     try {
-        return JSON.parse(fs.readFileSync(WORKSPACE_FILE, 'utf8'));
+        return JSON.parse(fs.readFileSync(workspaceFile, 'utf8'));
     } catch (e) {
         return {};
     }
 }
 
 function saveWorkspaces(data) {
+    const workspaceFile = getWorkspaceFile();
     ensureDir();
-    fs.writeFileSync(WORKSPACE_FILE, JSON.stringify(data, null, 2));
+    fs.writeFileSync(workspaceFile, JSON.stringify(data, null, 2));
+}
+
+function isPathInsideWorkspace(currentPath, workspacePath) {
+    const relative = path.relative(workspacePath, currentPath);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
 }
 
 function addWorkspace(name, rootPath, instructions = '') {
@@ -62,7 +71,7 @@ function getWorkspaceByPath(currentPath) {
     // Find workspace where current path is inside or equal to workspace path
     for (const name in workspaces) {
         const ws = workspaces[name];
-        if (absoluteCurrent.startsWith(ws.path)) {
+        if (isPathInsideWorkspace(absoluteCurrent, ws.path)) {
             return ws;
         }
     }

package/src/Plugins/docker.js

@@ -1,4 +1,4 @@
-const { exec } = require('child_process');
+const { execFile } = require('child_process');
 
 module.exports = {
     name: 'docker',
@@ -8,28 +8,30 @@ module.exports = {
         return new Promise((resolve) => {
             console.log(`[Docker Plugin] Executing command: ${target}`);
             
-            const [action, ...args] = target.toLowerCase().split(' ');
+            const rawTarget = (target || '').trim();
+            const [rawAction, ...args] = rawTarget.split(/\s+/);
+            const action = (rawAction || '').toLowerCase();
             const containerName = args.join(' ');
-
-            let cmd = '';
+            let commandArgs = [];
             
             if (action === 'list') {
-                cmd = 'docker ps --format "{{.Names}} ({{.Status}})"';
+                commandArgs = ['ps', '--format', '{{.Names}} ({{.Status}})'];
             } else if (['start', 'stop', 'restart'].includes(action) && containerName) {
-                cmd = `docker ${action} ${containerName}`;
+                commandArgs = [action, containerName];
             } else {
                 return resolve(`Invalid docker command or missing container name: ${target}`);
             }
 
-            exec(cmd, (error, stdout, stderr) => {
+            execFile('docker', commandArgs, (error, stdout, stderr) => {
                 if (error) {
-                    if (error.code === 127 || stderr.includes('not found')) {
+                    const stderrText = stderr || '';
+                    if (error.code === 127 || stderrText.includes('not found') || error.code === 'ENOENT') {
                         return resolve('Error: Docker is not installed or not in PATH.');
                     }
-                    if (stderr.includes('permission denied')) {
+                    if (stderrText.toLowerCase().includes('permission denied')) {
                         return resolve('Error: Permission denied. You might need to add your user to the "docker" group.');
                     }
-                    return resolve(`Docker Error: ${stderr || error.message}`);
+                    return resolve(`Docker Error: ${stderrText || error.message}`);
                 }
 
                 if (action === 'list') {

package/src/System/custom_workflows.js

@@ -3,6 +3,10 @@ const path = require('path');
 const { app, shell } = require('electron');
 const { exec } = require('child_process');
 
+function escapeRegExp(text) {
+    return String(text).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
 class CustomWorkflows {
     constructor() {
         this.configPath = path.join(app.getPath('userData'), 'workflows.json');
@@ -86,7 +90,7 @@ class CustomWorkflows {
                     if (wf.trigger && wf.trigger.type === 'process_running' && wf.trigger.processName) {
                         const targetName = wf.trigger.processName.toLowerCase();
                         // simplistic exact-word match to avoid partial matches
-                        const regex = new RegExp(`^${targetName}$`, 'm');
+                        const regex = new RegExp(`^${escapeRegExp(targetName)}$`, 'm');
                         const isRunning = regex.test(runningProcesses);
                         
                         if (isRunning) {
@@ -124,4 +128,7 @@ class CustomWorkflows {
     }
 }
 
-module.exports = new CustomWorkflows();
+const instance = new CustomWorkflows();
+instance._helpers = { escapeRegExp };
+
+module.exports = instance;

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/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();
+    });
+});