@jackwener/opencli 1.7.15 → 1.7.17

package/clis/chatgpt/ask.js

@@ -22,7 +22,7 @@ export const askCommand = cli({
     domain: CHATGPT_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
-    browserSession: { reuse: 'site' },
+    siteSession: 'persistent',
     navigateBefore: false,
     args: [
         { name: 'prompt', positional: true, required: true, help: 'Prompt to send' },
@@ -43,7 +43,8 @@ export const askCommand = cli({
         } else {
             await ensureOnChatGPT(page);
         }
-        await page.wait(2);
+        // startNewChat / ensureOnChatGPT now wait for the composer selector
+        // after navigating, so the previous standalone 2 s settle is redundant.
         await ensureChatGPTComposer(page, 'ChatGPT ask requires a logged-in ChatGPT session with a visible composer.');
 
         const baseline = await getBubbleCount(page);

package/clis/chatgpt/commands.test.js

@@ -10,7 +10,7 @@ import './status.js';
 import './image.js';
 
 describe('chatgpt browser command registration', () => {
-    it('registers the baseline web chat commands with site-level reuse', () => {
+    it('registers the baseline web chat commands with persistent site sessions', () => {
         const expectedAccess = {
             ask: 'write',
             send: 'write',
@@ -29,7 +29,7 @@ describe('chatgpt browser command registration', () => {
             expect(cmd.domain).toBe('chatgpt.com');
             expect(cmd.strategy).toBe('cookie');
             expect(cmd.browser).toBe(true);
-            expect(cmd.browserSession).toEqual({ reuse: 'site' });
+            expect(cmd.siteSession).toBe('persistent');
             expect(cmd.navigateBefore).toBe(false);
             expect(cmd.access).toBe(access);
         }

package/clis/chatgpt/detail.js

@@ -3,6 +3,7 @@ import { EmptyResultError } from '@jackwener/opencli/errors';
 import {
     CHATGPT_DOMAIN,
     CHATGPT_URL,
+    CONVERSATION_MESSAGE_SELECTOR,
     ensureChatGPTLogin,
     getVisibleMessages,
     messageHtmlToMarkdown,
@@ -18,7 +19,7 @@ export const detailCommand = cli({
     domain: CHATGPT_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
-    browserSession: { reuse: 'site' },
+    siteSession: 'persistent',
     navigateBefore: false,
     args: [
         { name: 'id', positional: true, required: true, help: 'Conversation ID or full /c/<id> URL' },
@@ -29,7 +30,11 @@ export const detailCommand = cli({
         const id = parseChatGPTConversationId(kwargs.id);
         const wantMarkdown = normalizeBooleanFlag(kwargs.markdown, false);
         await page.goto(`${CHATGPT_URL}/c/${id}`, { settleMs: 2000 });
-        await page.wait(4);
+        try {
+            await page.wait({ selector: CONVERSATION_MESSAGE_SELECTOR, timeout: 10 });
+        } catch {
+            // Empty conversation, missing access, or login redirect — handled by ensureChatGPTLogin / EmptyResultError below.
+        }
         await ensureChatGPTLogin(page, 'ChatGPT detail requires a logged-in ChatGPT session.');
         const messages = await getVisibleMessages(page);
         if (!messages.length) {

package/clis/chatgpt/history.js

@@ -16,7 +16,7 @@ export const historyCommand = cli({
     domain: CHATGPT_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
-    browserSession: { reuse: 'site' },
+    siteSession: 'persistent',
     navigateBefore: false,
     args: [
         { name: 'limit', type: 'int', default: 20, help: 'Max conversations to show' },

package/clis/chatgpt/image.js

@@ -4,7 +4,7 @@ import * as fs from 'node:fs';
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { saveBase64ToFile } from '@jackwener/opencli/utils';
 import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
-import { getChatGPTVisibleImageUrls, normalizeBooleanFlag, sendChatGPTMessage, waitForChatGPTImages, getChatGPTImageAssets } from './utils.js';
+import { clearChatGPTDraft, getChatGPTVisibleImageUrls, normalizeBooleanFlag, prepareChatGPTImagePaths, sendChatGPTMessage, waitForChatGPTImages, getChatGPTImageAssets, uploadChatGPTImages } from './utils.js';
 
 const CHATGPT_DOMAIN = 'chatgpt.com';
 
@@ -36,6 +36,23 @@ export function nextAvailablePath(dir, baseName, ext, existsSync = fs.existsSync
     return candidate;
 }
 
+export function parseImagePaths(value) {
+    if (Array.isArray(value)) {
+        return value.flatMap(item => parseImagePaths(item));
+    }
+    return String(value ?? '')
+        .split(',')
+        .map(item => item.trim())
+        .filter(Boolean);
+}
+
+function buildPrompt(prompt, imageCount) {
+    if (imageCount > 0) {
+        return `Edit the attached image${imageCount === 1 ? '' : 's'}: ${prompt}`;
+    }
+    return `Generate an image of: ${prompt}`;
+}
+
 async function currentChatGPTLink(page) {
     const url = await page.evaluate('window.location.href').catch(() => '');
     return typeof url === 'string' && url ? url : 'https://chatgpt.com';
@@ -49,11 +66,12 @@ export const imageCommand = cli({
     domain: CHATGPT_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
-    browserSession: { reuse: 'site' },
+    siteSession: 'persistent',
     navigateBefore: false,
     defaultFormat: 'plain',
     args: [
         { name: 'prompt', positional: true, required: true, help: 'Image prompt to send to ChatGPT' },
+        { name: 'image', help: 'Local image path to attach before prompting; comma-separated paths are supported' },
         { name: 'op', help: 'Output directory (default: ~/Pictures/chatgpt)' },
         { name: 'sd', type: 'boolean', default: false, help: 'Skip download shorthand; only show ChatGPT link' },
         { name: 'timeout', type: 'int', required: false, default: 240, help: 'Max seconds for the overall command (default: 240)' },
@@ -61,6 +79,7 @@ export const imageCommand = cli({
     columns: ['status', 'file', 'link'],
     func: async (page, kwargs) => {
         const prompt = kwargs.prompt;
+        const imagePaths = parseImagePaths(kwargs.image);
         const outputDir = resolveOutputDir(kwargs.op);
         const skipDownloadRaw = kwargs.sd;
         const skipDownload = skipDownloadRaw === '' || skipDownloadRaw === true || normalizeBooleanFlag(skipDownloadRaw);
@@ -68,14 +87,29 @@ export const imageCommand = cli({
         if (!Number.isInteger(timeout) || timeout < 1) {
             throw new ArgumentError('--timeout must be a positive integer (seconds)');
         }
+        const preparedImages = imagePaths.length ? await prepareChatGPTImagePaths(imagePaths) : { ok: true, paths: [] };
+        if (!preparedImages.ok) {
+            throw new ArgumentError(preparedImages.reason);
+        }
 
         // Navigate to chatgpt.com/new with full reload to clear React sidebar state
         await page.goto(`https://${CHATGPT_DOMAIN}/new`, { settleMs: 2000 });
+        await clearChatGPTDraft(page);
+
+        if (imagePaths.length) {
+            let upload;
+            try {
+                upload = await uploadChatGPTImages(page, preparedImages.paths);
+            } catch (err) {
+                throw new CommandExecutionError(`Failed to upload image to ChatGPT: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            if (!upload?.ok) throw new CommandExecutionError(upload?.reason || 'Failed to upload image to ChatGPT');
+        }
 
         const beforeUrls = await getChatGPTVisibleImageUrls(page);
 
-        // Send the image generation prompt - must be explicit
-        const sent = await sendChatGPTMessage(page, `Generate an image of: ${prompt}`);
+        // Send an explicit generation/editing prompt so ChatGPT returns image assets.
+        const sent = await sendChatGPTMessage(page, buildPrompt(prompt, imagePaths.length));
         if (!sent) {
             throw new CommandExecutionError(
                 'Failed to send image prompt to ChatGPT',

package/clis/chatgpt/image.test.js

@@ -4,13 +4,17 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 const mocks = vi.hoisted(() => ({
     getChatGPTVisibleImageUrls: vi.fn(),
+    clearChatGPTDraft: vi.fn(),
+    prepareChatGPTImagePaths: vi.fn(),
     sendChatGPTMessage: vi.fn(),
+    uploadChatGPTImages: vi.fn(),
     waitForChatGPTImages: vi.fn(),
     getChatGPTImageAssets: vi.fn(),
     saveBase64ToFile: vi.fn(),
 }));
 
 vi.mock('./utils.js', () => ({
+    clearChatGPTDraft: mocks.clearChatGPTDraft,
     getChatGPTVisibleImageUrls: mocks.getChatGPTVisibleImageUrls,
     normalizeBooleanFlag: (value, fallback = false) => {
         if (typeof value === 'boolean') return value;
@@ -18,7 +22,9 @@ vi.mock('./utils.js', () => ({
         const normalized = String(value).trim().toLowerCase();
         return normalized === 'true' || normalized === '1' || normalized === 'yes' || normalized === 'on';
     },
+    prepareChatGPTImagePaths: mocks.prepareChatGPTImagePaths,
     sendChatGPTMessage: mocks.sendChatGPTMessage,
+    uploadChatGPTImages: mocks.uploadChatGPTImages,
     waitForChatGPTImages: mocks.waitForChatGPTImages,
     getChatGPTImageAssets: mocks.getChatGPTImageAssets,
 }));
@@ -27,7 +33,7 @@ vi.mock('@jackwener/opencli/utils', () => ({
     saveBase64ToFile: mocks.saveBase64ToFile,
 }));
 
-const { imageCommand, nextAvailablePath, resolveOutputDir } = await import('./image.js');
+const { imageCommand, nextAvailablePath, parseImagePaths, resolveOutputDir } = await import('./image.js');
 
 function createPage() {
     return {
@@ -39,8 +45,11 @@ function createPage() {
 
 beforeEach(() => {
     vi.restoreAllMocks();
+    mocks.clearChatGPTDraft.mockReset().mockResolvedValue(undefined);
+    mocks.prepareChatGPTImagePaths.mockReset().mockImplementation(async (paths) => ({ ok: true, paths }));
     mocks.getChatGPTVisibleImageUrls.mockReset().mockResolvedValue([]);
     mocks.sendChatGPTMessage.mockReset().mockResolvedValue(true);
+    mocks.uploadChatGPTImages.mockReset().mockResolvedValue({ ok: true });
     mocks.waitForChatGPTImages.mockReset().mockResolvedValue(['https://images.example/generated.png']);
     mocks.getChatGPTImageAssets.mockReset().mockResolvedValue([{
         url: 'https://images.example/generated.png',
@@ -66,6 +75,64 @@ describe('chatgpt image output paths', () => {
 
         expect(nextAvailablePath(dir, 'chatgpt_123', '.png', (file) => taken.has(file))).toBe(path.join(dir, 'chatgpt_123_2.png'));
     });
+
+    it('parses comma-separated image paths', () => {
+        expect(parseImagePaths('/tmp/a.png, /tmp/b.jpg')).toEqual(['/tmp/a.png', '/tmp/b.jpg']);
+        expect(parseImagePaths([' /tmp/a.png ', '/tmp/b.jpg,/tmp/c.webp'])).toEqual(['/tmp/a.png', '/tmp/b.jpg', '/tmp/c.webp']);
+    });
+});
+
+describe('chatgpt image upload flow', () => {
+    it('uploads local images before sending an edit prompt', async () => {
+        mocks.prepareChatGPTImagePaths.mockResolvedValue({ ok: true, paths: ['/abs/cat.png', '/abs/dog.jpg'] });
+        await imageCommand.func(createPage(), {
+            prompt: 'make the background blue',
+            image: '/tmp/cat.png,/tmp/dog.jpg',
+            op: '',
+            sd: true,
+            timeout: 240,
+        });
+
+        expect(mocks.clearChatGPTDraft).toHaveBeenCalled();
+        expect(mocks.uploadChatGPTImages).toHaveBeenCalledWith(expect.anything(), ['/abs/cat.png', '/abs/dog.jpg']);
+        expect(mocks.uploadChatGPTImages.mock.invocationCallOrder[0]).toBeLessThan(
+            mocks.getChatGPTVisibleImageUrls.mock.invocationCallOrder[0],
+        );
+        expect(mocks.sendChatGPTMessage).toHaveBeenCalledWith(expect.anything(), 'Edit the attached images: make the background blue');
+    });
+
+    it('rejects invalid local image paths before browser navigation', async () => {
+        mocks.prepareChatGPTImagePaths.mockResolvedValue({ ok: false, reason: 'Image not found: /tmp/missing.png' });
+        const page = createPage();
+
+        await expect(imageCommand.func(page, {
+            prompt: 'make the background blue',
+            image: '/tmp/missing.png',
+            op: '',
+            sd: false,
+            timeout: 240,
+        })).rejects.toMatchObject({
+            code: 'ARGUMENT',
+            message: expect.stringContaining('Image not found'),
+        });
+        expect(page.goto).not.toHaveBeenCalled();
+        expect(mocks.uploadChatGPTImages).not.toHaveBeenCalled();
+    });
+
+    it('surfaces upload failures as command execution errors', async () => {
+        mocks.uploadChatGPTImages.mockResolvedValue({ ok: false, reason: 'image upload preview did not appear' });
+
+        await expect(imageCommand.func(createPage(), {
+            prompt: 'make the background blue',
+            image: '/tmp/cat.png',
+            op: '',
+            sd: false,
+            timeout: 240,
+        })).rejects.toMatchObject({
+            code: 'COMMAND_EXEC',
+            message: expect.stringContaining('image upload preview did not appear'),
+        });
+    });
 });
 
 describe('chatgpt image failure contracts', () => {

package/clis/chatgpt/new.js

@@ -13,7 +13,7 @@ export const newCommand = cli({
     domain: CHATGPT_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
-    browserSession: { reuse: 'site' },
+    siteSession: 'persistent',
     navigateBefore: false,
     args: [],
     columns: ['Status'],

package/clis/chatgpt/read.js

@@ -17,7 +17,7 @@ export const readCommand = cli({
     domain: CHATGPT_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
-    browserSession: { reuse: 'site' },
+    siteSession: 'persistent',
     navigateBefore: false,
     args: [
         { name: 'markdown', type: 'boolean', default: false, help: 'Emit assistant replies as markdown' },
@@ -25,8 +25,9 @@ export const readCommand = cli({
     columns: ['Index', 'Role', 'Text'],
     func: async (page, kwargs) => {
         const wantMarkdown = normalizeBooleanFlag(kwargs.markdown, false);
+        // ensureOnChatGPT now waits for the composer selector after navigating,
+        // so the previous standalone 2 s settle is redundant.
         await ensureOnChatGPT(page);
-        await page.wait(2);
         await ensureChatGPTLogin(page, 'ChatGPT read requires a logged-in ChatGPT session.');
         const messages = await getVisibleMessages(page);
         if (!messages.length) {

package/clis/chatgpt/send.js

@@ -19,7 +19,7 @@ export const sendCommand = cli({
     domain: CHATGPT_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
-    browserSession: { reuse: 'site' },
+    siteSession: 'persistent',
     navigateBefore: false,
     args: [
         { name: 'prompt', positional: true, required: true, help: 'Prompt to send' },
@@ -34,7 +34,8 @@ export const sendCommand = cli({
         } else {
             await ensureOnChatGPT(page);
         }
-        await page.wait(2);
+        // startNewChat / ensureOnChatGPT now wait for the composer selector
+        // after navigating, so the previous standalone 2 s settle is redundant.
         await ensureChatGPTComposer(page, 'ChatGPT send requires a logged-in ChatGPT session with a visible composer.');
 
         const sent = await sendChatGPTMessage(page, prompt);

package/clis/chatgpt/status.js

@@ -13,7 +13,7 @@ export const statusCommand = cli({
     domain: CHATGPT_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
-    browserSession: { reuse: 'site' },
+    siteSession: 'persistent',
     navigateBefore: false,
     args: [],
     columns: ['Status', 'Login', 'Url'],