feat(deepseek): add file upload support via --file flag (#1093)

* WIP: deepseek file upload (blocked by 30s idle timeout)

* feat(deepseek): add file upload support via --file flag

Closes #1092

* fix(deepseek): use native file input path for --file

---------

Co-authored-by: Benjamin Liu <beneecs@Benjamins-Mac-mini.local>
Co-authored-by: jackwener <jakevingoo@gmail.com>

Author: 3 people

cli-manifest.json

@@ -4118,6 +4118,12 @@
         "default": false,
         "required": false,
         "help": "Enable web search"
+      },
+      {
+        "name": "file",
+        "type": "str",
+        "required": false,
+        "help": "Attach a file (PDF, image, text) with the prompt"
       }
     ],
     "columns": [

clis/deepseek/ask.js

@@ -2,7 +2,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 import { CommandExecutionError } from '@jackwener/opencli/errors';
 import {
     DEEPSEEK_DOMAIN, DEEPSEEK_URL, ensureOnDeepSeek, selectModel, setFeature,
-    sendMessage, getBubbleCount, waitForResponse, parseBoolFlag, withRetry,
+    sendMessage, sendWithFile, getBubbleCount, waitForResponse, parseBoolFlag, withRetry,
 } from './utils.js';
 
 export const askCommand = cli({
@@ -21,6 +21,7 @@ export const askCommand = cli({
         { name: 'model', default: 'instant', choices: ['instant', 'expert'], help: 'Model to use: instant or expert' },
         { 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' },
     ],
     columns: ['response'],
 
@@ -58,6 +59,25 @@ export const askCommand = cli({
 
         if (thinkResult.toggled || searchResult.toggled) await page.wait(0.5);
 
+        if (kwargs.file) {
+            const baseline = await withRetry(() => getBubbleCount(page));
+            try {
+                const fileResult = await sendWithFile(page, kwargs.file, prompt);
+                if (fileResult && !fileResult.ok) {
+                    throw new CommandExecutionError(fileResult.reason || 'Failed to attach file');
+                }
+            } catch (err) {
+                // SPA navigates after send; "Promise was collected" means send succeeded
+                if (!String(err?.message || err).includes('Promise was collected')) throw err;
+            }
+            await page.wait(3);
+            const response = await waitForResponse(page, baseline, prompt, timeoutMs);
+            if (!response) {
+                return [{ response: `[NO RESPONSE] No reply within ${kwargs.timeout}s.` }];
+            }
+            return [{ response }];
+        }
+
         const baseline = await withRetry(() => getBubbleCount(page));
         const sendResult = await withRetry(() => sendMessage(page, prompt));
         if (!sendResult?.ok) {

clis/deepseek/ask.test.js

@@ -0,0 +1,73 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const {
+  mockEnsureOnDeepSeek,
+  mockSelectModel,
+  mockSetFeature,
+  mockSendMessage,
+  mockSendWithFile,
+  mockGetBubbleCount,
+  mockWaitForResponse,
+  mockParseBoolFlag,
+  mockWithRetry,
+} = vi.hoisted(() => ({
+  mockEnsureOnDeepSeek: vi.fn(),
+  mockSelectModel: vi.fn(),
+  mockSetFeature: vi.fn(),
+  mockSendMessage: vi.fn(),
+  mockSendWithFile: vi.fn(),
+  mockGetBubbleCount: vi.fn(),
+  mockWaitForResponse: vi.fn(),
+  mockParseBoolFlag: vi.fn((v) => v === true || v === 'true'),
+  mockWithRetry: vi.fn(async (fn) => fn()),
+}));
+
+vi.mock('./utils.js', () => ({
+  DEEPSEEK_DOMAIN: 'chat.deepseek.com',
+  DEEPSEEK_URL: 'https://chat.deepseek.com/',
+  ensureOnDeepSeek: mockEnsureOnDeepSeek,
+  selectModel: mockSelectModel,
+  setFeature: mockSetFeature,
+  sendMessage: mockSendMessage,
+  sendWithFile: mockSendWithFile,
+  getBubbleCount: mockGetBubbleCount,
+  waitForResponse: mockWaitForResponse,
+  parseBoolFlag: mockParseBoolFlag,
+  withRetry: mockWithRetry,
+}));
+
+import { askCommand } from './ask.js';
+
+describe('deepseek ask --file', () => {
+  const page = {
+    wait: vi.fn().mockResolvedValue(undefined),
+    goto: vi.fn().mockResolvedValue(undefined),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockEnsureOnDeepSeek.mockResolvedValue(undefined);
+    mockSelectModel.mockResolvedValue({ ok: true, toggled: false });
+    mockSetFeature.mockResolvedValue({ ok: true, toggled: false });
+    mockSendWithFile.mockResolvedValue({ ok: true });
+    mockGetBubbleCount.mockResolvedValue(7);
+    mockWaitForResponse.mockResolvedValue('new reply');
+  });
+
+  it('captures the existing baseline before sending a file prompt', async () => {
+    const rows = await askCommand.func(page, {
+      prompt: 'summarize this',
+      timeout: 120,
+      file: './report.pdf',
+      new: false,
+      model: 'instant',
+      think: false,
+      search: false,
+    });
+
+    expect(rows).toEqual([{ response: 'new reply' }]);
+    expect(mockGetBubbleCount).toHaveBeenCalledTimes(1);
+    expect(mockSendWithFile).toHaveBeenCalledWith(page, './report.pdf', 'summarize this');
+    expect(mockWaitForResponse).toHaveBeenCalledWith(page, 7, 'summarize this', 120000);
+  });
+});

clis/deepseek/utils.js

@@ -161,7 +161,6 @@ export async function getConversationList(page) {
             if (btn) btn.click();
         }
     })()`);
-    // Poll for sidebar history links to render
     for (let attempt = 0; attempt < 5; attempt++) {
         await page.wait(2);
         const items = await page.evaluate(`(() => {
@@ -186,6 +185,90 @@ export async function getConversationList(page) {
     return [];
 }
 
+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);
+        })()`);
+        if (ready) return true;
+    }
+    return false;
+}
+
+export async function sendWithFile(page, filePath, prompt) {
+    const fs = await import('node:fs');
+    const path = await import('node:path');
+    const absPath = path.default.resolve(filePath);
+
+    if (!fs.default.existsSync(absPath)) {
+        return { ok: false, reason: `File not found: ${absPath}` };
+    }
+
+    const stats = fs.default.statSync(absPath);
+    if (stats.size > 100 * 1024 * 1024) {
+        return { ok: false, reason: `File too large (${(stats.size / 1024 / 1024).toFixed(1)} MB). Max: 100 MB` };
+    }
+
+    const fileName = path.default.basename(absPath);
+
+    // Collapse sidebar to keep DOM simple for send button matching
+    await page.evaluate(`(() => {
+        if (document.querySelectorAll('a[href*="/a/chat/s/"]').length > 0) {
+            const btn = document.querySelector('div[tabindex="0"][role="button"]');
+            if (btn) btn.click();
+        }
+    })()`);
+    await page.wait(0.5);
+
+    let uploaded = false;
+    if (page.setFileInput) {
+        try {
+            await page.setFileInput([absPath], 'input[type="file"]');
+            uploaded = true;
+        } catch (err) {
+            const msg = String(err?.message || err);
+            if (!msg.includes('Unknown action') && !msg.includes('not supported')) {
+                throw err;
+            }
+        }
+    }
+
+    if (!uploaded) {
+        const content = fs.default.readFileSync(absPath);
+        const base64 = content.toString('base64');
+        const fallbackResult = await page.evaluate(`(async () => {
+            var binary = atob('${base64}');
+            var bytes = new Uint8Array(binary.length);
+            for (var i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+
+            var file = new File([bytes], ${JSON.stringify(fileName)});
+            var dt = new DataTransfer();
+            dt.items.add(file);
+
+            var inp = document.querySelector('input[type="file"]');
+            if (!inp) return { ok: false, reason: 'file input not found' };
+
+            var propsKey = Object.keys(inp).find(function(k) { return k.startsWith('__reactProps$'); });
+            if (!propsKey || typeof inp[propsKey].onChange !== 'function') {
+                return { ok: false, reason: 'React onChange not found' };
+            }
+
+            inp.files = dt.files;
+            inp[propsKey].onChange({ target: { files: dt.files } });
+            return { ok: true };
+        })()`);
+        if (fallbackResult && !fallbackResult.ok) return fallbackResult;
+    }
+
+    const ready = await waitForFilePreview(page, fileName);
+    if (!ready) return { ok: false, reason: 'file preview did not appear' };
+
+    return sendMessage(page, prompt);
+}
+
 // Retries on CDP "Promise was collected" errors caused by DeepSeek's SPA router transitions.
 export async function withRetry(fn, retries = 2) {
     for (let i = 0; i <= retries; i++) {

clis/deepseek/utils.test.js

@@ -0,0 +1,37 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { sendWithFile } from './utils.js';
+
+describe('deepseek sendWithFile', () => {
+  const tempDirs = [];
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    while (tempDirs.length) {
+      fs.rmSync(tempDirs.pop(), { recursive: true, force: true });
+    }
+  });
+
+  it('prefers page.setFileInput over base64-in-evaluate when supported', 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)
+        .mockResolvedValueOnce(true)
+        .mockResolvedValueOnce({ ok: true }),
+    };
+
+    const result = await sendWithFile(page, filePath, 'summarize this');
+
+    expect(result).toEqual({ ok: true });
+    expect(page.setFileInput).toHaveBeenCalledWith([filePath], 'input[type="file"]');
+  });
+});

docs/adapters/browser/deepseek.md

@@ -30,6 +30,9 @@ opencli deepseek ask "prove that sqrt(2) is irrational" --think
 # Enable web search
 opencli deepseek ask "latest news about AI" --search
 
+# Attach a file
+opencli deepseek ask "summarize this document" --file ./report.pdf
+
 # Combine modes
 opencli deepseek ask "what happened today?" --model expert --think --search --new
 
@@ -62,6 +65,7 @@ opencli deepseek history --limit 10
 | `--model` | Model to use: `instant` or `expert` (default: instant) |
 | `--think` | Enable DeepThink mode (default: false) |
 | `--search` | Enable web search (default: false) |
+| `--file` | Attach a file (PDF, image, text) with the prompt (max 100 MB) |
 
 ## Prerequisites
 
@@ -73,4 +77,4 @@ opencli deepseek history --limit 10
 - This adapter drives the DeepSeek web UI in the browser, not an API
 - Default mode is Instant with DeepThink and Search disabled; each flag (`--model`, `--think`, `--search`) is synced on every invocation so omitting a flag resets it
 - Long responses (code, essays) may need a higher `--timeout`
-- File upload is not yet supported
+- File upload reads the file into memory and passes it via base64 to the browser; files over 100 MB are rejected