@jackwener/opencli 1.7.8 → 1.7.10

package/clis/claude/ask.test.js

@@ -0,0 +1,338 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+const {
+    mockEnsureOnClaude,
+    mockEnsureClaudeComposer,
+    mockSelectModel,
+    mockSetAdaptiveThinking,
+    mockSendMessage,
+    mockSendWithFile,
+    mockGetBubbleCount,
+    mockWaitForResponse,
+    mockParseBoolFlag,
+    mockRequireNonEmptyPrompt,
+    mockRequirePositiveInt,
+    mockWithRetry,
+} = vi.hoisted(() => ({
+    mockEnsureOnClaude: vi.fn(),
+    mockEnsureClaudeComposer: vi.fn(),
+    mockSelectModel: vi.fn(),
+    mockSetAdaptiveThinking: vi.fn(),
+    mockSendMessage: vi.fn(),
+    mockSendWithFile: vi.fn(),
+    mockGetBubbleCount: vi.fn(),
+    mockWaitForResponse: vi.fn(),
+    mockParseBoolFlag: vi.fn((v) => v === true || v === 'true'),
+    mockRequireNonEmptyPrompt: vi.fn((v) => String(v ?? '')),
+    mockRequirePositiveInt: vi.fn((v) => Number(v)),
+    mockWithRetry: vi.fn(async (fn) => fn()),
+}));
+
+vi.mock('./utils.js', () => ({
+    CLAUDE_DOMAIN: 'claude.ai',
+    CLAUDE_URL: 'https://claude.ai/new',
+    ensureOnClaude: mockEnsureOnClaude,
+    ensureClaudeComposer: mockEnsureClaudeComposer,
+    selectModel: mockSelectModel,
+    setAdaptiveThinking: mockSetAdaptiveThinking,
+    sendMessage: mockSendMessage,
+    sendWithFile: mockSendWithFile,
+    getBubbleCount: mockGetBubbleCount,
+    waitForResponse: mockWaitForResponse,
+    parseBoolFlag: mockParseBoolFlag,
+    requireNonEmptyPrompt: mockRequireNonEmptyPrompt,
+    requirePositiveInt: mockRequirePositiveInt,
+    withRetry: mockWithRetry,
+}));
+
+import { askCommand } from './ask.js';
+
+describe('claude ask basic flow', () => {
+    const page = {
+        wait: vi.fn().mockResolvedValue(undefined),
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue('https://claude.ai/new'),
+    };
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        page.evaluate.mockResolvedValue('https://claude.ai/new');
+        mockEnsureOnClaude.mockResolvedValue(false);
+        mockEnsureClaudeComposer.mockResolvedValue({ isLoggedIn: true, hasComposer: true });
+        mockSelectModel.mockResolvedValue({ ok: true, toggled: false });
+        mockSetAdaptiveThinking.mockResolvedValue({ ok: true, toggled: false });
+        mockSendMessage.mockResolvedValue({ ok: true });
+        mockSendWithFile.mockResolvedValue({ ok: true });
+        mockGetBubbleCount.mockResolvedValue(0);
+        mockWaitForResponse.mockResolvedValue('hello there');
+        mockRequireNonEmptyPrompt.mockImplementation((v) => String(v ?? ''));
+        mockRequirePositiveInt.mockImplementation((v) => Number(v));
+    });
+
+    it('returns the assistant response on a fresh chat', async () => {
+        const rows = await askCommand.func(page, {
+            prompt: 'hi',
+            timeout: 120,
+            new: false,
+            model: 'sonnet',
+            think: false,
+        });
+
+        expect(rows).toEqual([{ response: 'hello there' }]);
+        expect(mockSendMessage).toHaveBeenCalledWith(page, 'hi');
+        expect(mockWaitForResponse).toHaveBeenCalledWith(page, 0, 'hi', 120000);
+    });
+
+    it('navigates to /new when --new is set', async () => {
+        await askCommand.func(page, {
+            prompt: 'hi',
+            timeout: 120,
+            new: true,
+            model: 'sonnet',
+            think: false,
+        });
+
+        expect(page.goto).toHaveBeenCalledWith('https://claude.ai/new');
+        expect(mockEnsureOnClaude).not.toHaveBeenCalled();
+    });
+
+    it('throws EmptyResultError when waitForResponse yields nothing', async () => {
+        mockWaitForResponse.mockResolvedValue(null);
+
+        await expect(askCommand.func(page, {
+            prompt: 'hi',
+            timeout: 60,
+            new: false,
+            model: 'sonnet',
+            think: false,
+        })).rejects.toThrow(EmptyResultError);
+    });
+
+    it('throws CommandExecutionError when send fails', async () => {
+        mockSendMessage.mockResolvedValue({ ok: false, reason: 'composer not found' });
+
+        await expect(askCommand.func(page, {
+            prompt: 'hi',
+            timeout: 120,
+            new: false,
+            model: 'sonnet',
+            think: false,
+        })).rejects.toThrow(/composer not found/);
+    });
+});
+
+describe('claude ask --model handling', () => {
+    const page = {
+        wait: vi.fn().mockResolvedValue(undefined),
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn(),
+    };
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockEnsureOnClaude.mockResolvedValue(false);
+        mockSetAdaptiveThinking.mockResolvedValue({ ok: true, toggled: false });
+        mockSendMessage.mockResolvedValue({ ok: true });
+        mockGetBubbleCount.mockResolvedValue(0);
+        mockWaitForResponse.mockResolvedValue('reply');
+    });
+
+    it('rejects --model opus on free tier with usage-error guidance', async () => {
+        page.evaluate.mockResolvedValue('https://claude.ai/new');
+        mockSelectModel.mockResolvedValue({ ok: false, upgrade: true });
+
+        await expect(askCommand.func(page, {
+            prompt: 'hi',
+            timeout: 120,
+            new: false,
+            model: 'opus',
+            think: false,
+        })).rejects.toMatchObject(new ArgumentError(
+            'opus model requires a paid Claude plan.',
+            'Pick --model sonnet or --model haiku, or upgrade your account.',
+        ));
+    });
+
+    it('skips model selection inside an existing conversation', async () => {
+        page.evaluate.mockResolvedValue('https://claude.ai/chat/abc-123');
+
+        const rows = await askCommand.func(page, {
+            prompt: 'continue',
+            timeout: 120,
+            new: false,
+            model: 'sonnet',
+            think: false,
+        });
+
+        expect(rows).toEqual([{ response: 'reply' }]);
+        expect(mockSelectModel).not.toHaveBeenCalled();
+    });
+
+    it('fails fast when --model is explicit inside an existing conversation', async () => {
+        page.evaluate.mockResolvedValue('https://claude.ai/chat/abc-123');
+
+        await expect(askCommand.func(page, {
+            prompt: 'continue',
+            timeout: 120,
+            new: false,
+            model: 'opus',
+            think: false,
+            __opencliOptionSources: { model: 'cli' },
+        })).rejects.toMatchObject(new ArgumentError(
+            'Cannot switch to opus model inside an existing conversation.',
+            'Re-run with --new to start a fresh chat before selecting a model.',
+        ));
+
+        expect(mockSelectModel).not.toHaveBeenCalled();
+    });
+});
+
+describe('claude ask --think', () => {
+    const page = {
+        wait: vi.fn().mockResolvedValue(undefined),
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue('https://claude.ai/new'),
+    };
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockEnsureOnClaude.mockResolvedValue(false);
+        mockSelectModel.mockResolvedValue({ ok: true, toggled: false });
+        mockSendMessage.mockResolvedValue({ ok: true });
+        mockGetBubbleCount.mockResolvedValue(0);
+        mockWaitForResponse.mockResolvedValue('reply');
+    });
+
+    it('toggles Adaptive thinking when --think is set', async () => {
+        mockSetAdaptiveThinking.mockResolvedValue({ ok: true, toggled: true });
+
+        await askCommand.func(page, {
+            prompt: 'reason carefully',
+            timeout: 120,
+            new: false,
+            model: 'sonnet',
+            think: true,
+        });
+
+        expect(mockSetAdaptiveThinking).toHaveBeenCalledWith(page, true);
+    });
+
+    it('throws when --think requested but toggle fails', async () => {
+        mockSetAdaptiveThinking.mockResolvedValue({ ok: false });
+
+        await expect(askCommand.func(page, {
+            prompt: 'reason carefully',
+            timeout: 120,
+            new: false,
+            model: 'sonnet',
+            think: true,
+        })).rejects.toThrow(/Adaptive thinking/);
+    });
+
+    it('does not throw when --think is false and toggle returns ok=false', async () => {
+        mockSetAdaptiveThinking.mockResolvedValue({ ok: false });
+
+        await expect(askCommand.func(page, {
+            prompt: 'hi',
+            timeout: 120,
+            new: false,
+            model: 'sonnet',
+            think: false,
+        })).resolves.toEqual([{ response: 'reply' }]);
+    });
+
+    it('fails fast when prompt validation rejects an empty prompt', async () => {
+        mockRequireNonEmptyPrompt.mockImplementation(() => {
+            throw new ArgumentError('claude ask prompt cannot be empty');
+        });
+
+        await expect(askCommand.func(page, {
+            prompt: '',
+            timeout: 120,
+            new: false,
+            model: 'sonnet',
+            think: false,
+        })).rejects.toThrow(ArgumentError);
+    });
+
+    it('fails fast when timeout validation rejects a non-positive value', async () => {
+        mockRequirePositiveInt.mockImplementation(() => {
+            throw new ArgumentError('claude ask --timeout must be a positive integer');
+        });
+
+        await expect(askCommand.func(page, {
+            prompt: 'hi',
+            timeout: 0,
+            new: false,
+            model: 'sonnet',
+            think: false,
+        })).rejects.toThrow(ArgumentError);
+    });
+});
+
+describe('claude ask --file', () => {
+    const page = {
+        wait: vi.fn().mockResolvedValue(undefined),
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue('https://claude.ai/new'),
+    };
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockEnsureOnClaude.mockResolvedValue(false);
+        mockSelectModel.mockResolvedValue({ ok: true, toggled: false });
+        mockSetAdaptiveThinking.mockResolvedValue({ ok: true, toggled: false });
+        mockSendWithFile.mockResolvedValue({ ok: true });
+        mockGetBubbleCount.mockResolvedValue(3);
+        mockWaitForResponse.mockResolvedValue('the image shows a cat');
+        mockEnsureClaudeComposer.mockResolvedValue({ isLoggedIn: true, hasComposer: true });
+        mockRequireNonEmptyPrompt.mockImplementation((v) => String(v ?? ''));
+        mockRequirePositiveInt.mockImplementation((v) => Number(v));
+    });
+
+    it('routes through sendWithFile and captures baseline before sending', async () => {
+        const rows = await askCommand.func(page, {
+            prompt: 'describe this',
+            timeout: 120,
+            new: false,
+            model: 'sonnet',
+            think: false,
+            file: '/tmp/cat.png',
+        });
+
+        expect(rows).toEqual([{ response: 'the image shows a cat' }]);
+        expect(mockGetBubbleCount).toHaveBeenCalledTimes(1);
+        expect(mockSendWithFile).toHaveBeenCalledWith(page, '/tmp/cat.png', 'describe this');
+        expect(mockSendMessage).not.toHaveBeenCalled();
+        expect(mockWaitForResponse).toHaveBeenCalledWith(page, 3, 'describe this', 120000);
+    });
+
+    it('surfaces file upload failure as CommandExecutionError', async () => {
+        mockSendWithFile.mockResolvedValue({ ok: false, reason: 'file preview did not appear' });
+
+        await expect(askCommand.func(page, {
+            prompt: 'describe this',
+            timeout: 120,
+            new: false,
+            model: 'sonnet',
+            think: false,
+            file: '/tmp/cat.png',
+        })).rejects.toThrow(/file preview did not appear/);
+    });
+
+    it('absorbs "Promise was collected" SPA navigation error after send', async () => {
+        mockSendWithFile.mockRejectedValue(new Error('Promise was collected'));
+
+        const rows = await askCommand.func(page, {
+            prompt: 'describe this',
+            timeout: 120,
+            new: false,
+            model: 'sonnet',
+            think: false,
+            file: '/tmp/cat.png',
+        });
+
+        expect(rows).toEqual([{ response: 'the image shows a cat' }]);
+    });
+});

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,
+        }];
+    },
+});