@jackwener/opencli 1.7.7 → 1.7.9

package/clis/cursor/composer.js

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { SelectorError } from '@jackwener/opencli/errors';
+import { selectorError } from '@jackwener/opencli/errors';
 export const composerCommand = cli({
     site: 'cursor',
     name: 'composer',
@@ -27,7 +27,7 @@ export const composerCommand = cli({
         return true;
       })(${JSON.stringify(textToInsert)})`);
         if (!typed) {
-            throw new SelectorError('Cursor Composer input element', 'Could not find Cursor Composer input element after pressing Cmd+I.');
+            throw selectorError('Cursor Composer input element', 'Could not find Cursor Composer input element after pressing Cmd+I.');
         }
         await page.wait(0.5);
         await page.pressKey('Enter');

package/clis/cursor/send.js

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { SelectorError } from '@jackwener/opencli/errors';
+import { selectorError } from '@jackwener/opencli/errors';
 export const sendCommand = cli({
     site: 'cursor',
     name: 'send',
@@ -24,7 +24,7 @@ export const sendCommand = cli({
         return true;
       })(${JSON.stringify(textToInsert)})`);
         if (!injected) {
-            throw new SelectorError('Cursor Composer input element');
+            throw selectorError('Cursor Composer input element');
         }
         // Submit the command. In Cursor, Enter usually submits the chat.
         await page.wait(0.5);

package/clis/deepseek/ask.js

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { CommandExecutionError } from '@jackwener/opencli/errors';
+import { CliError, CommandExecutionError, EXIT_CODES } from '@jackwener/opencli/errors';
 import {
     DEEPSEEK_DOMAIN, DEEPSEEK_URL, ensureOnDeepSeek, selectModel, setFeature,
     sendMessage, sendWithFile, getBubbleCount, waitForResponse, parseBoolFlag, withRetry,
@@ -18,7 +18,7 @@ export const askCommand = cli({
         { name: 'prompt', positional: true, required: true, help: 'Prompt to send' },
         { name: 'timeout', type: 'int', default: 120, help: 'Max seconds to wait for response' },
         { name: 'new', type: 'boolean', default: false, help: 'Start a new chat before sending' },
-        { name: 'model', default: 'instant', choices: ['instant', 'expert'], help: 'Model to use: instant or expert' },
+        { name: 'model', default: 'instant', choices: ['instant', 'expert', 'vision'], help: 'Model to use: instant, expert, or vision' },
         { name: 'think', type: 'boolean', default: false, help: 'Enable DeepThink mode' },
         { name: 'search', type: 'boolean', default: false, help: 'Enable web search' },
         { name: 'file', help: 'Attach a file (PDF, image, text) with the prompt' },
@@ -35,26 +35,65 @@ export const askCommand = cli({
             await page.goto(DEEPSEEK_URL);
             await page.wait(3);
         } else {
-            await ensureOnDeepSeek(page);
+            const navigated = await ensureOnDeepSeek(page);
+            if (navigated) {
+                // Workspace was recycled; try to resume the most recent
+                // conversation instead of starting a new one.
+                await page.evaluate(`(() => {
+                    var link = document.querySelector('a[href*="/a/chat/s/"]');
+                    if (link) link.click();
+                })()`);
+                await page.wait(2);
+            }
         }
 
         await page.wait(2);
 
+        // Model selector is only available on the new-chat page, not inside
+        // an existing conversation. Skip it when we resumed a prior thread.
+        const currentUrl = await page.evaluate('window.location.href') || '';
+        const inConversation = currentUrl.includes('/a/chat/s/');
+        const modelExplicit = kwargs.__opencliOptionSources?.model === 'cli';
+
         const wantModel = kwargs.model || 'instant';
-        const modelResult = await withRetry(() => selectModel(page, wantModel));
-        if (!modelResult?.ok) {
-            throw new CommandExecutionError(`Could not switch to ${wantModel} model`);
+        if (inConversation && modelExplicit) {
+            throw new CliError(
+                'ARGUMENT',
+                `Cannot switch to ${wantModel} model inside an existing conversation.`,
+                'Re-run with --new to start a fresh chat before selecting a model.',
+                EXIT_CODES.USAGE_ERROR,
+            );
+        }
+
+        if (!inConversation) {
+            const modelResult = await withRetry(() => selectModel(page, wantModel));
+            if (!modelResult?.ok) {
+                throw new CommandExecutionError(`Could not switch to ${wantModel} model`);
+            }
+            if (modelResult?.toggled) await page.wait(0.5);
         }
-        if (modelResult?.toggled) await page.wait(0.5);
 
         const thinkResult = await withRetry(() => setFeature(page, 'DeepThink', wantThink));
         if (!thinkResult?.ok && wantThink) {
             throw new CommandExecutionError('Could not enable DeepThink');
         }
 
-        const searchResult = await withRetry(() => setFeature(page, 'Search', wantSearch));
-        if (!searchResult?.ok && wantSearch) {
-            throw new CommandExecutionError('Could not enable Search');
+        if (wantModel === 'vision' && wantSearch) {
+            throw new CliError(
+                'ARGUMENT',
+                'DeepSeek vision mode does not support --search.',
+                'Run without --search, or use --model instant/expert for web search.',
+                EXIT_CODES.USAGE_ERROR,
+            );
+        }
+
+        // Vision mode does not have the search toggle.
+        let searchResult;
+        if (wantModel !== 'vision') {
+            searchResult = await withRetry(() => setFeature(page, 'Search', wantSearch));
+            if (!searchResult?.ok && wantSearch) {
+                throw new CommandExecutionError('Could not enable Search');
+            }
         }
 
         if (thinkResult?.toggled || searchResult?.toggled) await page.wait(0.5);

package/clis/deepseek/ask.test.js

@@ -1,5 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { CommandExecutionError } from '@jackwener/opencli/errors';
+import { CliError, CommandExecutionError, EXIT_CODES } from '@jackwener/opencli/errors';
 
 const {
   mockEnsureOnDeepSeek,
@@ -43,11 +43,13 @@ describe('deepseek ask --file', () => {
   const page = {
     wait: vi.fn().mockResolvedValue(undefined),
     goto: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn().mockResolvedValue('https://chat.deepseek.com/'),
   };
 
   beforeEach(() => {
     vi.clearAllMocks();
-    mockEnsureOnDeepSeek.mockResolvedValue(undefined);
+    page.evaluate.mockResolvedValue('https://chat.deepseek.com/');
+    mockEnsureOnDeepSeek.mockResolvedValue(false);
     mockSelectModel.mockResolvedValue({ ok: true, toggled: false });
     mockSetFeature.mockResolvedValue({ ok: true, toggled: false });
     mockSendWithFile.mockResolvedValue({ ok: true });
@@ -90,11 +92,13 @@ describe('deepseek ask --think', () => {
   const page = {
     wait: vi.fn().mockResolvedValue(undefined),
     goto: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn().mockResolvedValue('https://chat.deepseek.com/'),
   };
 
   beforeEach(() => {
     vi.clearAllMocks();
-    mockEnsureOnDeepSeek.mockResolvedValue(undefined);
+    page.evaluate.mockResolvedValue('https://chat.deepseek.com/');
+    mockEnsureOnDeepSeek.mockResolvedValue(false);
     mockSelectModel.mockResolvedValue({ ok: true, toggled: false });
     mockSetFeature.mockResolvedValue({ ok: true, toggled: false });
     mockSendMessage.mockResolvedValue({ ok: true });
@@ -163,3 +167,146 @@ describe('deepseek ask --think', () => {
     expect(Object.keys(rows[0])).toEqual(['response']);
   });
 });
+
+describe('deepseek ask conversation resume', () => {
+  const page = {
+    wait: vi.fn().mockResolvedValue(undefined),
+    goto: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn(),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockSetFeature.mockResolvedValue({ ok: true, toggled: false });
+    mockSendMessage.mockResolvedValue({ ok: true });
+    mockGetBubbleCount.mockResolvedValue(2);
+    mockWaitForResponse.mockResolvedValue('follow-up reply');
+  });
+
+  it('resumes the most recent conversation and skips model selection', async () => {
+    mockEnsureOnDeepSeek.mockResolvedValue(true);
+    // first evaluate: sidebar resume click (returns undefined)
+    page.evaluate.mockResolvedValueOnce(undefined);
+    // second evaluate: URL check (now inside a conversation)
+    page.evaluate.mockResolvedValueOnce('https://chat.deepseek.com/a/chat/s/abc-123');
+
+    const rows = await askCommand.func(page, {
+      prompt: 'follow up',
+      timeout: 120,
+      new: false,
+      model: 'instant',
+      think: false,
+      search: false,
+    });
+
+    expect(rows).toEqual([{ response: 'follow-up reply' }]);
+    expect(mockSelectModel).not.toHaveBeenCalled();
+    expect(mockSendMessage).toHaveBeenCalled();
+  });
+
+  it('skips model selection when already inside an existing conversation', async () => {
+    mockEnsureOnDeepSeek.mockResolvedValue(false);
+    page.evaluate.mockResolvedValue('https://chat.deepseek.com/a/chat/s/abc-123');
+
+    const rows = await askCommand.func(page, {
+      prompt: 'continue',
+      timeout: 120,
+      new: false,
+      model: 'expert',
+      think: false,
+      search: false,
+    });
+
+    expect(rows).toEqual([{ response: 'follow-up reply' }]);
+    expect(mockSelectModel).not.toHaveBeenCalled();
+  });
+
+  it('fails fast when --model is explicitly requested inside an existing conversation', async () => {
+    mockEnsureOnDeepSeek.mockResolvedValue(false);
+    page.evaluate.mockResolvedValue('https://chat.deepseek.com/a/chat/s/abc-123');
+
+    await expect(askCommand.func(page, {
+      prompt: 'continue',
+      timeout: 120,
+      new: false,
+      model: 'expert',
+      think: false,
+      search: false,
+      __opencliOptionSources: { model: 'cli' },
+    })).rejects.toMatchObject(new CliError(
+      'ARGUMENT',
+      'Cannot switch to expert model inside an existing conversation.',
+      'Re-run with --new to start a fresh chat before selecting a model.',
+      EXIT_CODES.USAGE_ERROR,
+    ));
+
+    expect(mockSelectModel).not.toHaveBeenCalled();
+  });
+
+  it('still selects model when no conversation to resume', async () => {
+    mockEnsureOnDeepSeek.mockResolvedValue(true);
+    mockSelectModel.mockResolvedValue({ ok: true, toggled: false });
+    // first evaluate: sidebar resume click (no link found)
+    page.evaluate.mockResolvedValueOnce(undefined);
+    // second evaluate: URL check (still on root page)
+    page.evaluate.mockResolvedValueOnce('https://chat.deepseek.com/');
+
+    const rows = await askCommand.func(page, {
+      prompt: 'hello',
+      timeout: 120,
+      new: false,
+      model: 'instant',
+      think: false,
+      search: false,
+    });
+
+    expect(rows).toEqual([{ response: 'follow-up reply' }]);
+    expect(mockSelectModel).toHaveBeenCalled();
+  });
+
+  it('skips search toggle in vision mode when search is not requested', async () => {
+    mockEnsureOnDeepSeek.mockResolvedValue(false);
+    mockSelectModel.mockResolvedValue({ ok: true, toggled: false });
+    mockSetFeature.mockResolvedValue({ ok: true, toggled: false });
+    mockSendMessage.mockResolvedValue({ ok: true });
+    mockGetBubbleCount.mockResolvedValue(0);
+    mockWaitForResponse.mockResolvedValue('vision reply');
+    page.evaluate.mockResolvedValue('https://chat.deepseek.com/');
+
+    const rows = await askCommand.func(page, {
+      prompt: 'describe',
+      timeout: 120,
+      new: false,
+      model: 'vision',
+      think: false,
+      search: false,
+    });
+
+    expect(rows).toEqual([{ response: 'vision reply' }]);
+    expect(mockSetFeature).toHaveBeenCalledTimes(1);
+    expect(mockSetFeature).toHaveBeenCalledWith(expect.anything(), 'DeepThink', false);
+  });
+
+  it('fails fast instead of silently ignoring --search in vision mode', async () => {
+    mockEnsureOnDeepSeek.mockResolvedValue(false);
+    mockSelectModel.mockResolvedValue({ ok: true, toggled: false });
+    page.evaluate.mockResolvedValue('https://chat.deepseek.com/');
+
+    await expect(askCommand.func(page, {
+      prompt: 'describe',
+      timeout: 120,
+      new: false,
+      model: 'vision',
+      think: false,
+      search: true,
+    })).rejects.toMatchObject(new CliError(
+      'ARGUMENT',
+      'DeepSeek vision mode does not support --search.',
+      'Run without --search, or use --model instant/expert for web search.',
+      EXIT_CODES.USAGE_ERROR,
+    ));
+
+    expect(mockSendMessage).not.toHaveBeenCalled();
+    expect(mockSendWithFile).not.toHaveBeenCalled();
+  });
+});

package/clis/deepseek/utils.js

@@ -15,10 +15,10 @@ export async function isOnDeepSeek(page) {
 }
 
 export async function ensureOnDeepSeek(page) {
-    if (!(await isOnDeepSeek(page))) {
-        await page.goto(DEEPSEEK_URL);
-        await page.wait(3);
-    }
+    if (await isOnDeepSeek(page)) return false;
+    await page.goto(DEEPSEEK_URL);
+    await page.wait(3);
+    return true;
 }
 
 export async function getPageState(page) {
@@ -40,9 +40,10 @@ export async function selectModel(page, modelName) {
     return page.evaluate(`(() => {
         var radios = document.querySelectorAll('div[role="radio"]');
         if (radios.length === 0) return { ok: false };
-        var isFirst = '${modelName}'.toLowerCase() === 'instant';
-        if (!isFirst && radios.length < 2) return { ok: false };
-        var target = isFirst ? radios[0] : radios[radios.length - 1];
+        var name = '${modelName}'.toLowerCase();
+        var index = name === 'instant' ? 0 : name === 'expert' ? 1 : name === 'vision' ? 2 : -1;
+        if (index < 0 || index >= radios.length) return { ok: false };
+        var target = radios[index];
         var alreadySelected = target.getAttribute('aria-checked') === 'true';
         if (!alreadySelected) target.click();
         return { ok: true, toggled: !alreadySelected };
@@ -74,14 +75,18 @@ export async function sendMessage(page, prompt) {
         document.execCommand('insertText', false, ${promptJson});
         await new Promise(r => setTimeout(r, 800));
 
-        const btns = document.querySelectorAll('div[role="button"]');
-        for (const btn of btns) {
-            if (btn.getAttribute('aria-disabled') === 'false') {
-                const svgs = btn.querySelectorAll('svg');
-                if (svgs.length > 0 && btn.closest('div')?.querySelector('textarea')) {
-                    btn.click();
-                    return { ok: true };
-                }
+        // Find the send button: last non-toggle button in the textarea's container
+        var container = box.parentElement;
+        while (container && !container.querySelector('div[role="button"]')) {
+            container = container.parentElement;
+        }
+        if (container) {
+            var btns = container.querySelectorAll('div[role="button"]:not(.ds-toggle-button)');
+            var sendBtn = btns[btns.length - 1];
+            if (sendBtn && sendBtn.getAttribute('aria-disabled') === 'false'
+                && sendBtn.querySelectorAll('svg').length > 0) {
+                sendBtn.click();
+                return { ok: true };
             }
         }
 
@@ -252,8 +257,7 @@ export async function getConversationList(page) {
             const items = [];
             const links = document.querySelectorAll('a[href*="/a/chat/s/"]');
             links.forEach((link, i) => {
-                const titleEl = link.querySelector('div');
-                const title = titleEl ? titleEl.textContent.trim() : '';
+                const title = (link.innerText || '').trim().split('\\n')[0].trim();
                 const href = link.getAttribute('href') || '';
                 const idMatch = href.match(/\\/s\\/([a-f0-9-]+)/);
                 items.push({
@@ -274,9 +278,18 @@ async function waitForFilePreview(page, fileName) {
     for (let attempt = 0; attempt < 8; attempt++) {
         await page.wait(2);
         const ready = await page.evaluate(`(() => {
-            const name = ${JSON.stringify(fileName)};
-            return Array.from(document.querySelectorAll('div'))
-                .some((el) => el.children.length === 0 && (el.textContent || '').trim() === name);
+            var name = ${JSON.stringify(fileName)};
+            var hasFileName = Array.from(document.querySelectorAll('div'))
+                .some(function(el) { return el.children.length === 0 && (el.textContent || '').trim() === name; });
+            if (hasFileName) return true;
+            // Vision mode shows an image thumbnail, not filename text. Require
+            // a preview-like node here; send-button readiness is checked later.
+            var box = document.querySelector('${TEXTAREA_SELECTOR}');
+            if (!box) return false;
+            var c = box.parentElement;
+            while (c && !c.querySelector('div[role="button"]')) c = c.parentElement;
+            if (!c) return false;
+            return !!c.querySelector('img[src], canvas, video, [style*="background-image"], [class*="preview"], [class*="upload"]');
         })()`);
         if (ready) return true;
     }
@@ -315,7 +328,7 @@ export async function sendWithFile(page, filePath, prompt) {
             uploaded = true;
         } catch (err) {
             const msg = String(err?.message || err);
-            if (!msg.includes('Unknown action') && !msg.includes('not supported')) {
+            if (!msg.includes('Unknown action') && !msg.includes('not supported') && !msg.includes('Not allowed')) {
                 throw err;
             }
         }
@@ -342,7 +355,8 @@ export async function sendWithFile(page, filePath, prompt) {
             }
 
             inp.files = dt.files;
-            inp[propsKey].onChange({ target: { files: dt.files } });
+            // Use inp.files, not dt.files; assignment transfers ownership
+            inp[propsKey].onChange({ target: { files: inp.files } });
             return { ok: true };
         })()`);
         if (fallbackResult && !fallbackResult.ok) return fallbackResult;
@@ -351,6 +365,30 @@ export async function sendWithFile(page, filePath, prompt) {
     const ready = await waitForFilePreview(page, fileName);
     if (!ready) return { ok: false, reason: 'file preview did not appear' };
 
+    // File preview appears immediately but send button stays disabled until
+    // the server upload finishes. Wait for it.
+    let sendEnabled = false;
+    for (let tick = 0; tick < 15; tick++) {
+        const enabled = await page.evaluate(`(() => {
+            var box = document.querySelector('${TEXTAREA_SELECTOR}');
+            if (!box) return false;
+            var c = box.parentElement;
+            while (c && !c.querySelector('div[role="button"]')) c = c.parentElement;
+            if (!c) return false;
+            var btns = c.querySelectorAll('div[role="button"]:not(.ds-toggle-button)');
+            var last = btns[btns.length - 1];
+            return !!(last && last.getAttribute('aria-disabled') === 'false');
+        })()`);
+        if (enabled) {
+            sendEnabled = true;
+            break;
+        }
+        await page.wait(1);
+    }
+    if (!sendEnabled) {
+        return { ok: false, reason: 'send button did not enable after upload' };
+    }
+
     return sendMessage(page, prompt);
 }
 

package/clis/deepseek/utils.test.js

@@ -107,15 +107,36 @@ describe('deepseek sendWithFile', () => {
       setFileInput: vi.fn().mockResolvedValue(undefined),
       wait: vi.fn().mockResolvedValue(undefined),
       evaluate: vi.fn()
-        .mockResolvedValueOnce(undefined)
-        .mockResolvedValueOnce(true)
-        .mockResolvedValueOnce({ ok: true }),
+        .mockResolvedValueOnce(undefined)    // sidebar collapse
+        .mockResolvedValueOnce(true)         // waitForFilePreview
+        .mockResolvedValueOnce(true)         // send button enabled check
+        .mockResolvedValueOnce({ ok: true }), // sendMessage
     };
 
     const result = await sendWithFile(page, filePath, 'summarize this');
 
-    expect(result).toEqual({ ok: true });
-    expect(page.setFileInput).toHaveBeenCalledWith([filePath], 'input[type="file"]');
+    expect(result).toEqual({ ok: true });    expect(page.setFileInput).toHaveBeenCalledWith([filePath], 'input[type="file"]');
+  });
+
+  it('fails closed when upload preview appears but send button never enables', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-deepseek-'));
+    tempDirs.push(dir);
+    const filePath = path.join(dir, 'report.txt');
+    fs.writeFileSync(filePath, 'hello');
+
+    const page = {
+      setFileInput: vi.fn().mockResolvedValue(undefined),
+      wait: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn()
+        .mockResolvedValueOnce(undefined) // sidebar collapse
+        .mockResolvedValueOnce(true)      // waitForFilePreview
+        .mockResolvedValue(false),        // send button never enables
+    };
+
+    const result = await sendWithFile(page, filePath, 'summarize this');
+
+    expect(result).toEqual({ ok: false, reason: 'send button did not enable after upload' });
+    expect(page.evaluate).toHaveBeenCalledTimes(17);
   });
 });
 
@@ -142,4 +163,102 @@ describe('deepseek selectModel', () => {
     expect(result).toEqual({ ok: false });
     expect(instantRadio.click).not.toHaveBeenCalled();
   });
+
+  it('selects the correct radio for each model', async () => {
+    const radios = [0, 1, 2].map(() => ({
+      getAttribute: vi.fn(() => 'false'),
+      click: vi.fn(),
+    }));
+    global.document = {
+      querySelectorAll: vi.fn(() => radios),
+    };
+    const page = {
+      evaluate: vi.fn(async (script) => eval(script)),
+    };
+
+    await selectModel(page, 'instant');
+    expect(radios[0].click).toHaveBeenCalled();
+    expect(radios[1].click).not.toHaveBeenCalled();
+    expect(radios[2].click).not.toHaveBeenCalled();
+
+    radios.forEach(r => r.click.mockClear());
+    await selectModel(page, 'expert');
+    expect(radios[1].click).toHaveBeenCalled();
+
+    radios.forEach(r => r.click.mockClear());
+    await selectModel(page, 'vision');
+    expect(radios[2].click).toHaveBeenCalled();
+  });
+
+  it('rejects unknown model names', async () => {
+    const radios = [0, 1, 2].map(() => ({
+      getAttribute: vi.fn(() => 'false'),
+      click: vi.fn(),
+    }));
+    global.document = {
+      querySelectorAll: vi.fn(() => radios),
+    };
+    const page = {
+      evaluate: vi.fn(async (script) => eval(script)),
+    };
+
+    const result = await selectModel(page, 'turbo');
+    expect(result).toEqual({ ok: false });
+  });
+});
+
+describe('deepseek sendWithFile Not allowed fallback', () => {
+  const tempDirs = [];
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    while (tempDirs.length) {
+      fs.rmSync(tempDirs.pop(), { recursive: true, force: true });
+    }
+  });
+
+  it('falls back to DataTransfer when setFileInput throws Not allowed', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-deepseek-'));
+    tempDirs.push(dir);
+    const filePath = path.join(dir, 'image.png');
+    fs.writeFileSync(filePath, 'fake-png');
+
+    const page = {
+      setFileInput: vi.fn().mockRejectedValue(new Error('Not allowed')),
+      wait: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn()
+        .mockResolvedValueOnce(undefined)    // sidebar collapse
+        .mockResolvedValueOnce({ ok: true }) // DataTransfer fallback
+        .mockResolvedValueOnce(true)         // waitForFilePreview
+        .mockResolvedValueOnce(true)         // send button enabled
+        .mockResolvedValueOnce({ ok: true }),// sendMessage
+    };
+
+    const result = await sendWithFile(page, filePath, 'describe');
+
+    expect(page.setFileInput).toHaveBeenCalled();
+    expect(page.evaluate).toHaveBeenCalledTimes(5);
+    expect(result).toEqual({ ok: true });
+  });
+
+  it('does not treat send-button enablement alone as image upload proof', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-deepseek-'));
+    tempDirs.push(dir);
+    const filePath = path.join(dir, 'image.png');
+    fs.writeFileSync(filePath, 'fake-png');
+
+    const page = {
+      setFileInput: vi.fn().mockResolvedValue(undefined),
+      wait: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn()
+        .mockResolvedValueOnce(undefined) // sidebar collapse
+        .mockResolvedValue(false),        // no filename / thumbnail preview
+    };
+
+    const result = await sendWithFile(page, filePath, 'describe');
+
+    expect(result).toEqual({ ok: false, reason: 'file preview did not appear' });
+    expect(page.evaluate.mock.calls[1][0]).toContain('img[src], canvas, video');
+    expect(page.evaluate.mock.calls[1][0]).not.toContain("aria-disabled') === 'false'");
+  });
 });