@jackwener/opencli 1.7.7 → 1.7.9

package/clis/claude/commands.test.js

@@ -0,0 +1,118 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ArgumentError, AuthRequiredError, EmptyResultError } from '@jackwener/opencli/errors';
+
+const {
+    mockEnsureOnClaude,
+    mockEnsureClaudeComposer,
+    mockEnsureClaudeLogin,
+    mockSendMessage,
+    mockParseBoolFlag,
+    mockRequireNonEmptyPrompt,
+    mockGetVisibleMessages,
+    mockGetConversationList,
+    mockRequirePositiveInt,
+    mockRequireConversationId,
+    mockWithRetry,
+} = vi.hoisted(() => ({
+    mockEnsureOnClaude: vi.fn(),
+    mockEnsureClaudeComposer: vi.fn(),
+    mockEnsureClaudeLogin: vi.fn(),
+    mockSendMessage: vi.fn(),
+    mockParseBoolFlag: vi.fn((v) => v === true || v === 'true'),
+    mockRequireNonEmptyPrompt: vi.fn((v) => String(v ?? '')),
+    mockGetVisibleMessages: vi.fn(),
+    mockGetConversationList: vi.fn(),
+    mockRequirePositiveInt: vi.fn((v) => Number(v)),
+    mockRequireConversationId: vi.fn((v) => String(v ?? '').trim()),
+    mockWithRetry: vi.fn(async (fn) => fn()),
+}));
+
+vi.mock('./utils.js', () => ({
+    CLAUDE_DOMAIN: 'claude.ai',
+    CLAUDE_URL: 'https://claude.ai/new',
+    ensureOnClaude: mockEnsureOnClaude,
+    ensureClaudeComposer: mockEnsureClaudeComposer,
+    ensureClaudeLogin: mockEnsureClaudeLogin,
+    sendMessage: mockSendMessage,
+    parseBoolFlag: mockParseBoolFlag,
+    requireNonEmptyPrompt: mockRequireNonEmptyPrompt,
+    getVisibleMessages: mockGetVisibleMessages,
+    getConversationList: mockGetConversationList,
+    requirePositiveInt: mockRequirePositiveInt,
+    requireConversationId: mockRequireConversationId,
+    withRetry: mockWithRetry,
+}));
+
+import { sendCommand } from './send.js';
+import { newCommand } from './new.js';
+import { readCommand } from './read.js';
+import { historyCommand } from './history.js';
+import { detailCommand } from './detail.js';
+
+describe('claude command-level fail-fast contracts', () => {
+    const page = {
+        goto: vi.fn().mockResolvedValue(undefined),
+        wait: vi.fn().mockResolvedValue(undefined),
+    };
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockEnsureOnClaude.mockResolvedValue(false);
+        mockEnsureClaudeComposer.mockResolvedValue({ isLoggedIn: true, hasComposer: true });
+        mockEnsureClaudeLogin.mockResolvedValue({ isLoggedIn: true });
+        mockSendMessage.mockResolvedValue({ ok: true });
+        mockRequireNonEmptyPrompt.mockImplementation((v) => String(v ?? ''));
+        mockGetVisibleMessages.mockResolvedValue([{ Index: 0, Role: 'assistant', Text: 'hi' }]);
+        mockGetConversationList.mockResolvedValue([{ Index: 1, Id: 'abc', Title: 'Hi', Url: 'https://claude.ai/chat/abc' }]);
+        mockRequirePositiveInt.mockImplementation((v) => Number(v));
+        mockRequireConversationId.mockImplementation((v) => String(v ?? '').trim());
+    });
+
+    it('send rejects empty prompt via ArgumentError', async () => {
+        mockRequireNonEmptyPrompt.mockImplementation(() => {
+            throw new ArgumentError('claude send prompt cannot be empty');
+        });
+
+        await expect(sendCommand.func(page, { prompt: '', new: false })).rejects.toThrow(ArgumentError);
+    });
+
+    it('send surfaces auth failure from composer readiness', async () => {
+        mockEnsureClaudeComposer.mockRejectedValue(new AuthRequiredError('claude.ai', 'Claude send requires a logged-in Claude session.'));
+
+        await expect(sendCommand.func(page, { prompt: 'hi', new: false })).rejects.toThrow(AuthRequiredError);
+    });
+
+    it('new no longer false-succeeds on login wall', async () => {
+        mockEnsureClaudeComposer.mockRejectedValue(new AuthRequiredError('claude.ai', 'Claude new requires a logged-in Claude session with a visible composer.'));
+
+        await expect(newCommand.func(page)).rejects.toThrow(AuthRequiredError);
+    });
+
+    it('read throws EmptyResultError instead of a placeholder row', async () => {
+        mockGetVisibleMessages.mockResolvedValue([]);
+
+        await expect(readCommand.func(page)).rejects.toThrow(EmptyResultError);
+    });
+
+    it('history rejects invalid --limit values instead of silently coercing them', async () => {
+        mockRequirePositiveInt.mockImplementation(() => {
+            throw new ArgumentError('claude history --limit must be a positive integer');
+        });
+
+        await expect(historyCommand.func(page, { limit: 0 })).rejects.toThrow(ArgumentError);
+    });
+
+    it('history throws EmptyResultError on an empty /recents page', async () => {
+        mockGetConversationList.mockResolvedValue([]);
+
+        await expect(historyCommand.func(page, { limit: 20 })).rejects.toThrow(EmptyResultError);
+    });
+
+    it('detail rejects a missing conversation id', async () => {
+        mockRequireConversationId.mockImplementation(() => {
+            throw new ArgumentError('claude detail requires a conversation id');
+        });
+
+        await expect(detailCommand.func(page, { id: '' })).rejects.toThrow(ArgumentError);
+    });
+});

