@jackwener/opencli 1.6.1 → 1.6.2

package/dist/clis/twitter/post.js

@@ -1,5 +1,29 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { cli, Strategy } from '../../registry.js';
 import { CommandExecutionError } from '../../errors.js';
+const MAX_IMAGES = 4;
+const UPLOAD_POLL_MS = 500;
+const UPLOAD_TIMEOUT_MS = 30_000;
+const SUPPORTED_EXTENSIONS = new Set(['.jpg', '.jpeg', '.png', '.gif', '.webp']);
+function validateImagePaths(raw) {
+    const paths = raw.split(',').map(s => s.trim()).filter(Boolean);
+    if (paths.length > MAX_IMAGES) {
+        throw new CommandExecutionError(`Too many images: ${paths.length} (max ${MAX_IMAGES})`);
+    }
+    return paths.map(p => {
+        const absPath = path.resolve(p);
+        const ext = path.extname(absPath).toLowerCase();
+        if (!SUPPORTED_EXTENSIONS.has(ext)) {
+            throw new CommandExecutionError(`Unsupported image format "${ext}". Supported: jpg, png, gif, webp`);
+        }
+        const stat = fs.statSync(absPath, { throwIfNoEntry: false });
+        if (!stat || !stat.isFile()) {
+            throw new CommandExecutionError(`Not a valid file: ${absPath}`);
+        }
+        return absPath;
+    });
+}
 cli({
     site: 'twitter',
     name: 'post',
@@ -9,63 +33,66 @@ cli({
     browser: true,
     args: [
         { name: 'text', type: 'string', required: true, positional: true, help: 'The text content of the tweet' },
+        { name: 'images', type: 'string', required: false, help: 'Image paths, comma-separated, max 4 (jpg/png/gif/webp)' },
     ],
     columns: ['status', 'message', 'text'],
     func: async (page, kwargs) => {
         if (!page)
             throw new CommandExecutionError('Browser session required for twitter post');
-        // 1. Navigate directly to the compose tweet modal
+        // Validate images upfront before any browser interaction
+        const absPaths = kwargs.images ? validateImagePaths(String(kwargs.images)) : [];
+        // 1. Navigate to compose modal
         await page.goto('https://x.com/compose/tweet');
-        await page.wait(3); // Wait for the modal and React app to hydrate
-        // 2. Automate typing and clicking
-        const result = await page.evaluate(`(async () => {
+        await page.wait(3);
+        // 2. Type the text via clipboard paste (handles newlines in Draft.js)
+        const typeResult = await page.evaluate(`(async () => {
         try {
-            // Find the active text area
             const box = document.querySelector('[data-testid="tweetTextarea_0"]');
-            if (box) {
-                box.focus();
-                // Simulate a paste event to properly handle newlines in Draft.js/React
-                const textToInsert = ${JSON.stringify(kwargs.text)};
-                const dataTransfer = new DataTransfer();
-                dataTransfer.setData('text/plain', textToInsert);
-                box.dispatchEvent(new ClipboardEvent('paste', {
-                    clipboardData: dataTransfer,
-                    bubbles: true,
-                    cancelable: true
-                }));
-            } else {
-                return { ok: false, message: 'Could not find the tweet composer text area.' };
+            if (!box) return { ok: false, message: 'Could not find the tweet composer text area.' };
+            box.focus();
+            const dt = new DataTransfer();
+            dt.setData('text/plain', ${JSON.stringify(kwargs.text)});
+            box.dispatchEvent(new ClipboardEvent('paste', { clipboardData: dt, bubbles: true, cancelable: true }));
+            return { ok: true };
+        } catch (e) { return { ok: false, message: String(e) }; }
+    })()`);
+        if (!typeResult.ok) {
+            return [{ status: 'failed', message: typeResult.message, text: kwargs.text }];
+        }
+        // 3. Attach images if provided
+        if (absPaths.length > 0) {
+            if (!page.setFileInput) {
+                throw new CommandExecutionError('Browser extension does not support file upload. Please update the extension.');
             }
-            
-            // Wait a brief moment for the button state to update
-            await new Promise(r => setTimeout(r, 1000));
-            
-            // Click the post button
-            const btn = document.querySelector('[data-testid="tweetButton"]');
-            if (btn && !btn.disabled) {
-                btn.click();
-                return { ok: true, message: 'Tweet posted successfully.' };
-            } else {
-                // Sometimes it's rendered inline depending on the viewport
-                const inlineBtn = document.querySelector('[data-testid="tweetButtonInline"]');
-                if (inlineBtn && !inlineBtn.disabled) {
-                    inlineBtn.click();
-                    return { ok: true, message: 'Tweet posted successfully.' };
-                }
-                return { ok: false, message: 'Tweet button is disabled or not found.' };
+            await page.setFileInput(absPaths, 'input[data-testid="fileInput"]');
+            // Poll until attachments render and tweet button is enabled
+            const pollIterations = Math.ceil(UPLOAD_TIMEOUT_MS / UPLOAD_POLL_MS);
+            const uploaded = await page.evaluate(`(async () => {
+          for (let i = 0; i < ${JSON.stringify(pollIterations)}; i++) {
+              await new Promise(r => setTimeout(r, ${JSON.stringify(UPLOAD_POLL_MS)}));
+              const container = document.querySelector('[data-testid="attachments"]');
+              if (!container) continue;
+              if (container.querySelectorAll('[role="group"]').length !== ${JSON.stringify(absPaths.length)}) continue;
+              const btn = document.querySelector('[data-testid="tweetButton"]') || document.querySelector('[data-testid="tweetButtonInline"]');
+              if (btn && !btn.disabled) return true;
+          }
+          return false;
+      })()`);
+            if (!uploaded) {
+                return [{ status: 'failed', message: `Image upload timed out (${UPLOAD_TIMEOUT_MS / 1000}s).`, text: kwargs.text }];
             }
-        } catch (e) {
-            return { ok: false, message: e.toString() };
         }
+        // 4. Click the post button
+        await page.wait(1);
+        const result = await page.evaluate(`(async () => {
+        try {
+            const btn = document.querySelector('[data-testid="tweetButton"]') || document.querySelector('[data-testid="tweetButtonInline"]');
+            if (btn && !btn.disabled) { btn.click(); return { ok: true, message: 'Tweet posted successfully.' }; }
+            return { ok: false, message: 'Tweet button is disabled or not found.' };
+        } catch (e) { return { ok: false, message: String(e) }; }
     })()`);
-        // 3. Wait a few seconds for the network request to finish sending
-        if (result.ok) {
+        if (result.ok)
             await page.wait(3);
-        }
-        return [{
-                status: result.ok ? 'success' : 'failed',
-                message: result.message,
-                text: kwargs.text
-            }];
+        return [{ status: result.ok ? 'success' : 'failed', message: result.message, text: kwargs.text }];
     }
 });

package/dist/clis/twitter/post.test.d.ts

@@ -0,0 +1 @@
+import './post.js';

package/dist/clis/twitter/post.test.js

@@ -0,0 +1,116 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './post.js';
+vi.mock('node:fs', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        statSync: vi.fn((p, _opts) => {
+            if (String(p).includes('missing'))
+                return undefined;
+            return { isFile: () => true };
+        }),
+    };
+});
+vi.mock('node:path', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        resolve: vi.fn((p) => `/abs/${p}`),
+        extname: vi.fn((p) => {
+            const m = p.match(/\.[^.]+$/);
+            return m ? m[0] : '';
+        }),
+    };
+});
+function makePage(overrides = {}) {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        wait: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue({ ok: true }),
+        setFileInput: vi.fn().mockResolvedValue(undefined),
+        ...overrides,
+    };
+}
+describe('twitter post command', () => {
+    const getCommand = () => getRegistry().get('twitter/post');
+    it('posts text-only tweet successfully', async () => {
+        const command = getCommand();
+        const page = makePage({
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({ ok: true })
+                .mockResolvedValueOnce({ ok: true, message: 'Tweet posted successfully.' }),
+        });
+        const result = await command.func(page, { text: 'hello world' });
+        expect(result).toEqual([{ status: 'success', message: 'Tweet posted successfully.', text: 'hello world' }]);
+        expect(page.goto).toHaveBeenCalledWith('https://x.com/compose/tweet');
+    });
+    it('returns failed when text area not found', async () => {
+        const command = getCommand();
+        const page = makePage({
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({ ok: false, message: 'Could not find the tweet composer text area.' }),
+        });
+        const result = await command.func(page, { text: 'hello' });
+        expect(result).toEqual([{ status: 'failed', message: 'Could not find the tweet composer text area.', text: 'hello' }]);
+    });
+    it('throws when more than 4 images', async () => {
+        const command = getCommand();
+        const page = makePage();
+        await expect(command.func(page, { text: 'hi', images: 'a.png,b.png,c.png,d.png,e.png' })).rejects.toThrow('Too many images: 5 (max 4)');
+    });
+    it('throws when image file does not exist', async () => {
+        const command = getCommand();
+        const page = makePage();
+        await expect(command.func(page, { text: 'hi', images: 'missing.png' })).rejects.toThrow('Not a valid file');
+    });
+    it('throws on unsupported image format', async () => {
+        const command = getCommand();
+        const page = makePage();
+        await expect(command.func(page, { text: 'hi', images: 'photo.bmp' })).rejects.toThrow('Unsupported image format');
+    });
+    it('throws when page.setFileInput is not available', async () => {
+        const command = getCommand();
+        const page = makePage({
+            evaluate: vi.fn().mockResolvedValueOnce({ ok: true }),
+            setFileInput: undefined,
+        });
+        await expect(command.func(page, { text: 'hi', images: 'a.png' })).rejects.toThrow('Browser extension does not support file upload');
+    });
+    it('posts with images when upload completes', async () => {
+        const command = getCommand();
+        const page = makePage({
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({ ok: true }) // type text
+                .mockResolvedValueOnce(true) // upload polling returns true
+                .mockResolvedValueOnce({ ok: true, message: 'Tweet posted successfully.' }), // click post
+        });
+        const result = await command.func(page, { text: 'with images', images: 'a.png,b.png' });
+        expect(result).toEqual([{ status: 'success', message: 'Tweet posted successfully.', text: 'with images' }]);
+        expect(page.setFileInput).toHaveBeenCalled();
+        const uploadScript = page.evaluate.mock.calls[1][0];
+        expect(uploadScript).toContain('[data-testid="attachments"]');
+        expect(uploadScript).toContain('[role="group"]');
+    });
+    it('returns failed when image upload times out', async () => {
+        const command = getCommand();
+        const page = makePage({
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({ ok: true })
+                .mockResolvedValueOnce(false),
+        });
+        const result = await command.func(page, { text: 'timeout', images: 'a.png' });
+        expect(result).toEqual([{ status: 'failed', message: 'Image upload timed out (30s).', text: 'timeout' }]);
+    });
+    it('validates images before navigating to compose page', async () => {
+        const command = getCommand();
+        const page = makePage();
+        await expect(command.func(page, { text: 'hi', images: 'missing.png' })).rejects.toThrow('Not a valid file');
+        // Should NOT have navigated since validation happens first
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+    it('throws when no browser session', async () => {
+        const command = getCommand();
+        await expect(command.func(null, { text: 'hi' })).rejects.toThrow('Browser session required for twitter post');
+    });
+});

package/dist/clis/twitter/reply.d.ts

@@ -1 +1,13 @@
+declare function resolveImagePath(imagePath: string): string;
+declare function extractTweetId(url: string): string;
+declare function buildReplyComposerUrl(url: string): string;
+declare function resolveImageExtension(url: string, contentType: string | null): string;
+declare function downloadRemoteImage(imageUrl: string): Promise<string>;
+export declare const __test__: {
+    buildReplyComposerUrl: typeof buildReplyComposerUrl;
+    downloadRemoteImage: typeof downloadRemoteImage;
+    extractTweetId: typeof extractTweetId;
+    resolveImageExtension: typeof resolveImageExtension;
+    resolveImagePath: typeof resolveImagePath;
+};
 export {};

package/dist/clis/twitter/reply.js

@@ -1,58 +1,280 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
 import { CommandExecutionError } from '../../errors.js';
 import { cli, Strategy } from '../../registry.js';
+const REPLY_FILE_INPUT_SELECTOR = 'input[type="file"][data-testid="fileInput"]';
+const SUPPORTED_IMAGE_EXTENSIONS = new Set([
+    '.jpg',
+    '.jpeg',
+    '.png',
+    '.gif',
+    '.webp',
+]);
+const MAX_IMAGE_SIZE_BYTES = 20 * 1024 * 1024; // 20 MB (Twitter allows 5MB images, 15MB GIFs)
+const CONTENT_TYPE_TO_EXTENSION = {
+    'image/jpeg': '.jpg',
+    'image/jpg': '.jpg',
+    'image/png': '.png',
+    'image/gif': '.gif',
+    'image/webp': '.webp',
+};
+function resolveImagePath(imagePath) {
+    const absPath = path.resolve(imagePath);
+    if (!fs.existsSync(absPath)) {
+        throw new Error(`Image file not found: ${absPath}`);
+    }
+    const ext = path.extname(absPath).toLowerCase();
+    if (!SUPPORTED_IMAGE_EXTENSIONS.has(ext)) {
+        throw new Error(`Unsupported image format "${ext}". Supported: jpg, jpeg, png, gif, webp`);
+    }
+    const stat = fs.statSync(absPath);
+    if (stat.size > MAX_IMAGE_SIZE_BYTES) {
+        throw new Error(`Image too large: ${(stat.size / 1024 / 1024).toFixed(1)} MB (max ${MAX_IMAGE_SIZE_BYTES / 1024 / 1024} MB)`);
+    }
+    return absPath;
+}
+function extractTweetId(url) {
+    let pathname = '';
+    try {
+        pathname = new URL(url).pathname;
+    }
+    catch {
+        throw new Error(`Invalid tweet URL: ${url}`);
+    }
+    const match = pathname.match(/\/status\/(\d+)/);
+    if (!match?.[1]) {
+        throw new Error(`Could not extract tweet ID from URL: ${url}`);
+    }
+    return match[1];
+}
+function buildReplyComposerUrl(url) {
+    return `https://x.com/compose/post?in_reply_to=${extractTweetId(url)}`;
+}
+function resolveImageExtension(url, contentType) {
+    const normalizedContentType = (contentType || '').split(';')[0].trim().toLowerCase();
+    if (normalizedContentType && CONTENT_TYPE_TO_EXTENSION[normalizedContentType]) {
+        return CONTENT_TYPE_TO_EXTENSION[normalizedContentType];
+    }
+    try {
+        const pathname = new URL(url).pathname;
+        const ext = path.extname(pathname).toLowerCase();
+        if (SUPPORTED_IMAGE_EXTENSIONS.has(ext))
+            return ext;
+    }
+    catch {
+        // Fall through to the final error below.
+    }
+    throw new Error(`Unsupported remote image format "${normalizedContentType || 'unknown'}". ` +
+        'Supported: jpg, jpeg, png, gif, webp');
+}
+async function downloadRemoteImage(imageUrl) {
+    let parsed;
+    try {
+        parsed = new URL(imageUrl);
+    }
+    catch {
+        throw new Error(`Invalid image URL: ${imageUrl}`);
+    }
+    if (!/^https?:$/.test(parsed.protocol)) {
+        throw new Error(`Unsupported image URL protocol: ${parsed.protocol}`);
+    }
+    const response = await fetch(imageUrl);
+    if (!response.ok) {
+        throw new Error(`Image download failed: HTTP ${response.status}`);
+    }
+    const contentLength = Number(response.headers.get('content-length') || '0');
+    if (contentLength > MAX_IMAGE_SIZE_BYTES) {
+        throw new Error(`Image too large: ${(contentLength / 1024 / 1024).toFixed(1)} MB (max ${MAX_IMAGE_SIZE_BYTES / 1024 / 1024} MB)`);
+    }
+    const ext = resolveImageExtension(imageUrl, response.headers.get('content-type'));
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-twitter-reply-'));
+    const tmpPath = path.join(tmpDir, `image${ext}`);
+    const buffer = Buffer.from(await response.arrayBuffer());
+    if (buffer.byteLength > MAX_IMAGE_SIZE_BYTES) {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        throw new Error(`Image too large: ${(buffer.byteLength / 1024 / 1024).toFixed(1)} MB (max ${MAX_IMAGE_SIZE_BYTES / 1024 / 1024} MB)`);
+    }
+    fs.writeFileSync(tmpPath, buffer);
+    return tmpPath;
+}
+async function attachReplyImage(page, absImagePath) {
+    let uploaded = false;
+    if (page.setFileInput) {
+        try {
+            await page.setFileInput([absImagePath], REPLY_FILE_INPUT_SELECTOR);
+            uploaded = true;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (!msg.includes('Unknown action') && !msg.includes('not supported')) {
+                throw new Error(`Image upload failed: ${msg}`);
+            }
+            // setFileInput not supported by extension — fall through to base64 fallback
+        }
+    }
+    if (!uploaded) {
+        const ext = path.extname(absImagePath).toLowerCase();
+        const mimeType = ext === '.png'
+            ? 'image/png'
+            : ext === '.gif'
+                ? 'image/gif'
+                : ext === '.webp'
+                    ? 'image/webp'
+                    : 'image/jpeg';
+        const base64 = fs.readFileSync(absImagePath).toString('base64');
+        if (base64.length > 500_000) {
+            console.warn(`[warn] Image base64 payload is ${(base64.length / 1024 / 1024).toFixed(1)}MB. ` +
+                'This may fail with the browser bridge. Update the extension to v1.6+ for CDP-based upload, ' +
+                'or compress the image before attaching.');
+        }
+        const upload = await page.evaluate(`
+      (() => {
+        const input = document.querySelector(${JSON.stringify(REPLY_FILE_INPUT_SELECTOR)});
+        if (!input) return { ok: false, error: 'No file input found on page' };
+
+        const binary = atob(${JSON.stringify(base64)});
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+
+        const dt = new DataTransfer();
+        const blob = new Blob([bytes], { type: ${JSON.stringify(mimeType)} });
+        dt.items.add(new File([blob], ${JSON.stringify(path.basename(absImagePath))}, { type: ${JSON.stringify(mimeType)} }));
+
+        Object.defineProperty(input, 'files', { value: dt.files, writable: false });
+        input.dispatchEvent(new Event('change', { bubbles: true }));
+        input.dispatchEvent(new Event('input', { bubbles: true }));
+        return { ok: true };
+      })()
+    `);
+        if (!upload?.ok) {
+            throw new Error(`Image upload failed: ${upload?.error ?? 'unknown error'}`);
+        }
+    }
+    await page.wait(2);
+    const uploadState = await page.evaluate(`
+    (() => {
+      const previewCount = document.querySelectorAll(
+        '[data-testid="attachments"] img, [data-testid="attachments"] video, [data-testid="tweetPhoto"]'
+      ).length;
+      const hasMedia = previewCount > 0
+        || !!document.querySelector('[data-testid="attachments"]')
+        || !!Array.from(document.querySelectorAll('button,[role="button"]')).find((el) =>
+          /remove media|remove image|remove/i.test((el.getAttribute('aria-label') || '') + ' ' + (el.textContent || ''))
+        );
+      return { ok: hasMedia, previewCount };
+    })()
+  `);
+    if (!uploadState?.ok) {
+        throw new Error('Image upload failed: preview did not appear.');
+    }
+}
+async function submitReply(page, text) {
+    return page.evaluate(`(async () => {
+      try {
+          const visible = (el) => !!el && (el.offsetParent !== null || el.getClientRects().length > 0);
+          const boxes = Array.from(document.querySelectorAll('[data-testid="tweetTextarea_0"]'));
+          const box = boxes.find(visible) || boxes[0];
+          if (!box) {
+              return { ok: false, message: 'Could not find the reply text area. Are you logged in?' };
+          }
+
+          box.focus();
+          const textToInsert = ${JSON.stringify(text)};
+          // execCommand('insertText') is more reliable with Twitter's Draft.js editor
+          if (!document.execCommand('insertText', false, textToInsert)) {
+              // Fallback to paste event if execCommand fails
+              const dataTransfer = new DataTransfer();
+              dataTransfer.setData('text/plain', textToInsert);
+              box.dispatchEvent(new ClipboardEvent('paste', {
+                  clipboardData: dataTransfer,
+                  bubbles: true,
+                  cancelable: true
+              }));
+          }
+
+          await new Promise(r => setTimeout(r, 1000));
+
+          const buttons = Array.from(
+              document.querySelectorAll('[data-testid="tweetButton"], [data-testid="tweetButtonInline"]')
+          );
+          const btn = buttons.find((el) => visible(el) && !el.disabled);
+          if (!btn) {
+              return { ok: false, message: 'Reply button is disabled or not found.' };
+          }
+
+          btn.click();
+          return { ok: true, message: 'Reply posted successfully.' };
+      } catch (e) {
+          return { ok: false, message: e.toString() };
+      }
+  })()`);
+}
 cli({
     site: 'twitter',
     name: 'reply',
-    description: 'Reply to a specific tweet',
+    description: 'Reply to a specific tweet, optionally with a local or remote image',
     domain: 'x.com',
     strategy: Strategy.UI, // Uses the UI directly to input and click post
     browser: true,
     args: [
         { name: 'url', type: 'string', required: true, positional: true, help: 'The URL of the tweet to reply to' },
         { name: 'text', type: 'string', required: true, positional: true, help: 'The text content of your reply' },
+        { name: 'image', help: 'Optional local image path to attach to the reply' },
+        { name: 'image-url', help: 'Optional remote image URL to download and attach to the reply' },
     ],
     columns: ['status', 'message', 'text'],
     func: async (page, kwargs) => {
         if (!page)
             throw new CommandExecutionError('Browser session required for twitter reply');
-        // 1. Navigate to the tweet page
-        await page.goto(kwargs.url);
-        await page.wait({ selector: '[data-testid="primaryColumn"]' });
-        // 2. Automate typing the reply and clicking reply
-        const result = await page.evaluate(`(async () => {
+        if (kwargs.image && kwargs['image-url']) {
+            throw new Error('Use either --image or --image-url, not both.');
+        }
+        let localImagePath;
+        let cleanupDir;
         try {
-            // Find the reply text area on the tweet page. 
-            // The placeholder is usually "Post your reply"
-            const box = document.querySelector('[data-testid="tweetTextarea_0"]');
-            if (box) {
-                box.focus();
-                document.execCommand('insertText', false, ${JSON.stringify(kwargs.text)});
-            } else {
-                return { ok: false, message: 'Could not find the reply text area. Are you logged in?' };
+            if (kwargs.image) {
+                localImagePath = resolveImagePath(kwargs.image);
+            }
+            else if (kwargs['image-url']) {
+                localImagePath = await downloadRemoteImage(kwargs['image-url']);
+                cleanupDir = path.dirname(localImagePath);
             }
-            
-            // Wait for React state to register the input and enable the button
-            await new Promise(r => setTimeout(r, 1000));
-            
-            // Find the Reply button. It usually shares the same test id tweetButtonInline in this context
-            const btn = document.querySelector('[data-testid="tweetButtonInline"]');
-            if (btn && !btn.disabled) {
-                btn.click();
-                return { ok: true, message: 'Reply posted successfully.' };
-            } else {
-                return { ok: false, message: 'Reply button is disabled or not found.' };
+            // Dedicated composer is more reliable for image replies because the media
+            // toolbar and file input are consistently present there.
+            if (localImagePath) {
+                await page.goto(buildReplyComposerUrl(kwargs.url));
+                await page.wait({ selector: '[data-testid="tweetTextarea_0"]' });
+                await page.wait({ selector: REPLY_FILE_INPUT_SELECTOR, timeout: 20 });
+                await attachReplyImage(page, localImagePath);
             }
-        } catch (e) {
-            return { ok: false, message: e.toString() };
+            else {
+                await page.goto(kwargs.url);
+                await page.wait({ selector: '[data-testid="primaryColumn"]' });
+            }
+            const result = await submitReply(page, kwargs.text);
+            if (result.ok) {
+                await page.wait(3); // Wait for network submission to complete
+            }
+            return [{
+                    status: result.ok ? 'success' : 'failed',
+                    message: result.message,
+                    text: kwargs.text,
+                    ...(kwargs.image ? { image: kwargs.image } : {}),
+                    ...(kwargs['image-url'] ? { 'image-url': kwargs['image-url'] } : {}),
+                }];
         }
-    })()`);
-        if (result.ok) {
-            await page.wait(3); // Wait for network submission to complete
+        finally {
+            if (cleanupDir) {
+                fs.rmSync(cleanupDir, { recursive: true, force: true });
+            }
         }
-        return [{
-                status: result.ok ? 'success' : 'failed',
-                message: result.message,
-                text: kwargs.text
-            }];
     }
 });
+export const __test__ = {
+    buildReplyComposerUrl,
+    downloadRemoteImage,
+    extractTweetId,
+    resolveImageExtension,
+    resolveImagePath,
+};

package/dist/clis/twitter/reply.test.d.ts

@@ -0,0 +1 @@
+export {};