package/clis/claude/detail.js

@@ -0,0 +1,29 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import { CLAUDE_DOMAIN, getVisibleMessages, ensureClaudeLogin, requireConversationId } from './utils.js';
+
+export const detailCommand = cli({
+    site: 'claude',
+    name: 'detail',
+    description: 'Open a Claude conversation by ID and read its messages',
+    domain: CLAUDE_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'id', positional: true, required: true, help: 'Conversation ID (UUID from /chat/<id>)' },
+    ],
+    columns: ['Index', 'Role', 'Text'],
+
+    func: async (page, kwargs) => {
+        const id = requireConversationId(kwargs.id);
+
+        await page.goto(`https://claude.ai/chat/${id}`);
+        await page.wait(4);
+        await ensureClaudeLogin(page, 'Claude detail requires a logged-in Claude session.');
+
+        const messages = await getVisibleMessages(page);
+        if (messages.length > 0) return messages;
+        throw new EmptyResultError('claude detail', `No visible Claude messages were found for conversation ${id}.`);
+    },
+});

package/clis/claude/history.js

@@ -0,0 +1,31 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import { CLAUDE_DOMAIN, getConversationList, ensureClaudeLogin, requirePositiveInt } from './utils.js';
+
+export const historyCommand = cli({
+    site: 'claude',
+    name: 'history',
+    description: 'List conversation history from Claude /recents',
+    domain: CLAUDE_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Max conversations to show' },
+    ],
+    columns: ['Index', 'Id', 'Title', 'Url'],
+
+    func: async (page, kwargs) => {
+        const limit = requirePositiveInt(
+            Number(kwargs.limit ?? 20),
+            'claude history --limit',
+            'Example: opencli claude history --limit 20',
+        );
+        const conversations = await getConversationList(page);
+        await ensureClaudeLogin(page, 'Claude history requires a logged-in Claude session.');
+        if (conversations.length === 0) {
+            throw new EmptyResultError('claude history', 'No Claude conversation history was visible on /recents.');
+        }
+        return conversations.slice(0, limit);
+    },
+});

package/clis/claude/new.js

@@ -0,0 +1,21 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CLAUDE_DOMAIN, CLAUDE_URL, ensureClaudeComposer } from './utils.js';
+
+export const newCommand = cli({
+    site: 'claude',
+    name: 'new',
+    description: 'Start a new conversation in Claude',
+    domain: CLAUDE_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [],
+    columns: ['Status'],
+
+    func: async (page) => {
+        await page.goto(CLAUDE_URL);
+        await page.wait(2);
+        await ensureClaudeComposer(page, 'Claude new requires a logged-in Claude session with a visible composer.');
+        return [{ Status: 'New chat started' }];
+    },
+});

package/clis/claude/read.js

@@ -0,0 +1,24 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import { CLAUDE_DOMAIN, ensureOnClaude, getVisibleMessages, ensureClaudeLogin } from './utils.js';
+
+export const readCommand = cli({
+    site: 'claude',
+    name: 'read',
+    description: 'Read the current Claude conversation',
+    domain: CLAUDE_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [],
+    columns: ['Index', 'Role', 'Text'],
+
+    func: async (page) => {
+        await ensureOnClaude(page);
+        await page.wait(3);
+        await ensureClaudeLogin(page, 'Claude read requires a logged-in Claude session.');
+        const messages = await getVisibleMessages(page);
+        if (messages.length > 0) return messages;
+        throw new EmptyResultError('claude read', 'No visible Claude messages were found in the current conversation.');
+    },
+});

package/clis/claude/send.js

@@ -0,0 +1,41 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import { CLAUDE_DOMAIN, CLAUDE_URL, ensureOnClaude, sendMessage, parseBoolFlag, withRetry, ensureClaudeComposer, requireNonEmptyPrompt } from './utils.js';
+
+export const sendCommand = cli({
+    site: 'claude',
+    name: 'send',
+    description: 'Send a prompt to Claude without waiting for the response',
+    domain: CLAUDE_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'prompt', positional: true, required: true, help: 'Prompt to send' },
+        { name: 'new', type: 'boolean', default: false, help: 'Start a new chat before sending' },
+    ],
+    columns: ['Status', 'SubmittedBy', 'InjectedText'],
+
+    func: async (page, kwargs) => {
+        const prompt = requireNonEmptyPrompt(kwargs.prompt, 'claude send');
+
+        if (parseBoolFlag(kwargs.new)) {
+            await page.goto(CLAUDE_URL);
+            await page.wait(3);
+        } else {
+            await ensureOnClaude(page);
+            await page.wait(2);
+        }
+        await withRetry(() => ensureClaudeComposer(page, 'Claude send requires a visible composer on the current page.'));
+
+        const sendResult = await withRetry(() => sendMessage(page, prompt));
+        if (!sendResult?.ok) {
+            throw new CommandExecutionError(sendResult?.reason || 'Failed to send message');
+        }
+        return [{
+            Status: 'Success',
+            SubmittedBy: sendResult.method || 'send-button',
+            InjectedText: prompt,
+        }];
+    },
+});

package/clis/claude/status.js

@@ -0,0 +1,24 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CLAUDE_DOMAIN, ensureOnClaude, getPageState } from './utils.js';
+
+export const statusCommand = cli({
+    site: 'claude',
+    name: 'status',
+    description: 'Check Claude page availability and login state',
+    domain: CLAUDE_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [],
+    columns: ['Status', 'Login', 'Url'],
+
+    func: async (page) => {
+        await ensureOnClaude(page);
+        const state = await getPageState(page);
+        return [{
+            Status: state.hasComposer ? 'Connected' : 'Page not ready',
+            Login: state.isLoggedIn ? 'Yes' : 'No',
+            Url: state.url,
+        }];
+    },
+});